Attachment 695473 Details for Bug 909569 – CoinPackedVectorTest.i

CoinPackedVectorTest.i

CoinPackedVectorTest.i (text/plain), 859.36 KB, created by Paulo Andrade on 2013-02-09 13:24:52 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Paulo Andrade

Created: 2013-02-09 13:24:52 UTC

Size: 859.36 KB

patch

obsolete

># 1 "CoinPackedVectorTest.cpp"
># 1 "/home/pcpa/rpmbuild/BUILD/CoinUtils-2.8.8/CoinUtils/test//"
># 1 "<command-line>"
># 1 "/usr/include/stdc-predef.h" 1 3 4
># 1 "<command-line>" 2
># 1 "CoinPackedVectorTest.cpp"
># 9 "CoinPackedVectorTest.cpp"
># 1 "/usr/include/c++/4.8.0/cassert" 1 3
># 41 "/usr/include/c++/4.8.0/cassert" 3
>       
># 42 "/usr/include/c++/4.8.0/cassert" 3
>
># 1 "/usr/include/assert.h" 1 3 4
># 36 "/usr/include/assert.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 375 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 385 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 386 "/usr/include/sys/cdefs.h" 2 3 4
># 376 "/usr/include/features.h" 2 3 4
># 399 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
># 10 "/usr/include/gnu/stubs.h" 3 4
># 1 "/usr/include/gnu/stubs-64.h" 1 3 4
># 11 "/usr/include/gnu/stubs.h" 2 3 4
># 400 "/usr/include/features.h" 2 3 4
># 37 "/usr/include/assert.h" 2 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
>      unsigned int __line, const char *__function)
>     throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
>      unsigned int __line, const char *__function)
>     throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
>     throw () __attribute__ ((__noreturn__));
>
>
>}
># 43 "/usr/include/c++/4.8.0/cassert" 2 3
># 10 "CoinPackedVectorTest.cpp" 2
>
># 1 "../src/CoinPragma.hpp" 1
># 12 "CoinPackedVectorTest.cpp" 2
># 1 "../src/CoinFloatEqual.hpp" 1
># 9 "../src/CoinFloatEqual.hpp"
># 1 "/usr/include/c++/4.8.0/algorithm" 1 3
># 58 "/usr/include/c++/4.8.0/algorithm" 3
>       
># 59 "/usr/include/c++/4.8.0/algorithm" 3
>
># 1 "/usr/include/c++/4.8.0/utility" 1 3
># 58 "/usr/include/c++/4.8.0/utility" 3
>       
># 59 "/usr/include/c++/4.8.0/utility" 3
># 68 "/usr/include/c++/4.8.0/utility" 3
># 1 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++config.h" 1 3
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 4 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++config.h" 2 3
># 1828 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++config.h" 3
>namespace std
>{
>  typedef long unsigned int size_t;
>  typedef long int ptrdiff_t;
>
>
>
>
>}
># 2070 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++config.h" 3
># 1 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/os_defines.h" 1 3
># 2071 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++config.h" 2 3
>
>
># 1 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
># 2074 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++config.h" 2 3
># 69 "/usr/include/c++/4.8.0/utility" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_relops.h" 1 3
># 67 "/usr/include/c++/4.8.0/bits/stl_relops.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>  namespace rel_ops
>  {
> 
># 85 "/usr/include/c++/4.8.0/bits/stl_relops.h" 3
>    template <class _Tp>
>      inline bool
>      operator!=(const _Tp& __x, const _Tp& __y)
>      { return !(__x == __y); }
># 98 "/usr/include/c++/4.8.0/bits/stl_relops.h" 3
>    template <class _Tp>
>      inline bool
>      operator>(const _Tp& __x, const _Tp& __y)
>      { return __y < __x; }
># 111 "/usr/include/c++/4.8.0/bits/stl_relops.h" 3
>    template <class _Tp>
>      inline bool
>      operator<=(const _Tp& __x, const _Tp& __y)
>      { return !(__y < __x); }
># 124 "/usr/include/c++/4.8.0/bits/stl_relops.h" 3
>    template <class _Tp>
>      inline bool
>      operator>=(const _Tp& __x, const _Tp& __y)
>      { return !(__x < __y); }
>
> 
>  }
>
>}
># 70 "/usr/include/c++/4.8.0/utility" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_pair.h" 1 3
># 59 "/usr/include/c++/4.8.0/bits/stl_pair.h" 3
># 1 "/usr/include/c++/4.8.0/bits/move.h" 1 3
># 34 "/usr/include/c++/4.8.0/bits/move.h" 3
># 1 "/usr/include/c++/4.8.0/bits/concept_check.h" 1 3
># 33 "/usr/include/c++/4.8.0/bits/concept_check.h" 3
>       
># 34 "/usr/include/c++/4.8.0/bits/concept_check.h" 3
># 35 "/usr/include/c++/4.8.0/bits/move.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>  template<typename _Tp>
>    inline _Tp*
>    __addressof(_Tp& __r)
>    {
>      return reinterpret_cast<_Tp*>
> (&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
>    }
>
>
>}
># 149 "/usr/include/c++/4.8.0/bits/move.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 164 "/usr/include/c++/4.8.0/bits/move.h" 3
>  template<typename _Tp>
>    inline void
>    swap(_Tp& __a, _Tp& __b)
>
>
>
>
>    {
>
>     
>
>      _Tp __tmp = (__a);
>      __a = (__b);
>      __b = (__tmp);
>    }
>
>
>
>
>  template<typename _Tp, size_t _Nm>
>    inline void
>    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
>
>
>
>    {
>      for (size_t __n = 0; __n < _Nm; ++__n)
> swap(__a[__n], __b[__n]);
>    }
>
>
>
>}
># 60 "/usr/include/c++/4.8.0/bits/stl_pair.h" 2 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 90 "/usr/include/c++/4.8.0/bits/stl_pair.h" 3
>  template<class _T1, class _T2>
>    struct pair
>    {
>      typedef _T1 first_type;
>      typedef _T2 second_type;
>
>      _T1 first;
>      _T2 second;
>
>
>
>
>
>      pair()
>      : first(), second() { }
>
>
>      pair(const _T1& __a, const _T2& __b)
>      : first(__a), second(__b) { }
>
>
>
>      template<class _U1, class _U2>
> pair(const pair<_U1, _U2>& __p)
> : first(__p.first), second(__p.second) { }
># 204 "/usr/include/c++/4.8.0/bits/stl_pair.h" 3
>    };
>
>
>  template<class _T1, class _T2>
>    inline bool
>    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
>    { return __x.first == __y.first && __x.second == __y.second; }
>
>
>  template<class _T1, class _T2>
>    inline bool
>    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
>    { return __x.first < __y.first
>      || (!(__y.first < __x.first) && __x.second < __y.second); }
>
>
>  template<class _T1, class _T2>
>    inline bool
>    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
>    { return !(__x == __y); }
>
>
>  template<class _T1, class _T2>
>    inline bool
>    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
>    { return __y < __x; }
>
>
>  template<class _T1, class _T2>
>    inline bool
>    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
>    { return !(__y < __x); }
>
>
>  template<class _T1, class _T2>
>    inline bool
>    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
>    { return !(__x < __y); }
># 279 "/usr/include/c++/4.8.0/bits/stl_pair.h" 3
>  template<class _T1, class _T2>
>    inline pair<_T1, _T2>
>    make_pair(_T1 __x, _T2 __y)
>    { return pair<_T1, _T2>(__x, __y); }
>
>
>
>}
># 71 "/usr/include/c++/4.8.0/utility" 2 3
># 61 "/usr/include/c++/4.8.0/algorithm" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 1 3
># 60 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
># 1 "/usr/include/c++/4.8.0/bits/functexcept.h" 1 3
># 40 "/usr/include/c++/4.8.0/bits/functexcept.h" 3
># 1 "/usr/include/c++/4.8.0/bits/exception_defines.h" 1 3
># 41 "/usr/include/c++/4.8.0/bits/functexcept.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>  void
>  __throw_bad_exception(void) __attribute__((__noreturn__));
>
>
>  void
>  __throw_bad_alloc(void) __attribute__((__noreturn__));
>
>
>  void
>  __throw_bad_cast(void) __attribute__((__noreturn__));
>
>  void
>  __throw_bad_typeid(void) __attribute__((__noreturn__));
>
>
>  void
>  __throw_logic_error(const char*) __attribute__((__noreturn__));
>
>  void
>  __throw_domain_error(const char*) __attribute__((__noreturn__));
>
>  void
>  __throw_invalid_argument(const char*) __attribute__((__noreturn__));
>
>  void
>  __throw_length_error(const char*) __attribute__((__noreturn__));
>
>  void
>  __throw_out_of_range(const char*) __attribute__((__noreturn__));
>
>  void
>  __throw_runtime_error(const char*) __attribute__((__noreturn__));
>
>  void
>  __throw_range_error(const char*) __attribute__((__noreturn__));
>
>  void
>  __throw_overflow_error(const char*) __attribute__((__noreturn__));
>
>  void
>  __throw_underflow_error(const char*) __attribute__((__noreturn__));
>
>
>  void
>  __throw_ios_failure(const char*) __attribute__((__noreturn__));
>
>  void
>  __throw_system_error(int) __attribute__((__noreturn__));
>
>  void
>  __throw_future_error(int) __attribute__((__noreturn__));
>
>
>  void
>  __throw_bad_function_call() __attribute__((__noreturn__));
>
>
>}
># 61 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/4.8.0/bits/cpp_type_traits.h" 1 3
># 35 "/usr/include/c++/4.8.0/bits/cpp_type_traits.h" 3
>       
># 36 "/usr/include/c++/4.8.0/bits/cpp_type_traits.h" 3
># 68 "/usr/include/c++/4.8.0/bits/cpp_type_traits.h" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _Iterator, typename _Container>
>    class __normal_iterator;
>
>
>}
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  struct __true_type { };
>  struct __false_type { };
>
>  template<bool>
>    struct __truth_type
>    { typedef __false_type __type; };
>
>  template<>
>    struct __truth_type<true>
>    { typedef __true_type __type; };
>
>
>
>  template<class _Sp, class _Tp>
>    struct __traitor
>    {
>      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
>      typedef typename __truth_type<__value>::__type __type;
>    };
>
>
>  template<typename, typename>
>    struct __are_same
>    {
>      enum { __value = 0 };
>      typedef __false_type __type;
>    };
>
>  template<typename _Tp>
>    struct __are_same<_Tp, _Tp>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>
>  template<typename _Tp>
>    struct __is_void
>    {
>      enum { __value = 0 };
>      typedef __false_type __type;
>    };
>
>  template<>
>    struct __is_void<void>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>
>
>
>  template<typename _Tp>
>    struct __is_integer
>    {
>      enum { __value = 0 };
>      typedef __false_type __type;
>    };
>
>
>
>
>  template<>
>    struct __is_integer<bool>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_integer<char>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_integer<signed char>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_integer<unsigned char>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>
>  template<>
>    struct __is_integer<wchar_t>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
># 198 "/usr/include/c++/4.8.0/bits/cpp_type_traits.h" 3
>  template<>
>    struct __is_integer<short>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_integer<unsigned short>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_integer<int>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_integer<unsigned int>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_integer<long>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_integer<unsigned long>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_integer<long long>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_integer<unsigned long long>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>
>
>
>  template<typename _Tp>
>    struct __is_floating
>    {
>      enum { __value = 0 };
>      typedef __false_type __type;
>    };
>
>
>  template<>
>    struct __is_floating<float>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_floating<double>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_floating<long double>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>
>
>
>  template<typename _Tp>
>    struct __is_pointer
>    {
>      enum { __value = 0 };
>      typedef __false_type __type;
>    };
>
>  template<typename _Tp>
>    struct __is_pointer<_Tp*>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>
>
>
>  template<typename _Tp>
>    struct __is_normal_iterator
>    {
>      enum { __value = 0 };
>      typedef __false_type __type;
>    };
>
>  template<typename _Iterator, typename _Container>
>    struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
>             _Container> >
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>
>
>
>  template<typename _Tp>
>    struct __is_arithmetic
>    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
>    { };
>
>
>
>
>  template<typename _Tp>
>    struct __is_fundamental
>    : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
>    { };
>
>
>
>
>  template<typename _Tp>
>    struct __is_scalar
>    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
>    { };
>
>
>
>
>  template<typename _Tp>
>    struct __is_char
>    {
>      enum { __value = 0 };
>      typedef __false_type __type;
>    };
>
>  template<>
>    struct __is_char<char>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>
>  template<>
>    struct __is_char<wchar_t>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>
>  template<typename _Tp>
>    struct __is_byte
>    {
>      enum { __value = 0 };
>      typedef __false_type __type;
>    };
>
>  template<>
>    struct __is_byte<char>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_byte<signed char>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>  template<>
>    struct __is_byte<unsigned char>
>    {
>      enum { __value = 1 };
>      typedef __true_type __type;
>    };
>
>
>
>
>  template<typename _Tp>
>    struct __is_move_iterator
>    {
>      enum { __value = 0 };
>      typedef __false_type __type;
>    };
># 421 "/usr/include/c++/4.8.0/bits/cpp_type_traits.h" 3
>
>}
># 62 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/4.8.0/ext/type_traits.h" 1 3
># 32 "/usr/include/c++/4.8.0/ext/type_traits.h" 3
>       
># 33 "/usr/include/c++/4.8.0/ext/type_traits.h" 3
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>  template<bool, typename>
>    struct __enable_if
>    { };
>
>  template<typename _Tp>
>    struct __enable_if<true, _Tp>
>    { typedef _Tp __type; };
>
>
>
>  template<bool _Cond, typename _Iftrue, typename _Iffalse>
>    struct __conditional_type
>    { typedef _Iftrue __type; };
>
>  template<typename _Iftrue, typename _Iffalse>
>    struct __conditional_type<false, _Iftrue, _Iffalse>
>    { typedef _Iffalse __type; };
>
>
>
>  template<typename _Tp>
>    struct __add_unsigned
>    {
>    private:
>      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
>
>    public:
>      typedef typename __if_type::__type __type;
>    };
>
>  template<>
>    struct __add_unsigned<char>
>    { typedef unsigned char __type; };
>
>  template<>
>    struct __add_unsigned<signed char>
>    { typedef unsigned char __type; };
>
>  template<>
>    struct __add_unsigned<short>
>    { typedef unsigned short __type; };
>
>  template<>
>    struct __add_unsigned<int>
>    { typedef unsigned int __type; };
>
>  template<>
>    struct __add_unsigned<long>
>    { typedef unsigned long __type; };
>
>  template<>
>    struct __add_unsigned<long long>
>    { typedef unsigned long long __type; };
>
>
>  template<>
>    struct __add_unsigned<bool>;
>
>  template<>
>    struct __add_unsigned<wchar_t>;
>
>
>
>  template<typename _Tp>
>    struct __remove_unsigned
>    {
>    private:
>      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
>
>    public:
>      typedef typename __if_type::__type __type;
>    };
>
>  template<>
>    struct __remove_unsigned<char>
>    { typedef signed char __type; };
>
>  template<>
>    struct __remove_unsigned<unsigned char>
>    { typedef signed char __type; };
>
>  template<>
>    struct __remove_unsigned<unsigned short>
>    { typedef short __type; };
>
>  template<>
>    struct __remove_unsigned<unsigned int>
>    { typedef int __type; };
>
>  template<>
>    struct __remove_unsigned<unsigned long>
>    { typedef long __type; };
>
>  template<>
>    struct __remove_unsigned<unsigned long long>
>    { typedef long long __type; };
>
>
>  template<>
>    struct __remove_unsigned<bool>;
>
>  template<>
>    struct __remove_unsigned<wchar_t>;
>
>
>
>  template<typename _Type>
>    inline bool
>    __is_null_pointer(_Type* __ptr)
>    { return __ptr == 0; }
>
>  template<typename _Type>
>    inline bool
>    __is_null_pointer(_Type)
>    { return false; }
>
>
>
>  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
>    struct __promote
>    { typedef double __type; };
>
>
>
>
>  template<typename _Tp>
>    struct __promote<_Tp, false>
>    { };
>
>  template<>
>    struct __promote<long double>
>    { typedef long double __type; };
>
>  template<>
>    struct __promote<double>
>    { typedef double __type; };
>
>  template<>
>    struct __promote<float>
>    { typedef float __type; };
>
>  template<typename _Tp, typename _Up,
>           typename _Tp2 = typename __promote<_Tp>::__type,
>           typename _Up2 = typename __promote<_Up>::__type>
>    struct __promote_2
>    {
>      typedef __typeof__(_Tp2() + _Up2()) __type;
>    };
>
>  template<typename _Tp, typename _Up, typename _Vp,
>           typename _Tp2 = typename __promote<_Tp>::__type,
>           typename _Up2 = typename __promote<_Up>::__type,
>           typename _Vp2 = typename __promote<_Vp>::__type>
>    struct __promote_3
>    {
>      typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
>    };
>
>  template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
>           typename _Tp2 = typename __promote<_Tp>::__type,
>           typename _Up2 = typename __promote<_Up>::__type,
>           typename _Vp2 = typename __promote<_Vp>::__type,
>           typename _Wp2 = typename __promote<_Wp>::__type>
>    struct __promote_4
>    {
>      typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
>    };
>
>
>}
># 63 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/4.8.0/ext/numeric_traits.h" 1 3
># 32 "/usr/include/c++/4.8.0/ext/numeric_traits.h" 3
>       
># 33 "/usr/include/c++/4.8.0/ext/numeric_traits.h" 3
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 54 "/usr/include/c++/4.8.0/ext/numeric_traits.h" 3
>  template<typename _Value>
>    struct __numeric_traits_integer
>    {
>
>      static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
>      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
>
>
>
>      static const bool __is_signed = ((_Value)(-1) < 0);
>      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
>    };
>
>  template<typename _Value>
>    const _Value __numeric_traits_integer<_Value>::__min;
>
>  template<typename _Value>
>    const _Value __numeric_traits_integer<_Value>::__max;
>
>  template<typename _Value>
>    const bool __numeric_traits_integer<_Value>::__is_signed;
>
>  template<typename _Value>
>    const int __numeric_traits_integer<_Value>::__digits;
># 99 "/usr/include/c++/4.8.0/ext/numeric_traits.h" 3
>  template<typename _Value>
>    struct __numeric_traits_floating
>    {
>
>      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
>
>
>      static const bool __is_signed = true;
>      static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
>      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
>    };
>
>  template<typename _Value>
>    const int __numeric_traits_floating<_Value>::__max_digits10;
>
>  template<typename _Value>
>    const bool __numeric_traits_floating<_Value>::__is_signed;
>
>  template<typename _Value>
>    const int __numeric_traits_floating<_Value>::__digits10;
>
>  template<typename _Value>
>    const int __numeric_traits_floating<_Value>::__max_exponent10;
>
>  template<typename _Value>
>    struct __numeric_traits
>    : public __conditional_type<std::__is_integer<_Value>::__value,
>    __numeric_traits_integer<_Value>,
>    __numeric_traits_floating<_Value> >::__type
>    { };
>
>
>}
># 64 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 2 3
>
># 1 "/usr/include/c++/4.8.0/bits/stl_iterator_base_types.h" 1 3
># 62 "/usr/include/c++/4.8.0/bits/stl_iterator_base_types.h" 3
>       
># 63 "/usr/include/c++/4.8.0/bits/stl_iterator_base_types.h" 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 89 "/usr/include/c++/4.8.0/bits/stl_iterator_base_types.h" 3
>  struct input_iterator_tag { };
>
>
>  struct output_iterator_tag { };
>
>
>  struct forward_iterator_tag : public input_iterator_tag { };
>
>
>
>  struct bidirectional_iterator_tag : public forward_iterator_tag { };
>
>
>
>  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
># 116 "/usr/include/c++/4.8.0/bits/stl_iterator_base_types.h" 3
>  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
>           typename _Pointer = _Tp*, typename _Reference = _Tp&>
>    struct iterator
>    {
>
>      typedef _Category iterator_category;
>
>      typedef _Tp value_type;
>
>      typedef _Distance difference_type;
>
>      typedef _Pointer pointer;
>
>      typedef _Reference reference;
>    };
># 162 "/usr/include/c++/4.8.0/bits/stl_iterator_base_types.h" 3
>  template<typename _Iterator>
>    struct iterator_traits
>    {
>      typedef typename _Iterator::iterator_category iterator_category;
>      typedef typename _Iterator::value_type value_type;
>      typedef typename _Iterator::difference_type difference_type;
>      typedef typename _Iterator::pointer pointer;
>      typedef typename _Iterator::reference reference;
>    };
>
>
>
>  template<typename _Tp>
>    struct iterator_traits<_Tp*>
>    {
>      typedef random_access_iterator_tag iterator_category;
>      typedef _Tp value_type;
>      typedef ptrdiff_t difference_type;
>      typedef _Tp* pointer;
>      typedef _Tp& reference;
>    };
>
>
>  template<typename _Tp>
>    struct iterator_traits<const _Tp*>
>    {
>      typedef random_access_iterator_tag iterator_category;
>      typedef _Tp value_type;
>      typedef ptrdiff_t difference_type;
>      typedef const _Tp* pointer;
>      typedef const _Tp& reference;
>    };
>
>
>
>
>
>  template<typename _Iter>
>    inline typename iterator_traits<_Iter>::iterator_category
>    __iterator_category(const _Iter&)
>    { return typename iterator_traits<_Iter>::iterator_category(); }
>
>
>
>
>
>  template<typename _Iterator, bool _HasBase>
>    struct _Iter_base
>    {
>      typedef _Iterator iterator_type;
>      static iterator_type _S_base(_Iterator __it)
>      { return __it; }
>    };
>
>  template<typename _Iterator>
>    struct _Iter_base<_Iterator, true>
>    {
>      typedef typename _Iterator::iterator_type iterator_type;
>      static iterator_type _S_base(_Iterator __it)
>      { return __it.base(); }
>    };
># 232 "/usr/include/c++/4.8.0/bits/stl_iterator_base_types.h" 3
>
>}
># 66 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_iterator_base_funcs.h" 1 3
># 62 "/usr/include/c++/4.8.0/bits/stl_iterator_base_funcs.h" 3
>       
># 63 "/usr/include/c++/4.8.0/bits/stl_iterator_base_funcs.h" 3
>
>
># 1 "/usr/include/c++/4.8.0/debug/debug.h" 1 3
># 46 "/usr/include/c++/4.8.0/debug/debug.h" 3
>namespace std
>{
>  namespace __debug { }
>}
>
>
>
>
>namespace __gnu_debug
>{
>  using namespace std::__debug;
>}
># 66 "/usr/include/c++/4.8.0/bits/stl_iterator_base_funcs.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _InputIterator>
>    inline typename iterator_traits<_InputIterator>::difference_type
>    __distance(_InputIterator __first, _InputIterator __last,
>               input_iterator_tag)
>    {
>
>     
>
>      typename iterator_traits<_InputIterator>::difference_type __n = 0;
>      while (__first != __last)
> {
>   ++__first;
>   ++__n;
> }
>      return __n;
>    }
>
>  template<typename _RandomAccessIterator>
>    inline typename iterator_traits<_RandomAccessIterator>::difference_type
>    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
>               random_access_iterator_tag)
>    {
>
>     
>
>      return __last - __first;
>    }
># 112 "/usr/include/c++/4.8.0/bits/stl_iterator_base_funcs.h" 3
>  template<typename _InputIterator>
>    inline typename iterator_traits<_InputIterator>::difference_type
>    distance(_InputIterator __first, _InputIterator __last)
>    {
>
>      return std::__distance(__first, __last,
>        std::__iterator_category(__first));
>    }
>
>  template<typename _InputIterator, typename _Distance>
>    inline void
>    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
>    {
>
>     
>      ;
>      while (__n--)
> ++__i;
>    }
>
>  template<typename _BidirectionalIterator, typename _Distance>
>    inline void
>    __advance(_BidirectionalIterator& __i, _Distance __n,
>       bidirectional_iterator_tag)
>    {
>
>     
>
>      if (__n > 0)
>        while (__n--)
>   ++__i;
>      else
>        while (__n++)
>   --__i;
>    }
>
>  template<typename _RandomAccessIterator, typename _Distance>
>    inline void
>    __advance(_RandomAccessIterator& __i, _Distance __n,
>              random_access_iterator_tag)
>    {
>
>     
>
>      __i += __n;
>    }
># 171 "/usr/include/c++/4.8.0/bits/stl_iterator_base_funcs.h" 3
>  template<typename _InputIterator, typename _Distance>
>    inline void
>    advance(_InputIterator& __i, _Distance __n)
>    {
>
>      typename iterator_traits<_InputIterator>::difference_type __d = __n;
>      std::__advance(__i, __d, std::__iterator_category(__i));
>    }
># 202 "/usr/include/c++/4.8.0/bits/stl_iterator_base_funcs.h" 3
>
>}
># 67 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 1 3
># 67 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 95 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>  template<typename _Iterator>
>    class reverse_iterator
>    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
>        typename iterator_traits<_Iterator>::value_type,
>        typename iterator_traits<_Iterator>::difference_type,
>        typename iterator_traits<_Iterator>::pointer,
>                      typename iterator_traits<_Iterator>::reference>
>    {
>    protected:
>      _Iterator current;
>
>      typedef iterator_traits<_Iterator> __traits_type;
>
>    public:
>      typedef _Iterator iterator_type;
>      typedef typename __traits_type::difference_type difference_type;
>      typedef typename __traits_type::pointer pointer;
>      typedef typename __traits_type::reference reference;
>
>
>
>
>
>
>
>      reverse_iterator() : current() { }
>
>
>
>
>      explicit
>      reverse_iterator(iterator_type __x) : current(__x) { }
>
>
>
>
>      reverse_iterator(const reverse_iterator& __x)
>      : current(__x.current) { }
>
>
>
>
>
>      template<typename _Iter>
>        reverse_iterator(const reverse_iterator<_Iter>& __x)
> : current(__x.base()) { }
>
>
>
>
>      iterator_type
>      base() const
>      { return current; }
># 159 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>      reference
>      operator*() const
>      {
> _Iterator __tmp = current;
> return *--__tmp;
>      }
>
>
>
>
>
>
>      pointer
>      operator->() const
>      { return &(operator*()); }
>
>
>
>
>
>
>      reverse_iterator&
>      operator++()
>      {
> --current;
> return *this;
>      }
>
>
>
>
>
>
>      reverse_iterator
>      operator++(int)
>      {
> reverse_iterator __tmp = *this;
> --current;
> return __tmp;
>      }
>
>
>
>
>
>
>      reverse_iterator&
>      operator--()
>      {
> ++current;
> return *this;
>      }
>
>
>
>
>
>
>      reverse_iterator
>      operator--(int)
>      {
> reverse_iterator __tmp = *this;
> ++current;
> return __tmp;
>      }
>
>
>
>
>
>
>      reverse_iterator
>      operator+(difference_type __n) const
>      { return reverse_iterator(current - __n); }
>
>
>
>
>
>
>
>      reverse_iterator&
>      operator+=(difference_type __n)
>      {
> current -= __n;
> return *this;
>      }
>
>
>
>
>
>
>      reverse_iterator
>      operator-(difference_type __n) const
>      { return reverse_iterator(current + __n); }
>
>
>
>
>
>
>
>      reverse_iterator&
>      operator-=(difference_type __n)
>      {
> current += __n;
> return *this;
>      }
>
>
>
>
>
>
>      reference
>      operator[](difference_type __n) const
>      { return *(*this + __n); }
>    };
># 289 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>  template<typename _Iterator>
>    inline bool
>    operator==(const reverse_iterator<_Iterator>& __x,
>        const reverse_iterator<_Iterator>& __y)
>    { return __x.base() == __y.base(); }
>
>  template<typename _Iterator>
>    inline bool
>    operator<(const reverse_iterator<_Iterator>& __x,
>       const reverse_iterator<_Iterator>& __y)
>    { return __y.base() < __x.base(); }
>
>  template<typename _Iterator>
>    inline bool
>    operator!=(const reverse_iterator<_Iterator>& __x,
>        const reverse_iterator<_Iterator>& __y)
>    { return !(__x == __y); }
>
>  template<typename _Iterator>
>    inline bool
>    operator>(const reverse_iterator<_Iterator>& __x,
>       const reverse_iterator<_Iterator>& __y)
>    { return __y < __x; }
>
>  template<typename _Iterator>
>    inline bool
>    operator<=(const reverse_iterator<_Iterator>& __x,
>        const reverse_iterator<_Iterator>& __y)
>    { return !(__y < __x); }
>
>  template<typename _Iterator>
>    inline bool
>    operator>=(const reverse_iterator<_Iterator>& __x,
>        const reverse_iterator<_Iterator>& __y)
>    { return !(__x < __y); }
>
>  template<typename _Iterator>
>    inline typename reverse_iterator<_Iterator>::difference_type
>    operator-(const reverse_iterator<_Iterator>& __x,
>       const reverse_iterator<_Iterator>& __y)
>    { return __y.base() - __x.base(); }
>
>  template<typename _Iterator>
>    inline reverse_iterator<_Iterator>
>    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
>       const reverse_iterator<_Iterator>& __x)
>    { return reverse_iterator<_Iterator>(__x.base() - __n); }
>
>
>
>  template<typename _IteratorL, typename _IteratorR>
>    inline bool
>    operator==(const reverse_iterator<_IteratorL>& __x,
>        const reverse_iterator<_IteratorR>& __y)
>    { return __x.base() == __y.base(); }
>
>  template<typename _IteratorL, typename _IteratorR>
>    inline bool
>    operator<(const reverse_iterator<_IteratorL>& __x,
>       const reverse_iterator<_IteratorR>& __y)
>    { return __y.base() < __x.base(); }
>
>  template<typename _IteratorL, typename _IteratorR>
>    inline bool
>    operator!=(const reverse_iterator<_IteratorL>& __x,
>        const reverse_iterator<_IteratorR>& __y)
>    { return !(__x == __y); }
>
>  template<typename _IteratorL, typename _IteratorR>
>    inline bool
>    operator>(const reverse_iterator<_IteratorL>& __x,
>       const reverse_iterator<_IteratorR>& __y)
>    { return __y < __x; }
>
>  template<typename _IteratorL, typename _IteratorR>
>    inline bool
>    operator<=(const reverse_iterator<_IteratorL>& __x,
>        const reverse_iterator<_IteratorR>& __y)
>    { return !(__y < __x); }
>
>  template<typename _IteratorL, typename _IteratorR>
>    inline bool
>    operator>=(const reverse_iterator<_IteratorL>& __x,
>        const reverse_iterator<_IteratorR>& __y)
>    { return !(__x < __y); }
>
>  template<typename _IteratorL, typename _IteratorR>
>
>
>
>
>
>
>
>    inline typename reverse_iterator<_IteratorL>::difference_type
>    operator-(const reverse_iterator<_IteratorL>& __x,
>       const reverse_iterator<_IteratorR>& __y)
>
>    { return __y.base() - __x.base(); }
># 401 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>  template<typename _Container>
>    class back_insert_iterator
>    : public iterator<output_iterator_tag, void, void, void, void>
>    {
>    protected:
>      _Container* container;
>
>    public:
>
>      typedef _Container container_type;
>
>
>      explicit
>      back_insert_iterator(_Container& __x) : container(&__x) { }
># 428 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>      back_insert_iterator&
>      operator=(typename _Container::const_reference __value)
>      {
> container->push_back(__value);
> return *this;
>      }
># 451 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>      back_insert_iterator&
>      operator*()
>      { return *this; }
>
>
>      back_insert_iterator&
>      operator++()
>      { return *this; }
>
>
>      back_insert_iterator
>      operator++(int)
>      { return *this; }
>    };
># 477 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>  template<typename _Container>
>    inline back_insert_iterator<_Container>
>    back_inserter(_Container& __x)
>    { return back_insert_iterator<_Container>(__x); }
># 492 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>  template<typename _Container>
>    class front_insert_iterator
>    : public iterator<output_iterator_tag, void, void, void, void>
>    {
>    protected:
>      _Container* container;
>
>    public:
>
>      typedef _Container container_type;
>
>
>      explicit front_insert_iterator(_Container& __x) : container(&__x) { }
># 518 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>      front_insert_iterator&
>      operator=(typename _Container::const_reference __value)
>      {
> container->push_front(__value);
> return *this;
>      }
># 541 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>      front_insert_iterator&
>      operator*()
>      { return *this; }
>
>
>      front_insert_iterator&
>      operator++()
>      { return *this; }
>
>
>      front_insert_iterator
>      operator++(int)
>      { return *this; }
>    };
># 567 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>  template<typename _Container>
>    inline front_insert_iterator<_Container>
>    front_inserter(_Container& __x)
>    { return front_insert_iterator<_Container>(__x); }
># 586 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>  template<typename _Container>
>    class insert_iterator
>    : public iterator<output_iterator_tag, void, void, void, void>
>    {
>    protected:
>      _Container* container;
>      typename _Container::iterator iter;
>
>    public:
>
>      typedef _Container container_type;
>
>
>
>
>
>      insert_iterator(_Container& __x, typename _Container::iterator __i)
>      : container(&__x), iter(__i) {}
># 629 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>      insert_iterator&
>      operator=(typename _Container::const_reference __value)
>      {
> iter = container->insert(iter, __value);
> ++iter;
> return *this;
>      }
># 655 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>      insert_iterator&
>      operator*()
>      { return *this; }
>
>
>      insert_iterator&
>      operator++()
>      { return *this; }
>
>
>      insert_iterator&
>      operator++(int)
>      { return *this; }
>    };
># 681 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>  template<typename _Container, typename _Iterator>
>    inline insert_iterator<_Container>
>    inserter(_Container& __x, _Iterator __i)
>    {
>      return insert_iterator<_Container>(__x,
>      typename _Container::iterator(__i));
>    }
>
>
>
>
>}
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 705 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>  using std::iterator_traits;
>  using std::iterator;
>  template<typename _Iterator, typename _Container>
>    class __normal_iterator
>    {
>    protected:
>      _Iterator _M_current;
>
>      typedef iterator_traits<_Iterator> __traits_type;
>
>    public:
>      typedef _Iterator iterator_type;
>      typedef typename __traits_type::iterator_category iterator_category;
>      typedef typename __traits_type::value_type value_type;
>      typedef typename __traits_type::difference_type difference_type;
>      typedef typename __traits_type::reference reference;
>      typedef typename __traits_type::pointer pointer;
>
>      __normal_iterator() : _M_current(_Iterator()) { }
>
>      explicit
>      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
>
>
>      template<typename _Iter>
>        __normal_iterator(const __normal_iterator<_Iter,
>     typename __enable_if<
>              (std::__are_same<_Iter, typename _Container::pointer>::__value),
>        _Container>::__type>& __i)
>        : _M_current(__i.base()) { }
>
>
>      reference
>      operator*() const
>      { return *_M_current; }
>
>      pointer
>      operator->() const
>      { return _M_current; }
>
>      __normal_iterator&
>      operator++()
>      {
> ++_M_current;
> return *this;
>      }
>
>      __normal_iterator
>      operator++(int)
>      { return __normal_iterator(_M_current++); }
>
>
>      __normal_iterator&
>      operator--()
>      {
> --_M_current;
> return *this;
>      }
>
>      __normal_iterator
>      operator--(int)
>      { return __normal_iterator(_M_current--); }
>
>
>      reference
>      operator[](const difference_type& __n) const
>      { return _M_current[__n]; }
>
>      __normal_iterator&
>      operator+=(const difference_type& __n)
>      { _M_current += __n; return *this; }
>
>      __normal_iterator
>      operator+(const difference_type& __n) const
>      { return __normal_iterator(_M_current + __n); }
>
>      __normal_iterator&
>      operator-=(const difference_type& __n)
>      { _M_current -= __n; return *this; }
>
>      __normal_iterator
>      operator-(const difference_type& __n) const
>      { return __normal_iterator(_M_current - __n); }
>
>      const _Iterator&
>      base() const
>      { return _M_current; }
>    };
># 803 "/usr/include/c++/4.8.0/bits/stl_iterator.h" 3
>  template<typename _IteratorL, typename _IteratorR, typename _Container>
>    inline bool
>    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
>        const __normal_iterator<_IteratorR, _Container>& __rhs)
>    { return __lhs.base() == __rhs.base(); }
>
>  template<typename _Iterator, typename _Container>
>    inline bool
>    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
>        const __normal_iterator<_Iterator, _Container>& __rhs)
>    { return __lhs.base() == __rhs.base(); }
>
>  template<typename _IteratorL, typename _IteratorR, typename _Container>
>    inline bool
>    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
>        const __normal_iterator<_IteratorR, _Container>& __rhs)
>    { return __lhs.base() != __rhs.base(); }
>
>  template<typename _Iterator, typename _Container>
>    inline bool
>    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
>        const __normal_iterator<_Iterator, _Container>& __rhs)
>    { return __lhs.base() != __rhs.base(); }
>
>
>  template<typename _IteratorL, typename _IteratorR, typename _Container>
>    inline bool
>    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
>       const __normal_iterator<_IteratorR, _Container>& __rhs)
>    { return __lhs.base() < __rhs.base(); }
>
>  template<typename _Iterator, typename _Container>
>    inline bool
>    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
>       const __normal_iterator<_Iterator, _Container>& __rhs)
>    { return __lhs.base() < __rhs.base(); }
>
>  template<typename _IteratorL, typename _IteratorR, typename _Container>
>    inline bool
>    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
>       const __normal_iterator<_IteratorR, _Container>& __rhs)
>    { return __lhs.base() > __rhs.base(); }
>
>  template<typename _Iterator, typename _Container>
>    inline bool
>    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
>       const __normal_iterator<_Iterator, _Container>& __rhs)
>    { return __lhs.base() > __rhs.base(); }
>
>  template<typename _IteratorL, typename _IteratorR, typename _Container>
>    inline bool
>    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
>        const __normal_iterator<_IteratorR, _Container>& __rhs)
>    { return __lhs.base() <= __rhs.base(); }
>
>  template<typename _Iterator, typename _Container>
>    inline bool
>    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
>        const __normal_iterator<_Iterator, _Container>& __rhs)
>    { return __lhs.base() <= __rhs.base(); }
>
>  template<typename _IteratorL, typename _IteratorR, typename _Container>
>    inline bool
>    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
>        const __normal_iterator<_IteratorR, _Container>& __rhs)
>    { return __lhs.base() >= __rhs.base(); }
>
>  template<typename _Iterator, typename _Container>
>    inline bool
>    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
>        const __normal_iterator<_Iterator, _Container>& __rhs)
>    { return __lhs.base() >= __rhs.base(); }
>
>
>
>
>
>  template<typename _IteratorL, typename _IteratorR, typename _Container>
>
>
>
>
>
>
>
>    inline typename __normal_iterator<_IteratorL, _Container>::difference_type
>    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
>       const __normal_iterator<_IteratorR, _Container>& __rhs)
>
>    { return __lhs.base() - __rhs.base(); }
>
>  template<typename _Iterator, typename _Container>
>    inline typename __normal_iterator<_Iterator, _Container>::difference_type
>    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
>       const __normal_iterator<_Iterator, _Container>& __rhs)
>    { return __lhs.base() - __rhs.base(); }
>
>  template<typename _Iterator, typename _Container>
>    inline __normal_iterator<_Iterator, _Container>
>    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
>       __n, const __normal_iterator<_Iterator, _Container>& __i)
>    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
>
>
>}
># 68 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 2 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>  template<bool _BoolType>
>    struct __iter_swap
>    {
>      template<typename _ForwardIterator1, typename _ForwardIterator2>
>        static void
>        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
>        {
>          typedef typename iterator_traits<_ForwardIterator1>::value_type
>            _ValueType1;
>          _ValueType1 __tmp = (*__a);
>          *__a = (*__b);
>          *__b = (__tmp);
> }
>    };
>
>  template<>
>    struct __iter_swap<true>
>    {
>      template<typename _ForwardIterator1, typename _ForwardIterator2>
>        static void
>        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
>        {
>          swap(*__a, *__b);
>        }
>    };
># 117 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _ForwardIterator1, typename _ForwardIterator2>
>    inline void
>    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
>    {
>
>     
>
>     
>
>
>
>      typedef typename iterator_traits<_ForwardIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_ForwardIterator2>::value_type
> _ValueType2;
>
>     
>
>     
>
>
>      typedef typename iterator_traits<_ForwardIterator1>::reference
> _ReferenceType1;
>      typedef typename iterator_traits<_ForwardIterator2>::reference
> _ReferenceType2;
>      std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value
> && __are_same<_ValueType1&, _ReferenceType1>::__value
> && __are_same<_ValueType2&, _ReferenceType2>::__value>::
> iter_swap(__a, __b);
>
>
>
>    }
># 163 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _ForwardIterator1, typename _ForwardIterator2>
>    _ForwardIterator2
>    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>  _ForwardIterator2 __first2)
>    {
>
>     
>
>     
>
>      ;
>
>      for (; __first1 != __last1; ++__first1, ++__first2)
> std::iter_swap(__first1, __first2);
>      return __first2;
>    }
># 191 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _Tp>
>    inline const _Tp&
>    min(const _Tp& __a, const _Tp& __b)
>    {
>
>     
>
>      if (__b < __a)
> return __b;
>      return __a;
>    }
># 214 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _Tp>
>    inline const _Tp&
>    max(const _Tp& __a, const _Tp& __b)
>    {
>
>     
>
>      if (__a < __b)
> return __b;
>      return __a;
>    }
># 237 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _Tp, typename _Compare>
>    inline const _Tp&
>    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
>    {
>
>      if (__comp(__b, __a))
> return __b;
>      return __a;
>    }
># 258 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _Tp, typename _Compare>
>    inline const _Tp&
>    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
>    {
>
>      if (__comp(__a, __b))
> return __b;
>      return __a;
>    }
>
>
>
>  template<typename _Iterator>
>    struct _Niter_base
>    : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
>    { };
>
>  template<typename _Iterator>
>    inline typename _Niter_base<_Iterator>::iterator_type
>    __niter_base(_Iterator __it)
>    { return std::_Niter_base<_Iterator>::_S_base(__it); }
>
>
>  template<typename _Iterator>
>    struct _Miter_base
>    : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
>    { };
>
>  template<typename _Iterator>
>    inline typename _Miter_base<_Iterator>::iterator_type
>    __miter_base(_Iterator __it)
>    { return std::_Miter_base<_Iterator>::_S_base(__it); }
>
>
>
>
>
>
>
>  template<bool, bool, typename>
>    struct __copy_move
>    {
>      template<typename _II, typename _OI>
>        static _OI
>        __copy_m(_II __first, _II __last, _OI __result)
>        {
>   for (; __first != __last; ++__result, ++__first)
>     *__result = *__first;
>   return __result;
> }
>    };
># 325 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<>
>    struct __copy_move<false, false, random_access_iterator_tag>
>    {
>      template<typename _II, typename _OI>
>        static _OI
>        __copy_m(_II __first, _II __last, _OI __result)
>        {
>   typedef typename iterator_traits<_II>::difference_type _Distance;
>   for(_Distance __n = __last - __first; __n > 0; --__n)
>     {
>       *__result = *__first;
>       ++__first;
>       ++__result;
>     }
>   return __result;
> }
>    };
># 363 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<bool _IsMove>
>    struct __copy_move<_IsMove, true, random_access_iterator_tag>
>    {
>      template<typename _Tp>
>        static _Tp*
>        __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
>        {
>   const ptrdiff_t _Num = __last - __first;
>   if (_Num)
>     __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
>   return __result + _Num;
> }
>    };
>
>  template<bool _IsMove, typename _II, typename _OI>
>    inline _OI
>    __copy_move_a(_II __first, _II __last, _OI __result)
>    {
>      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
>      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
>      typedef typename iterator_traits<_II>::iterator_category _Category;
>      const bool __simple = (__is_trivial(_ValueTypeI)
>                      && __is_pointer<_II>::__value
>                      && __is_pointer<_OI>::__value
>        && __are_same<_ValueTypeI, _ValueTypeO>::__value);
>
>      return std::__copy_move<_IsMove, __simple,
>                       _Category>::__copy_m(__first, __last, __result);
>    }
>
>
>
>  template<typename _CharT>
>    struct char_traits;
>
>  template<typename _CharT, typename _Traits>
>    class istreambuf_iterator;
>
>  template<typename _CharT, typename _Traits>
>    class ostreambuf_iterator;
>
>  template<bool _IsMove, typename _CharT>
>    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
>      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
>    __copy_move_a2(_CharT*, _CharT*,
>     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
>
>  template<bool _IsMove, typename _CharT>
>    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
>      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
>    __copy_move_a2(const _CharT*, const _CharT*,
>     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
>
>  template<bool _IsMove, typename _CharT>
>    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
>        _CharT*>::__type
>    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
>     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
>
>  template<bool _IsMove, typename _II, typename _OI>
>    inline _OI
>    __copy_move_a2(_II __first, _II __last, _OI __result)
>    {
>      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
>          std::__niter_base(__last),
>          std::__niter_base(__result)));
>    }
># 448 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _II, typename _OI>
>    inline _OI
>    copy(_II __first, _II __last, _OI __result)
>    {
>
>     
>     
>
>      ;
>
>      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
>       (std::__miter_base(__first), std::__miter_base(__last),
>        __result));
>    }
># 500 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<bool, bool, typename>
>    struct __copy_move_backward
>    {
>      template<typename _BI1, typename _BI2>
>        static _BI2
>        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
>        {
>   while (__first != __last)
>     *--__result = *--__last;
>   return __result;
> }
>    };
># 528 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<>
>    struct __copy_move_backward<false, false, random_access_iterator_tag>
>    {
>      template<typename _BI1, typename _BI2>
>        static _BI2
>        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
>        {
>   typename iterator_traits<_BI1>::difference_type __n;
>   for (__n = __last - __first; __n > 0; --__n)
>     *--__result = *--__last;
>   return __result;
> }
>    };
># 558 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<bool _IsMove>
>    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
>    {
>      template<typename _Tp>
>        static _Tp*
>        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
>        {
>   const ptrdiff_t _Num = __last - __first;
>   if (_Num)
>     __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
>   return __result - _Num;
> }
>    };
>
>  template<bool _IsMove, typename _BI1, typename _BI2>
>    inline _BI2
>    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
>    {
>      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
>      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
>      typedef typename iterator_traits<_BI1>::iterator_category _Category;
>      const bool __simple = (__is_trivial(_ValueType1)
>                      && __is_pointer<_BI1>::__value
>                      && __is_pointer<_BI2>::__value
>        && __are_same<_ValueType1, _ValueType2>::__value);
>
>      return std::__copy_move_backward<_IsMove, __simple,
>                                _Category>::__copy_move_b(__first,
>         __last,
>         __result);
>    }
>
>  template<bool _IsMove, typename _BI1, typename _BI2>
>    inline _BI2
>    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
>    {
>      return _BI2(std::__copy_move_backward_a<_IsMove>
>    (std::__niter_base(__first), std::__niter_base(__last),
>     std::__niter_base(__result)));
>    }
># 617 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _BI1, typename _BI2>
>    inline _BI2
>    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
>    {
>
>     
>     
>     
>
>
>      ;
>
>      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
>       (std::__miter_base(__first), std::__miter_base(__last),
>        __result));
>    }
># 675 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _ForwardIterator, typename _Tp>
>    inline typename
>    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
>    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
>       const _Tp& __value)
>    {
>      for (; __first != __last; ++__first)
> *__first = __value;
>    }
>
>  template<typename _ForwardIterator, typename _Tp>
>    inline typename
>    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
>    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
>      const _Tp& __value)
>    {
>      const _Tp __tmp = __value;
>      for (; __first != __last; ++__first)
> *__first = __tmp;
>    }
>
>
>  template<typename _Tp>
>    inline typename
>    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
>    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
>    {
>      const _Tp __tmp = __c;
>      __builtin_memset(__first, static_cast<unsigned char>(__tmp),
>         __last - __first);
>    }
># 719 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _ForwardIterator, typename _Tp>
>    inline void
>    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
>    {
>
>     
>
>      ;
>
>      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
>      __value);
>    }
>
>  template<typename _OutputIterator, typename _Size, typename _Tp>
>    inline typename
>    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
>    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
>    {
>      for (__decltype(__n + 0) __niter = __n;
>    __niter > 0; --__niter, ++__first)
> *__first = __value;
>      return __first;
>    }
>
>  template<typename _OutputIterator, typename _Size, typename _Tp>
>    inline typename
>    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
>    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
>    {
>      const _Tp __tmp = __value;
>      for (__decltype(__n + 0) __niter = __n;
>    __niter > 0; --__niter, ++__first)
> *__first = __tmp;
>      return __first;
>    }
>
>  template<typename _Size, typename _Tp>
>    inline typename
>    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
>    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
>    {
>      std::__fill_a(__first, __first + __n, __c);
>      return __first + __n;
>    }
># 779 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _OI, typename _Size, typename _Tp>
>    inline _OI
>    fill_n(_OI __first, _Size __n, const _Tp& __value)
>    {
>
>     
>
>      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
>    }
>
>  template<bool _BoolType>
>    struct __equal
>    {
>      template<typename _II1, typename _II2>
>        static bool
>        equal(_II1 __first1, _II1 __last1, _II2 __first2)
>        {
>   for (; __first1 != __last1; ++__first1, ++__first2)
>     if (!(*__first1 == *__first2))
>       return false;
>   return true;
> }
>    };
>
>  template<>
>    struct __equal<true>
>    {
>      template<typename _Tp>
>        static bool
>        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
>        {
>   return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
>       * (__last1 - __first1));
> }
>    };
>
>  template<typename _II1, typename _II2>
>    inline bool
>    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
>    {
>      typedef typename iterator_traits<_II1>::value_type _ValueType1;
>      typedef typename iterator_traits<_II2>::value_type _ValueType2;
>      const bool __simple = ((__is_integer<_ValueType1>::__value
>         || __is_pointer<_ValueType1>::__value)
>                      && __is_pointer<_II1>::__value
>                      && __is_pointer<_II2>::__value
>        && __are_same<_ValueType1, _ValueType2>::__value);
>
>      return std::__equal<__simple>::equal(__first1, __last1, __first2);
>    }
>
>
>  template<typename, typename>
>    struct __lc_rai
>    {
>      template<typename _II1, typename _II2>
>        static _II1
>        __newlast1(_II1, _II1 __last1, _II2, _II2)
>        { return __last1; }
>
>      template<typename _II>
>        static bool
>        __cnd2(_II __first, _II __last)
>        { return __first != __last; }
>    };
>
>  template<>
>    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
>    {
>      template<typename _RAI1, typename _RAI2>
>        static _RAI1
>        __newlast1(_RAI1 __first1, _RAI1 __last1,
>     _RAI2 __first2, _RAI2 __last2)
>        {
>   const typename iterator_traits<_RAI1>::difference_type
>     __diff1 = __last1 - __first1;
>   const typename iterator_traits<_RAI2>::difference_type
>     __diff2 = __last2 - __first2;
>   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
> }
>
>      template<typename _RAI>
>        static bool
>        __cnd2(_RAI, _RAI)
>        { return true; }
>    };
>
>  template<bool _BoolType>
>    struct __lexicographical_compare
>    {
>      template<typename _II1, typename _II2>
>        static bool __lc(_II1, _II1, _II2, _II2);
>    };
>
>  template<bool _BoolType>
>    template<typename _II1, typename _II2>
>      bool
>      __lexicographical_compare<_BoolType>::
>      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
>      {
> typedef typename iterator_traits<_II1>::iterator_category _Category1;
> typedef typename iterator_traits<_II2>::iterator_category _Category2;
> typedef std::__lc_rai<_Category1, _Category2> __rai_type;
>
> __last1 = __rai_type::__newlast1(__first1, __last1,
>      __first2, __last2);
> for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
>      ++__first1, ++__first2)
>   {
>     if (*__first1 < *__first2)
>       return true;
>     if (*__first2 < *__first1)
>       return false;
>   }
> return __first1 == __last1 && __first2 != __last2;
>      }
>
>  template<>
>    struct __lexicographical_compare<true>
>    {
>      template<typename _Tp, typename _Up>
>        static bool
>        __lc(const _Tp* __first1, const _Tp* __last1,
>      const _Up* __first2, const _Up* __last2)
> {
>   const size_t __len1 = __last1 - __first1;
>   const size_t __len2 = __last2 - __first2;
>   const int __result = __builtin_memcmp(__first1, __first2,
>      std::min(__len1, __len2));
>   return __result != 0 ? __result < 0 : __len1 < __len2;
> }
>    };
>
>  template<typename _II1, typename _II2>
>    inline bool
>    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
>      _II2 __first2, _II2 __last2)
>    {
>      typedef typename iterator_traits<_II1>::value_type _ValueType1;
>      typedef typename iterator_traits<_II2>::value_type _ValueType2;
>      const bool __simple =
> (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
>  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
>  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
>  && __is_pointer<_II1>::__value
>  && __is_pointer<_II2>::__value);
>
>      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
>           __first2, __last2);
>    }
># 941 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _ForwardIterator, typename _Tp>
>    _ForwardIterator
>    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
>  const _Tp& __val)
>    {
>
>
>
>
>      typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>     
>     
>      ;
>
>      _DistanceType __len = std::distance(__first, __last);
>
>      while (__len > 0)
> {
>   _DistanceType __half = __len >> 1;
>   _ForwardIterator __middle = __first;
>   std::advance(__middle, __half);
>   if (*__middle < __val)
>     {
>       __first = __middle;
>       ++__first;
>       __len = __len - __half - 1;
>     }
>   else
>     __len = __half;
> }
>      return __first;
>    }
>
>
>
>  inline int
>  __lg(int __n)
>  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
>
>  inline unsigned
>  __lg(unsigned __n)
>  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
>
>  inline long
>  __lg(long __n)
>  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
>
>  inline unsigned long
>  __lg(unsigned long __n)
>  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
>
>  inline long long
>  __lg(long long __n)
>  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
>
>  inline unsigned long long
>  __lg(unsigned long long __n)
>  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
>
>
>
>
># 1019 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _II1, typename _II2>
>    inline bool
>    equal(_II1 __first1, _II1 __last1, _II2 __first2)
>    {
>
>     
>     
>     
>
>
>      ;
>
>      return std::__equal_aux(std::__niter_base(__first1),
>         std::__niter_base(__last1),
>         std::__niter_base(__first2));
>    }
># 1051 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
>    inline bool
>    equal(_IIter1 __first1, _IIter1 __last1,
>   _IIter2 __first2, _BinaryPredicate __binary_pred)
>    {
>
>     
>     
>      ;
>
>      for (; __first1 != __last1; ++__first1, ++__first2)
> if (!bool(__binary_pred(*__first1, *__first2)))
>   return false;
>      return true;
>    }
># 1082 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _II1, typename _II2>
>    inline bool
>    lexicographical_compare(_II1 __first1, _II1 __last1,
>       _II2 __first2, _II2 __last2)
>    {
>
>
>
>
>
>     
>     
>     
>     
>      ;
>      ;
>
>      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
>      std::__niter_base(__last1),
>      std::__niter_base(__first2),
>      std::__niter_base(__last2));
>    }
># 1118 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _II1, typename _II2, typename _Compare>
>    bool
>    lexicographical_compare(_II1 __first1, _II1 __last1,
>       _II2 __first2, _II2 __last2, _Compare __comp)
>    {
>      typedef typename iterator_traits<_II1>::iterator_category _Category1;
>      typedef typename iterator_traits<_II2>::iterator_category _Category2;
>      typedef std::__lc_rai<_Category1, _Category2> __rai_type;
>
>
>     
>     
>      ;
>      ;
>
>      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
>      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
>    ++__first1, ++__first2)
> {
>   if (__comp(*__first1, *__first2))
>     return true;
>   if (__comp(*__first2, *__first1))
>     return false;
> }
>      return __first1 == __last1 && __first2 != __last2;
>    }
># 1158 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _InputIterator1, typename _InputIterator2>
>    pair<_InputIterator1, _InputIterator2>
>    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
>      _InputIterator2 __first2)
>    {
>
>     
>     
>     
>
>
>      ;
>
>      while (__first1 != __last1 && *__first1 == *__first2)
>        {
>   ++__first1;
>   ++__first2;
>        }
>      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
>    }
># 1195 "/usr/include/c++/4.8.0/bits/stl_algobase.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _BinaryPredicate>
>    pair<_InputIterator1, _InputIterator2>
>    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
>      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
>    {
>
>     
>     
>      ;
>
>      while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
>        {
>   ++__first1;
>   ++__first2;
>        }
>      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
>    }
>
>
>}
># 62 "/usr/include/c++/4.8.0/algorithm" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_algo.h" 1 3
># 59 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
># 1 "/usr/include/c++/4.8.0/cstdlib" 1 3
># 39 "/usr/include/c++/4.8.0/cstdlib" 3
>       
># 40 "/usr/include/c++/4.8.0/cstdlib" 3
># 64 "/usr/include/c++/4.8.0/cstdlib" 3
># 1 "/usr/include/stdlib.h" 1 3 4
># 32 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stddef.h" 1 3 4
># 212 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stddef.h" 3 4
>typedef long unsigned int size_t;
># 33 "/usr/include/stdlib.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>
># 1 "/usr/include/bits/waitflags.h" 1 3 4
># 42 "/usr/include/stdlib.h" 2 3 4
># 1 "/usr/include/bits/waitstatus.h" 1 3 4
># 64 "/usr/include/bits/waitstatus.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 36 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 2 3 4
># 60 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 27 "/usr/include/bits/byteswap.h" 3 4
># 1 "/usr/include/bits/types.h" 1 3 4
># 27 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned char __u_char;
>typedef unsigned short int __u_short;
>typedef unsigned int __u_int;
>typedef unsigned long int __u_long;
>
>
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef signed short int __int16_t;
>typedef unsigned short int __uint16_t;
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
>
>typedef signed long int __int64_t;
>typedef unsigned long int __uint64_t;
>
>
>
>
>
>
>
>typedef long int __quad_t;
>typedef unsigned long int __u_quad_t;
># 130 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 131 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned long int __dev_t;
>typedef unsigned int __uid_t;
>typedef unsigned int __gid_t;
>typedef unsigned long int __ino_t;
>typedef unsigned long int __ino64_t;
>typedef unsigned int __mode_t;
>typedef unsigned long int __nlink_t;
>typedef long int __off_t;
>typedef long int __off64_t;
>typedef int __pid_t;
>typedef struct { int __val[2]; } __fsid_t;
>typedef long int __clock_t;
>typedef unsigned long int __rlim_t;
>typedef unsigned long int __rlim64_t;
>typedef unsigned int __id_t;
>typedef long int __time_t;
>typedef unsigned int __useconds_t;
>typedef long int __suseconds_t;
>
>typedef int __daddr_t;
>typedef int __key_t;
>
>
>typedef int __clockid_t;
>
>
>typedef void * __timer_t;
>
>
>typedef long int __blksize_t;
>
>
>
>
>typedef long int __blkcnt_t;
>typedef long int __blkcnt64_t;
>
>
>typedef unsigned long int __fsblkcnt_t;
>typedef unsigned long int __fsblkcnt64_t;
>
>
>typedef unsigned long int __fsfilcnt_t;
>typedef unsigned long int __fsfilcnt64_t;
>
>
>typedef long int __fsword_t;
>
>typedef long int __ssize_t;
>
>
>typedef long int __syscall_slong_t;
>
>typedef unsigned long int __syscall_ulong_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>typedef long int __intptr_t;
>
>
>typedef unsigned int __socklen_t;
># 28 "/usr/include/bits/byteswap.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/byteswap.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/bits/byteswap-16.h" 1 3 4
># 36 "/usr/include/bits/byteswap.h" 2 3 4
># 44 "/usr/include/bits/byteswap.h" 3 4
>static __inline unsigned int
>__bswap_32 (unsigned int __bsx)
>{
>  return __builtin_bswap32 (__bsx);
>}
># 108 "/usr/include/bits/byteswap.h" 3 4
>static __inline __uint64_t
>__bswap_64 (__uint64_t __bsx)
>{
>  return __builtin_bswap64 (__bsx);
>}
># 61 "/usr/include/endian.h" 2 3 4
># 65 "/usr/include/bits/waitstatus.h" 2 3 4
>
>union wait
>  {
>    int w_status;
>    struct
>      {
>
> unsigned int __w_termsig:7;
> unsigned int __w_coredump:1;
> unsigned int __w_retcode:8;
> unsigned int:16;
>
>
>
>
>
>
>
>      } __wait_terminated;
>    struct
>      {
>
> unsigned int __w_stopval:8;
> unsigned int __w_stopsig:8;
> unsigned int:16;
>
>
>
>
>
>
>      } __wait_stopped;
>  };
># 43 "/usr/include/stdlib.h" 2 3 4
># 95 "/usr/include/stdlib.h" 3 4
>
>
>typedef struct
>  {
>    int quot;
>    int rem;
>  } div_t;
>
>
>
>typedef struct
>  {
>    long int quot;
>    long int rem;
>  } ldiv_t;
>
>
>
>
>
>
>
>__extension__ typedef struct
>  {
>    long long int quot;
>    long long int rem;
>  } lldiv_t;
>
>
># 139 "/usr/include/stdlib.h" 3 4
>extern size_t __ctype_get_mb_cur_max (void) throw () __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern double atof (const char *__nptr)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern int atoi (const char *__nptr)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern long int atol (const char *__nptr)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>__extension__ extern long long int atoll (const char *__nptr)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern double strtod (const char *__restrict __nptr,
>        char **__restrict __endptr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern float strtof (const char *__restrict __nptr,
>       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
>
>extern long double strtold (const char *__restrict __nptr,
>       char **__restrict __endptr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern long int strtol (const char *__restrict __nptr,
>   char **__restrict __endptr, int __base)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>extern unsigned long int strtoul (const char *__restrict __nptr,
>      char **__restrict __endptr, int __base)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>__extension__
>extern long long int strtoq (const char *__restrict __nptr,
>        char **__restrict __endptr, int __base)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtouq (const char *__restrict __nptr,
>           char **__restrict __endptr, int __base)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>__extension__
>extern long long int strtoll (const char *__restrict __nptr,
>         char **__restrict __endptr, int __base)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtoull (const char *__restrict __nptr,
>     char **__restrict __endptr, int __base)
>     throw () __attribute__ ((__nonnull__ (1)));
>
># 235 "/usr/include/stdlib.h" 3 4
># 1 "/usr/include/xlocale.h" 1 3 4
># 27 "/usr/include/xlocale.h" 3 4
>typedef struct __locale_struct
>{
>
>  struct __locale_data *__locales[13];
>
>
>  const unsigned short int *__ctype_b;
>  const int *__ctype_tolower;
>  const int *__ctype_toupper;
>
>
>  const char *__names[13];
>} *__locale_t;
>
>
>typedef __locale_t locale_t;
># 236 "/usr/include/stdlib.h" 2 3 4
>
>
>
>extern long int strtol_l (const char *__restrict __nptr,
>     char **__restrict __endptr, int __base,
>     __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
>
>extern unsigned long int strtoul_l (const char *__restrict __nptr,
>        char **__restrict __endptr,
>        int __base, __locale_t __loc)
>     throw () __attribute__ ((__nonnull__ (1, 4)));
>
>__extension__
>extern long long int strtoll_l (const char *__restrict __nptr,
>    char **__restrict __endptr, int __base,
>    __locale_t __loc)
>     throw () __attribute__ ((__nonnull__ (1, 4)));
>
>__extension__
>extern unsigned long long int strtoull_l (const char *__restrict __nptr,
>       char **__restrict __endptr,
>       int __base, __locale_t __loc)
>     throw () __attribute__ ((__nonnull__ (1, 4)));
>
>extern double strtod_l (const char *__restrict __nptr,
>   char **__restrict __endptr, __locale_t __loc)
>     throw () __attribute__ ((__nonnull__ (1, 3)));
>
>extern float strtof_l (const char *__restrict __nptr,
>         char **__restrict __endptr, __locale_t __loc)
>     throw () __attribute__ ((__nonnull__ (1, 3)));
>
>extern long double strtold_l (const char *__restrict __nptr,
>         char **__restrict __endptr,
>         __locale_t __loc)
>     throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) atoi (const char *__nptr) throw ()
>{
>  return (int) strtol (__nptr, (char **) __null, 10);
>}
>extern __inline __attribute__ ((__gnu_inline__)) long int
>__attribute__ ((__leaf__)) atol (const char *__nptr) throw ()
>{
>  return strtol (__nptr, (char **) __null, 10);
>}
>
>
>
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
>__attribute__ ((__leaf__)) atoll (const char *__nptr) throw ()
>{
>  return strtoll (__nptr, (char **) __null, 10);
>}
>
># 305 "/usr/include/stdlib.h" 3 4
>extern char *l64a (long int __n) throw () __attribute__ ((__warn_unused_result__));
>
>
>extern long int a64l (const char *__s)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
># 1 "/usr/include/sys/types.h" 1 3 4
># 27 "/usr/include/sys/types.h" 3 4
>extern "C" {
>
>
>
>
>
>typedef __u_char u_char;
>typedef __u_short u_short;
>typedef __u_int u_int;
>typedef __u_long u_long;
>typedef __quad_t quad_t;
>typedef __u_quad_t u_quad_t;
>typedef __fsid_t fsid_t;
>
>
>
>
>typedef __loff_t loff_t;
>
>
>
>typedef __ino_t ino_t;
>
>
>
>
>
>
>typedef __ino64_t ino64_t;
>
>
>
>
>typedef __dev_t dev_t;
>
>
>
>
>typedef __gid_t gid_t;
>
>
>
>
>typedef __mode_t mode_t;
>
>
>
>
>typedef __nlink_t nlink_t;
>
>
>
>
>typedef __uid_t uid_t;
>
>
>
>
>
>typedef __off_t off_t;
>
>
>
>
>
>
>typedef __off64_t off64_t;
>
>
>
>
>typedef __pid_t pid_t;
>
>
>
>
>
>typedef __id_t id_t;
>
>
>
>
>typedef __ssize_t ssize_t;
>
>
>
>
>
>typedef __daddr_t daddr_t;
>typedef __caddr_t caddr_t;
>
>
>
>
>
>typedef __key_t key_t;
># 132 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 57 "/usr/include/time.h" 3 4
>
>
>typedef __clock_t clock_t;
>
>
>
># 73 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 91 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 103 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 133 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef __useconds_t useconds_t;
>
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stddef.h" 1 3 4
># 147 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 194 "/usr/include/sys/types.h" 3 4
>typedef int int8_t __attribute__ ((__mode__ (__QI__)));
>typedef int int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int int32_t __attribute__ ((__mode__ (__SI__)));
>typedef int int64_t __attribute__ ((__mode__ (__DI__)));
>
>
>typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
>typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
>
>typedef int register_t __attribute__ ((__mode__ (__word__)));
># 219 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/sys/select.h" 1 3 4
># 30 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 22 "/usr/include/bits/select.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/select.h" 2 3 4
># 31 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 23 "/usr/include/bits/sigset.h" 3 4
>typedef int __sig_atomic_t;
>
>
>
>
>typedef struct
>  {
>    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
>  } __sigset_t;
># 34 "/usr/include/sys/select.h" 2 3 4
>
>
>
>typedef __sigset_t sigset_t;
>
>
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 120 "/usr/include/time.h" 3 4
>struct timespec
>  {
>    __time_t tv_sec;
>    __syscall_slong_t tv_nsec;
>  };
># 44 "/usr/include/sys/select.h" 2 3 4
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 30 "/usr/include/bits/time.h" 3 4
>struct timeval
>  {
>    __time_t tv_sec;
>    __suseconds_t tv_usec;
>  };
># 46 "/usr/include/sys/select.h" 2 3 4
># 54 "/usr/include/sys/select.h" 3 4
>typedef long int __fd_mask;
># 64 "/usr/include/sys/select.h" 3 4
>typedef struct
>  {
>
>
>
>    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
>
>
>
>
>
>  } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 96 "/usr/include/sys/select.h" 3 4
>extern "C" {
># 106 "/usr/include/sys/select.h" 3 4
>extern int select (int __nfds, fd_set *__restrict __readfds,
>     fd_set *__restrict __writefds,
>     fd_set *__restrict __exceptfds,
>     struct timeval *__restrict __timeout);
># 118 "/usr/include/sys/select.h" 3 4
>extern int pselect (int __nfds, fd_set *__restrict __readfds,
>      fd_set *__restrict __writefds,
>      fd_set *__restrict __exceptfds,
>      const struct timespec *__restrict __timeout,
>      const __sigset_t *__restrict __sigmask);
>
>
>
>
>
># 1 "/usr/include/bits/select2.h" 1 3 4
># 24 "/usr/include/bits/select2.h" 3 4
>extern long int __fdelt_chk (long int __d);
>extern long int __fdelt_warn (long int __d)
>  __attribute__((__warning__ ("bit outside of fd_set selected")));
># 129 "/usr/include/sys/select.h" 2 3 4
>
>
>}
># 220 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 29 "/usr/include/sys/sysmacros.h" 3 4
>extern "C" {
>
>__extension__
>extern unsigned int gnu_dev_major (unsigned long long int __dev)
>     throw () __attribute__ ((__const__));
>__extension__
>extern unsigned int gnu_dev_minor (unsigned long long int __dev)
>     throw () __attribute__ ((__const__));
>__extension__
>extern unsigned long long int gnu_dev_makedev (unsigned int __major,
>            unsigned int __minor)
>     throw () __attribute__ ((__const__));
>
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int
>__attribute__ ((__leaf__)) gnu_dev_major (unsigned long long int __dev) throw ()
>{
>  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
>}
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int
>__attribute__ ((__leaf__)) gnu_dev_minor (unsigned long long int __dev) throw ()
>{
>  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
>}
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned long long int
>__attribute__ ((__leaf__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
>{
>  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
>   | (((unsigned long long int) (__minor & ~0xff)) << 12)
>   | (((unsigned long long int) (__major & ~0xfff)) << 32));
>}
>
>}
># 223 "/usr/include/sys/types.h" 2 3 4
>
>
>
>
>
>typedef __blksize_t blksize_t;
>
>
>
>
>
>
>typedef __blkcnt_t blkcnt_t;
>
>
>
>typedef __fsblkcnt_t fsblkcnt_t;
>
>
>
>typedef __fsfilcnt_t fsfilcnt_t;
># 262 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt64_t;
>typedef __fsblkcnt64_t fsblkcnt64_t;
>typedef __fsfilcnt64_t fsfilcnt64_t;
>
>
>
>
>
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 21 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 22 "/usr/include/bits/pthreadtypes.h" 2 3 4
># 60 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>union pthread_attr_t
>{
>  char __size[56];
>  long int __align;
>};
>
>typedef union pthread_attr_t pthread_attr_t;
>
>
>
>
>
>typedef struct __pthread_internal_list
>{
>  struct __pthread_internal_list *__prev;
>  struct __pthread_internal_list *__next;
>} __pthread_list_t;
># 90 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef union
>{
>  struct __pthread_mutex_s
>  {
>    int __lock;
>    unsigned int __count;
>    int __owner;
>
>    unsigned int __nusers;
>
>
>
>    int __kind;
>
>    int __spins;
>    __pthread_list_t __list;
># 115 "/usr/include/bits/pthreadtypes.h" 3 4
>  } __data;
>  char __size[40];
>  long int __align;
>} pthread_mutex_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
>  struct
>  {
>    int __lock;
>    unsigned int __futex;
>    __extension__ unsigned long long int __total_seq;
>    __extension__ unsigned long long int __wakeup_seq;
>    __extension__ unsigned long long int __woken_seq;
>    void *__mutex;
>    unsigned int __nwaiters;
>    unsigned int __broadcast_seq;
>  } __data;
>  char __size[48];
>  __extension__ long long int __align;
>} pthread_cond_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>
>typedef union
>{
>
>  struct
>  {
>    int __lock;
>    unsigned int __nr_readers;
>    unsigned int __readers_wakeup;
>    unsigned int __writer_wakeup;
>    unsigned int __nr_readers_queued;
>    unsigned int __nr_writers_queued;
>    int __writer;
>    int __shared;
>    unsigned long int __pad1;
>    unsigned long int __pad2;
>
>
>    unsigned int __flags;
>
>  } __data;
># 202 "/usr/include/bits/pthreadtypes.h" 3 4
>  char __size[56];
>  long int __align;
>} pthread_rwlock_t;
>
>typedef union
>{
>  char __size[8];
>  long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
>  char __size[32];
>  long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_barrierattr_t;
># 271 "/usr/include/sys/types.h" 2 3 4
>
>
>}
># 315 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>extern long int random (void) throw ();
>
>
>extern void srandom (unsigned int __seed) throw ();
>
>
>
>
>
>extern char *initstate (unsigned int __seed, char *__statebuf,
>   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>struct random_data
>  {
>    int32_t *fptr;
>    int32_t *rptr;
>    int32_t *state;
>    int rand_type;
>    int rand_deg;
>    int rand_sep;
>    int32_t *end_ptr;
>  };
>
>extern int random_r (struct random_data *__restrict __buf,
>       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int srandom_r (unsigned int __seed, struct random_data *__buf)
>     throw () __attribute__ ((__nonnull__ (2)));
>
>extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
>   size_t __statelen,
>   struct random_data *__restrict __buf)
>     throw () __attribute__ ((__nonnull__ (2, 4)));
>
>extern int setstate_r (char *__restrict __statebuf,
>         struct random_data *__restrict __buf)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int rand (void) throw ();
>
>extern void srand (unsigned int __seed) throw ();
>
>
>
>
>extern int rand_r (unsigned int *__seed) throw ();
>
>
>
>
>
>
>
>extern double drand48 (void) throw ();
>extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int lrand48 (void) throw ();
>extern long int nrand48 (unsigned short int __xsubi[3])
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int mrand48 (void) throw ();
>extern long int jrand48 (unsigned short int __xsubi[3])
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern void srand48 (long int __seedval) throw ();
>extern unsigned short int *seed48 (unsigned short int __seed16v[3])
>     throw () __attribute__ ((__nonnull__ (1)));
>extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>struct drand48_data
>  {
>    unsigned short int __x[3];
>    unsigned short int __old_x[3];
>    unsigned short int __c;
>    unsigned short int __init;
>    unsigned long long int __a;
>  };
>
>
>extern int drand48_r (struct drand48_data *__restrict __buffer,
>        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int erand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int lrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int nrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int mrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int jrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
>     throw () __attribute__ ((__nonnull__ (2)));
>
>extern int seed48_r (unsigned short int __seed16v[3],
>       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int lcong48_r (unsigned short int __param[7],
>        struct drand48_data *__buffer)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>
>
>extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>extern void *calloc (size_t __nmemb, size_t __size)
>     throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
>     throw () __attribute__ ((__warn_unused_result__));
>
>extern void free (void *__ptr) throw ();
>
>
>
>
>extern void cfree (void *__ptr) throw ();
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 24 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stddef.h" 1 3 4
># 25 "/usr/include/alloca.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>extern void *alloca (size_t __size) throw ();
>
>
>
>
>
>}
># 492 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
>     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void *aligned_alloc (size_t __alignment, size_t __size)
>     throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__malloc__, __alloc_size__ (2)));
>
>
>
>
>extern void abort (void) throw () __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern "C++" int at_quick_exit (void (*__func) (void))
>     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>
>
>extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>
>extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *secure_getenv (const char *__name)
>     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int setenv (const char *__name, const char *__value, int __replace)
>     throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int clearenv (void) throw ();
># 605 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
># 619 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 629 "/usr/include/stdlib.h" 3 4
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 641 "/usr/include/stdlib.h" 3 4
>extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 651 "/usr/include/stdlib.h" 3 4
>extern int mkstemps64 (char *__template, int __suffixlen)
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 662 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 673 "/usr/include/stdlib.h" 3 4
>extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 683 "/usr/include/stdlib.h" 3 4
>extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 693 "/usr/include/stdlib.h" 3 4
>extern int mkostemps (char *__template, int __suffixlen, int __flags)
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 705 "/usr/include/stdlib.h" 3 4
>extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>
>extern int system (const char *__command) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern char *canonicalize_file_name (const char *__name)
>     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 733 "/usr/include/stdlib.h" 3 4
>extern char *realpath (const char *__restrict __name,
>         char *__restrict __resolved) throw () __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>typedef int (*__compar_fn_t) (const void *, const void *);
>
>
>typedef __compar_fn_t comparison_fn_t;
>
>
>
>typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
>
>
>
>
>
>extern void *bsearch (const void *__key, const void *__base,
>        size_t __nmemb, size_t __size, __compar_fn_t __compar)
>     __attribute__ ((__nonnull__ (1, 2, 5))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern void qsort (void *__base, size_t __nmemb, size_t __size,
>     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
>
>extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
>       __compar_d_fn_t __compar, void *__arg)
>  __attribute__ ((__nonnull__ (1, 4)));
>
>
>
>
>extern int abs (int __x) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>extern long int labs (long int __x) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>__extension__ extern long long int llabs (long long int __x)
>     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern div_t div (int __numer, int __denom)
>     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>extern ldiv_t ldiv (long int __numer, long int __denom)
>     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>__extension__ extern lldiv_t lldiv (long long int __numer,
>        long long int __denom)
>     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
># 807 "/usr/include/stdlib.h" 3 4
>extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *gcvt (double __value, int __ndigit, char *__buf)
>     throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *qecvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>extern char *qfcvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>extern char *qgcvt (long double __value, int __ndigit, char *__buf)
>     throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>
>extern int qecvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int qfcvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>
>
>
>
>
>
>
>extern int mblen (const char *__s, size_t __n) throw () __attribute__ ((__warn_unused_result__));
>
>
>extern int mbtowc (wchar_t *__restrict __pwc,
>     const char *__restrict __s, size_t __n) throw () __attribute__ ((__warn_unused_result__));
>
>
>extern int wctomb (char *__s, wchar_t __wchar) throw () __attribute__ ((__warn_unused_result__));
>
>
>
>extern size_t mbstowcs (wchar_t *__restrict __pwcs,
>   const char *__restrict __s, size_t __n) throw ();
>
>extern size_t wcstombs (char *__restrict __s,
>   const wchar_t *__restrict __pwcs, size_t __n)
>     throw ();
>
>
>
>
>
>
>
>
>extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 895 "/usr/include/stdlib.h" 3 4
>extern int getsubopt (char **__restrict __optionp,
>        char *const *__restrict __tokens,
>        char **__restrict __valuep)
>     throw () __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern int grantpt (int __fd) throw ();
>
>
>
>extern int unlockpt (int __fd) throw ();
>
>
>
>
>extern char *ptsname (int __fd) throw () __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
>     throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int getpt (void);
>
>
>
>
>
>
>extern int getloadavg (double __loadavg[], int __nelem)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
># 1 "/usr/include/bits/stdlib-float.h" 1 3 4
># 24 "/usr/include/bits/stdlib-float.h" 3 4
>
>extern __inline __attribute__ ((__gnu_inline__)) double
>__attribute__ ((__leaf__)) atof (const char *__nptr) throw ()
>{
>  return strtod (__nptr, (char **) __null);
>}
>
># 952 "/usr/include/stdlib.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/stdlib.h" 1 3 4
># 23 "/usr/include/bits/stdlib.h" 3 4
>extern char *__realpath_chk (const char *__restrict __name,
>        char *__restrict __resolved,
>        size_t __resolvedlen) throw () __attribute__ ((__warn_unused_result__));
>extern char *__realpath_alias (const char *__restrict __name, char *__restrict __resolved) throw () __asm__ ("" "realpath")
>
>                                                 __attribute__ ((__warn_unused_result__));
>extern char *__realpath_chk_warn (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) throw () __asm__ ("" "__realpath_chk")
>
>
>                                                __attribute__ ((__warn_unused_result__))
>     __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer")))
>                                      ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>__attribute__ ((__leaf__)) realpath (const char *__restrict __name, char *__restrict __resolved) throw ()
>{
>  if (__builtin_object_size (__resolved, 2 > 1) != (size_t) -1)
>    {
>
>
>
>
>      return __realpath_chk (__name, __resolved, __builtin_object_size (__resolved, 2 > 1));
>    }
>
>  return __realpath_alias (__name, __resolved);
>}
>
>
>extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen,
>       size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
>extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ptsname_r")
>
>     __attribute__ ((__nonnull__ (2)));
>extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ptsname_r_chk")
>
>
>     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf")))
>                   ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__leaf__)) ptsname_r (int __fd, char *__buf, size_t __buflen) throw ()
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __ptsname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __ptsname_r_alias (__fd, __buf, __buflen);
>}
>
>
>extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen)
>  throw () __attribute__ ((__warn_unused_result__));
>extern int __wctomb_alias (char *__s, wchar_t __wchar) throw () __asm__ ("" "wctomb")
>              __attribute__ ((__warn_unused_result__));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) int
>__attribute__ ((__leaf__)) wctomb (char *__s, wchar_t __wchar) throw ()
>{
>
>
>
>
>
>
>
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
>    return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 2 > 1));
>  return __wctomb_alias (__s, __wchar);
>}
>
>
>extern size_t __mbstowcs_chk (wchar_t *__restrict __dst,
>         const char *__restrict __src,
>         size_t __len, size_t __dstlen) throw ();
>extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) throw () __asm__ ("" "mbstowcs")
>
>
>                                  ;
>extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__mbstowcs_chk")
>
>
>
>     __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
>                        ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__leaf__)) mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) throw ()
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __mbstowcs_chk (__dst, __src, __len,
>          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>
>      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
> return __mbstowcs_chk_warn (__dst, __src, __len,
>         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>    }
>  return __mbstowcs_alias (__dst, __src, __len);
>}
>
>
>extern size_t __wcstombs_chk (char *__restrict __dst,
>         const wchar_t *__restrict __src,
>         size_t __len, size_t __dstlen) throw ();
>extern size_t __wcstombs_alias (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) throw () __asm__ ("" "wcstombs")
>
>
>                                  ;
>extern size_t __wcstombs_chk_warn (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__wcstombs_chk")
>
>
>
>     __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len")));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__leaf__)) wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) throw ()
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __wcstombs_chk (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
>      if (__len > __builtin_object_size (__dst, 2 > 1))
> return __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
>    }
>  return __wcstombs_alias (__dst, __src, __len);
>}
># 956 "/usr/include/stdlib.h" 2 3 4
># 964 "/usr/include/stdlib.h" 3 4
>}
># 65 "/usr/include/c++/4.8.0/cstdlib" 2 3
># 96 "/usr/include/c++/4.8.0/cstdlib" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  using ::div_t;
>  using ::ldiv_t;
>
>  using ::abort;
>  using ::abs;
>  using ::atexit;
>  using ::atof;
>  using ::atoi;
>  using ::atol;
>  using ::bsearch;
>  using ::calloc;
>  using ::div;
>  using ::exit;
>  using ::free;
>  using ::getenv;
>  using ::labs;
>  using ::ldiv;
>  using ::malloc;
>
>  using ::mblen;
>  using ::mbstowcs;
>  using ::mbtowc;
>
>  using ::qsort;
>  using ::rand;
>  using ::realloc;
>  using ::srand;
>  using ::strtod;
>  using ::strtol;
>  using ::strtoul;
>  using ::system;
>
>  using ::wcstombs;
>  using ::wctomb;
>
>
>
>  inline long
>  abs(long __i) { return __builtin_labs(__i); }
>
>  inline ldiv_t
>  div(long __i, long __j) { return ldiv(__i, __j); }
>
>
>
>  inline long long
>  abs(long long __x) { return __builtin_llabs (__x); }
>
>
>
>  inline __int128
>  abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
>
>
>
>}
># 168 "/usr/include/c++/4.8.0/cstdlib" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>  using ::lldiv_t;
>
>
>
>
>
>  using ::_Exit;
>
>
>
>  using ::llabs;
>
>  inline lldiv_t
>  div(long long __n, long long __d)
>  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
>
>  using ::lldiv;
># 200 "/usr/include/c++/4.8.0/cstdlib" 3
>  using ::atoll;
>  using ::strtoll;
>  using ::strtoull;
>
>  using ::strtof;
>  using ::strtold;
>
>
>}
>
>namespace std
>{
>
>  using ::__gnu_cxx::lldiv_t;
>
>  using ::__gnu_cxx::_Exit;
>
>  using ::__gnu_cxx::llabs;
>  using ::__gnu_cxx::div;
>  using ::__gnu_cxx::lldiv;
>
>  using ::__gnu_cxx::atoll;
>  using ::__gnu_cxx::strtof;
>  using ::__gnu_cxx::strtoll;
>  using ::__gnu_cxx::strtoull;
>  using ::__gnu_cxx::strtold;
>}
># 60 "/usr/include/c++/4.8.0/bits/stl_algo.h" 2 3
># 1 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 1 3
># 33 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
>       
># 34 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
># 42 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 203 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
>  template<typename _FIter, typename _Tp>
>    bool
>    binary_search(_FIter, _FIter, const _Tp&);
>
>  template<typename _FIter, typename _Tp, typename _Compare>
>    bool
>    binary_search(_FIter, _FIter, const _Tp&, _Compare);
>
>  template<typename _IIter, typename _OIter>
>    _OIter
>    copy(_IIter, _IIter, _OIter);
>
>  template<typename _BIter1, typename _BIter2>
>    _BIter2
>    copy_backward(_BIter1, _BIter1, _BIter2);
># 232 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
>  template<typename _FIter, typename _Tp>
>    pair<_FIter, _FIter>
>    equal_range(_FIter, _FIter, const _Tp&);
>
>  template<typename _FIter, typename _Tp, typename _Compare>
>    pair<_FIter, _FIter>
>    equal_range(_FIter, _FIter, const _Tp&, _Compare);
>
>  template<typename _FIter, typename _Tp>
>    void
>    fill(_FIter, _FIter, const _Tp&);
>
>  template<typename _OIter, typename _Size, typename _Tp>
>    _OIter
>    fill_n(_OIter, _Size, const _Tp&);
>
>
>
>  template<typename _FIter1, typename _FIter2>
>    _FIter1
>    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
>
>  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
>    _FIter1
>    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
># 271 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
>  template<typename _IIter1, typename _IIter2>
>    bool
>    includes(_IIter1, _IIter1, _IIter2, _IIter2);
>
>  template<typename _IIter1, typename _IIter2, typename _Compare>
>    bool
>    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
>
>  template<typename _BIter>
>    void
>    inplace_merge(_BIter, _BIter, _BIter);
>
>  template<typename _BIter, typename _Compare>
>    void
>    inplace_merge(_BIter, _BIter, _BIter, _Compare);
># 334 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
>  template<typename _FIter1, typename _FIter2>
>    void
>    iter_swap(_FIter1, _FIter2);
>
>  template<typename _FIter, typename _Tp>
>    _FIter
>    lower_bound(_FIter, _FIter, const _Tp&);
>
>  template<typename _FIter, typename _Tp, typename _Compare>
>    _FIter
>    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
>
>  template<typename _RAIter>
>    void
>    make_heap(_RAIter, _RAIter);
>
>  template<typename _RAIter, typename _Compare>
>    void
>    make_heap(_RAIter, _RAIter, _Compare);
>
>  template<typename _Tp>
>    const _Tp&
>    max(const _Tp&, const _Tp&);
>
>  template<typename _Tp, typename _Compare>
>    const _Tp&
>    max(const _Tp&, const _Tp&, _Compare);
>
>
>
>
>  template<typename _Tp>
>    const _Tp&
>    min(const _Tp&, const _Tp&);
>
>  template<typename _Tp, typename _Compare>
>    const _Tp&
>    min(const _Tp&, const _Tp&, _Compare);
># 419 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
>  template<typename _BIter>
>    bool
>    next_permutation(_BIter, _BIter);
>
>  template<typename _BIter, typename _Compare>
>    bool
>    next_permutation(_BIter, _BIter, _Compare);
># 436 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
>  template<typename _IIter, typename _RAIter>
>    _RAIter
>    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
>
>  template<typename _IIter, typename _RAIter, typename _Compare>
>    _RAIter
>    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
># 457 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
>  template<typename _RAIter>
>    void
>    pop_heap(_RAIter, _RAIter);
>
>  template<typename _RAIter, typename _Compare>
>    void
>    pop_heap(_RAIter, _RAIter, _Compare);
>
>  template<typename _BIter>
>    bool
>    prev_permutation(_BIter, _BIter);
>
>  template<typename _BIter, typename _Compare>
>    bool
>    prev_permutation(_BIter, _BIter, _Compare);
>
>  template<typename _RAIter>
>    void
>    push_heap(_RAIter, _RAIter);
>
>  template<typename _RAIter, typename _Compare>
>    void
>    push_heap(_RAIter, _RAIter, _Compare);
>
>
>
>  template<typename _FIter, typename _Tp>
>    _FIter
>    remove(_FIter, _FIter, const _Tp&);
>
>  template<typename _FIter, typename _Predicate>
>    _FIter
>    remove_if(_FIter, _FIter, _Predicate);
>
>  template<typename _IIter, typename _OIter, typename _Tp>
>    _OIter
>    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
>
>  template<typename _IIter, typename _OIter, typename _Predicate>
>    _OIter
>    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
>
>
>
>  template<typename _IIter, typename _OIter, typename _Tp>
>    _OIter
>    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
>
>  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
>    _OIter
>    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
>
>
>
>  template<typename _BIter>
>    void
>    reverse(_BIter, _BIter);
>
>  template<typename _BIter, typename _OIter>
>    _OIter
>    reverse_copy(_BIter, _BIter, _OIter);
>
>  template<typename _FIter>
>    void
>    rotate(_FIter, _FIter, _FIter);
>
>  template<typename _FIter, typename _OIter>
>    _OIter
>    rotate_copy(_FIter, _FIter, _FIter, _OIter);
># 540 "/usr/include/c++/4.8.0/bits/algorithmfwd.h" 3
>  template<typename _RAIter>
>    void
>    sort_heap(_RAIter, _RAIter);
>
>  template<typename _RAIter, typename _Compare>
>    void
>    sort_heap(_RAIter, _RAIter, _Compare);
>
>  template<typename _BIter, typename _Predicate>
>    _BIter
>    stable_partition(_BIter, _BIter, _Predicate);
>
>  template<typename _Tp>
>    void
>    swap(_Tp&, _Tp&)
>
>
>
>
>    ;
>
>  template<typename _Tp, size_t _Nm>
>    void
>    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
>
>
>
>    ;
>
>  template<typename _FIter1, typename _FIter2>
>    _FIter2
>    swap_ranges(_FIter1, _FIter1, _FIter2);
>
>
>
>  template<typename _FIter>
>    _FIter
>    unique(_FIter, _FIter);
>
>  template<typename _FIter, typename _BinaryPredicate>
>    _FIter
>    unique(_FIter, _FIter, _BinaryPredicate);
>
>
>
>  template<typename _FIter, typename _Tp>
>    _FIter
>    upper_bound(_FIter, _FIter, const _Tp&);
>
>  template<typename _FIter, typename _Tp, typename _Compare>
>    _FIter
>    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
>
>
>
>
>
>  template<typename _FIter>
>    _FIter
>    adjacent_find(_FIter, _FIter);
>
>  template<typename _FIter, typename _BinaryPredicate>
>    _FIter
>    adjacent_find(_FIter, _FIter, _BinaryPredicate);
>
>  template<typename _IIter, typename _Tp>
>    typename iterator_traits<_IIter>::difference_type
>    count(_IIter, _IIter, const _Tp&);
>
>  template<typename _IIter, typename _Predicate>
>    typename iterator_traits<_IIter>::difference_type
>    count_if(_IIter, _IIter, _Predicate);
>
>  template<typename _IIter1, typename _IIter2>
>    bool
>    equal(_IIter1, _IIter1, _IIter2);
>
>  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
>    bool
>    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
>
>  template<typename _IIter, typename _Tp>
>    _IIter
>    find(_IIter, _IIter, const _Tp&);
>
>  template<typename _FIter1, typename _FIter2>
>    _FIter1
>    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
>
>  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
>    _FIter1
>    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
>  template<typename _IIter, typename _Predicate>
>    _IIter
>    find_if(_IIter, _IIter, _Predicate);
>
>  template<typename _IIter, typename _Funct>
>    _Funct
>    for_each(_IIter, _IIter, _Funct);
>
>  template<typename _FIter, typename _Generator>
>    void
>    generate(_FIter, _FIter, _Generator);
>
>  template<typename _OIter, typename _Size, typename _Generator>
>    _OIter
>    generate_n(_OIter, _Size, _Generator);
>
>  template<typename _IIter1, typename _IIter2>
>    bool
>    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
>
>  template<typename _IIter1, typename _IIter2, typename _Compare>
>    bool
>    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
>
>  template<typename _FIter>
>    _FIter
>    max_element(_FIter, _FIter);
>
>  template<typename _FIter, typename _Compare>
>    _FIter
>    max_element(_FIter, _FIter, _Compare);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter>
>    _OIter
>    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter,
>    typename _Compare>
>    _OIter
>    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
>  template<typename _FIter>
>    _FIter
>    min_element(_FIter, _FIter);
>
>  template<typename _FIter, typename _Compare>
>    _FIter
>    min_element(_FIter, _FIter, _Compare);
>
>  template<typename _IIter1, typename _IIter2>
>    pair<_IIter1, _IIter2>
>    mismatch(_IIter1, _IIter1, _IIter2);
>
>  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
>    pair<_IIter1, _IIter2>
>    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
>
>  template<typename _RAIter>
>    void
>    nth_element(_RAIter, _RAIter, _RAIter);
>
>  template<typename _RAIter, typename _Compare>
>    void
>    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
>
>  template<typename _RAIter>
>    void
>    partial_sort(_RAIter, _RAIter, _RAIter);
>
>  template<typename _RAIter, typename _Compare>
>    void
>    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
>
>  template<typename _BIter, typename _Predicate>
>    _BIter
>    partition(_BIter, _BIter, _Predicate);
>
>  template<typename _RAIter>
>    void
>    random_shuffle(_RAIter, _RAIter);
>
>  template<typename _RAIter, typename _Generator>
>    void
>    random_shuffle(_RAIter, _RAIter,
>
>
>
>     _Generator&);
>
>
>  template<typename _FIter, typename _Tp>
>    void
>    replace(_FIter, _FIter, const _Tp&, const _Tp&);
>
>  template<typename _FIter, typename _Predicate, typename _Tp>
>    void
>    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
>
>  template<typename _FIter1, typename _FIter2>
>    _FIter1
>    search(_FIter1, _FIter1, _FIter2, _FIter2);
>
>  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
>    _FIter1
>    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
>  template<typename _FIter, typename _Size, typename _Tp>
>    _FIter
>    search_n(_FIter, _FIter, _Size, const _Tp&);
>
>  template<typename _FIter, typename _Size, typename _Tp,
>    typename _BinaryPredicate>
>    _FIter
>    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter>
>    _OIter
>    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter,
>    typename _Compare>
>    _OIter
>    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter>
>    _OIter
>    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter,
>    typename _Compare>
>    _OIter
>    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter>
>    _OIter
>    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter,
>    typename _Compare>
>    _OIter
>    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
>        _OIter, _Compare);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter>
>    _OIter
>    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter,
>    typename _Compare>
>    _OIter
>    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
>  template<typename _RAIter>
>    void
>    sort(_RAIter, _RAIter);
>
>  template<typename _RAIter, typename _Compare>
>    void
>    sort(_RAIter, _RAIter, _Compare);
>
>  template<typename _RAIter>
>    void
>    stable_sort(_RAIter, _RAIter);
>
>  template<typename _RAIter, typename _Compare>
>    void
>    stable_sort(_RAIter, _RAIter, _Compare);
>
>  template<typename _IIter, typename _OIter, typename _UnaryOperation>
>    _OIter
>    transform(_IIter, _IIter, _OIter, _UnaryOperation);
>
>  template<typename _IIter1, typename _IIter2, typename _OIter,
>    typename _BinaryOperation>
>    _OIter
>    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
>
>  template<typename _IIter, typename _OIter>
>    _OIter
>    unique_copy(_IIter, _IIter, _OIter);
>
>  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
>    _OIter
>    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
>
>
>}
># 61 "/usr/include/c++/4.8.0/bits/stl_algo.h" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_heap.h" 1 3
># 61 "/usr/include/c++/4.8.0/bits/stl_heap.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>  template<typename _RandomAccessIterator, typename _Distance>
>    _Distance
>    __is_heap_until(_RandomAccessIterator __first, _Distance __n)
>    {
>      _Distance __parent = 0;
>      for (_Distance __child = 1; __child < __n; ++__child)
> {
>   if (__first[__parent] < __first[__child])
>     return __child;
>   if ((__child & 1) == 0)
>     ++__parent;
> }
>      return __n;
>    }
>
>  template<typename _RandomAccessIterator, typename _Distance,
>    typename _Compare>
>    _Distance
>    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
>      _Compare __comp)
>    {
>      _Distance __parent = 0;
>      for (_Distance __child = 1; __child < __n; ++__child)
> {
>   if (__comp(__first[__parent], __first[__child]))
>     return __child;
>   if ((__child & 1) == 0)
>     ++__parent;
> }
>      return __n;
>    }
>
>
>
>  template<typename _RandomAccessIterator, typename _Distance>
>    inline bool
>    __is_heap(_RandomAccessIterator __first, _Distance __n)
>    { return std::__is_heap_until(__first, __n) == __n; }
>
>  template<typename _RandomAccessIterator, typename _Compare,
>    typename _Distance>
>    inline bool
>    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
>    { return std::__is_heap_until(__first, __n, __comp) == __n; }
>
>  template<typename _RandomAccessIterator>
>    inline bool
>    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
>    { return std::__is_heap(__first, std::distance(__first, __last)); }
>
>  template<typename _RandomAccessIterator, typename _Compare>
>    inline bool
>    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
>       _Compare __comp)
>    { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
>
>
>
>
>  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
>    void
>    __push_heap(_RandomAccessIterator __first,
>  _Distance __holeIndex, _Distance __topIndex, _Tp __value)
>    {
>      _Distance __parent = (__holeIndex - 1) / 2;
>      while (__holeIndex > __topIndex && *(__first + __parent) < __value)
> {
>   *(__first + __holeIndex) = (*(__first + __parent));
>   __holeIndex = __parent;
>   __parent = (__holeIndex - 1) / 2;
> }
>      *(__first + __holeIndex) = (__value);
>    }
># 154 "/usr/include/c++/4.8.0/bits/stl_heap.h" 3
>  template<typename _RandomAccessIterator>
>    inline void
>    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
>   _ValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
>   _DistanceType;
>
>
>     
>
>     
>      ;
>      ;
>
>      _ValueType __value = (*(__last - 1));
>      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
>         _DistanceType(0), (__value));
>    }
>
>  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
>    typename _Compare>
>    void
>    __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
>  _Distance __topIndex, _Tp __value, _Compare __comp)
>    {
>      _Distance __parent = (__holeIndex - 1) / 2;
>      while (__holeIndex > __topIndex
>      && __comp(*(__first + __parent), __value))
> {
>   *(__first + __holeIndex) = (*(__first + __parent));
>   __holeIndex = __parent;
>   __parent = (__holeIndex - 1) / 2;
> }
>      *(__first + __holeIndex) = (__value);
>    }
># 204 "/usr/include/c++/4.8.0/bits/stl_heap.h" 3
>  template<typename _RandomAccessIterator, typename _Compare>
>    inline void
>    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
>       _Compare __comp)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
>   _ValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
>   _DistanceType;
>
>
>     
>
>      ;
>      ;
>
>      _ValueType __value = (*(__last - 1));
>      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
>         _DistanceType(0), (__value), __comp);
>    }
>
>  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
>    void
>    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
>    _Distance __len, _Tp __value)
>    {
>      const _Distance __topIndex = __holeIndex;
>      _Distance __secondChild = __holeIndex;
>      while (__secondChild < (__len - 1) / 2)
> {
>   __secondChild = 2 * (__secondChild + 1);
>   if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
>     __secondChild--;
>   *(__first + __holeIndex) = (*(__first + __secondChild));
>   __holeIndex = __secondChild;
> }
>      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
> {
>   __secondChild = 2 * (__secondChild + 1);
>   *(__first + __holeIndex) = (*(__first + (__secondChild - 1)))
>                                  ;
>   __holeIndex = __secondChild - 1;
> }
>      std::__push_heap(__first, __holeIndex, __topIndex,
>         (__value));
>    }
>
>  template<typename _RandomAccessIterator>
>    inline void
>    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
>        _RandomAccessIterator __result)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>      _ValueType __value = (*__result);
>      *__result = (*__first);
>      std::__adjust_heap(__first, _DistanceType(0),
>    _DistanceType(__last - __first),
>    (__value));
>    }
># 279 "/usr/include/c++/4.8.0/bits/stl_heap.h" 3
>  template<typename _RandomAccessIterator>
>    inline void
>    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
>     
>
>     
>      ;
>      ;
>      ;
>
>      --__last;
>      std::__pop_heap(__first, __last, __last);
>    }
>
>  template<typename _RandomAccessIterator, typename _Distance,
>    typename _Tp, typename _Compare>
>    void
>    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
>    _Distance __len, _Tp __value, _Compare __comp)
>    {
>      const _Distance __topIndex = __holeIndex;
>      _Distance __secondChild = __holeIndex;
>      while (__secondChild < (__len - 1) / 2)
> {
>   __secondChild = 2 * (__secondChild + 1);
>   if (__comp(*(__first + __secondChild),
>       *(__first + (__secondChild - 1))))
>     __secondChild--;
>   *(__first + __holeIndex) = (*(__first + __secondChild));
>   __holeIndex = __secondChild;
> }
>      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
> {
>   __secondChild = 2 * (__secondChild + 1);
>   *(__first + __holeIndex) = (*(__first + (__secondChild - 1)))
>                                  ;
>   __holeIndex = __secondChild - 1;
> }
>      std::__push_heap(__first, __holeIndex, __topIndex,
>         (__value), __comp);
>    }
>
>  template<typename _RandomAccessIterator, typename _Compare>
>    inline void
>    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
>        _RandomAccessIterator __result, _Compare __comp)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>      _ValueType __value = (*__result);
>      *__result = (*__first);
>      std::__adjust_heap(__first, _DistanceType(0),
>    _DistanceType(__last - __first),
>    (__value), __comp);
>    }
># 354 "/usr/include/c++/4.8.0/bits/stl_heap.h" 3
>  template<typename _RandomAccessIterator, typename _Compare>
>    inline void
>    pop_heap(_RandomAccessIterator __first,
>      _RandomAccessIterator __last, _Compare __comp)
>    {
>
>     
>
>      ;
>      ;
>      ;
>
>      --__last;
>      std::__pop_heap(__first, __last, __last, __comp);
>    }
># 378 "/usr/include/c++/4.8.0/bits/stl_heap.h" 3
>  template<typename _RandomAccessIterator>
>    void
>    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
>   _ValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
>   _DistanceType;
>
>
>     
>
>     
>      ;
>
>      if (__last - __first < 2)
> return;
>
>      const _DistanceType __len = __last - __first;
>      _DistanceType __parent = (__len - 2) / 2;
>      while (true)
> {
>   _ValueType __value = (*(__first + __parent));
>   std::__adjust_heap(__first, __parent, __len, (__value));
>   if (__parent == 0)
>     return;
>   __parent--;
> }
>    }
># 418 "/usr/include/c++/4.8.0/bits/stl_heap.h" 3
>  template<typename _RandomAccessIterator, typename _Compare>
>    void
>    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
>       _Compare __comp)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
>   _ValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
>   _DistanceType;
>
>
>     
>
>      ;
>
>      if (__last - __first < 2)
> return;
>
>      const _DistanceType __len = __last - __first;
>      _DistanceType __parent = (__len - 2) / 2;
>      while (true)
> {
>   _ValueType __value = (*(__first + __parent));
>   std::__adjust_heap(__first, __parent, __len, (__value),
>        __comp);
>   if (__parent == 0)
>     return;
>   __parent--;
> }
>    }
># 457 "/usr/include/c++/4.8.0/bits/stl_heap.h" 3
>  template<typename _RandomAccessIterator>
>    void
>    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
>    {
>
>     
>
>     
>
>      ;
>      ;
>
>      while (__last - __first > 1)
> {
>   --__last;
>   std::__pop_heap(__first, __last, __last);
> }
>    }
># 486 "/usr/include/c++/4.8.0/bits/stl_heap.h" 3
>  template<typename _RandomAccessIterator, typename _Compare>
>    void
>    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
>       _Compare __comp)
>    {
>
>     
>
>      ;
>      ;
>
>      while (__last - __first > 1)
> {
>   --__last;
>   std::__pop_heap(__first, __last, __last, __comp);
> }
>    }
># 583 "/usr/include/c++/4.8.0/bits/stl_heap.h" 3
>
>}
># 62 "/usr/include/c++/4.8.0/bits/stl_algo.h" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_tempbuf.h" 1 3
># 60 "/usr/include/c++/4.8.0/bits/stl_tempbuf.h" 3
># 1 "/usr/include/c++/4.8.0/bits/stl_construct.h" 1 3
># 59 "/usr/include/c++/4.8.0/bits/stl_construct.h" 3
># 1 "/usr/include/c++/4.8.0/new" 1 3
># 37 "/usr/include/c++/4.8.0/new" 3
>       
># 38 "/usr/include/c++/4.8.0/new" 3
>
>
># 1 "/usr/include/c++/4.8.0/exception" 1 3
># 33 "/usr/include/c++/4.8.0/exception" 3
>       
># 34 "/usr/include/c++/4.8.0/exception" 3
>
>#pragma GCC visibility push(default)
>
>
># 1 "/usr/include/c++/4.8.0/bits/atomic_lockfree_defines.h" 1 3
># 33 "/usr/include/c++/4.8.0/bits/atomic_lockfree_defines.h" 3
>       
># 34 "/usr/include/c++/4.8.0/bits/atomic_lockfree_defines.h" 3
># 39 "/usr/include/c++/4.8.0/exception" 2 3
>
>extern "C++" {
>
>namespace std
>{
># 60 "/usr/include/c++/4.8.0/exception" 3
>  class exception
>  {
>  public:
>    exception() throw() { }
>    virtual ~exception() throw();
>
>
>
>    virtual const char* what() const throw();
>  };
>
>
>
>  class bad_exception : public exception
>  {
>  public:
>    bad_exception() throw() { }
>
>
>
>    virtual ~bad_exception() throw();
>
>
>    virtual const char* what() const throw();
>  };
>
>
>  typedef void (*terminate_handler) ();
>
>
>  typedef void (*unexpected_handler) ();
>
>
>  terminate_handler set_terminate(terminate_handler) throw();
>
>
>
>  void terminate() throw() __attribute__ ((__noreturn__));
>
>
>  unexpected_handler set_unexpected(unexpected_handler) throw();
>
>
>
>  void unexpected() __attribute__ ((__noreturn__));
># 117 "/usr/include/c++/4.8.0/exception" 3
>  bool uncaught_exception() throw() __attribute__ ((__pure__));
>
>
>}
>
>namespace __gnu_cxx
>{
>
># 142 "/usr/include/c++/4.8.0/exception" 3
>  void __verbose_terminate_handler();
>
>
>}
>
>}
>
>#pragma GCC visibility pop
># 41 "/usr/include/c++/4.8.0/new" 2 3
>
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
>
>  class bad_alloc : public exception
>  {
>  public:
>    bad_alloc() throw() { }
>
>
>
>    virtual ~bad_alloc() throw();
>
>
>    virtual const char* what() const throw();
>  };
>
>  struct nothrow_t { };
>
>  extern const nothrow_t nothrow;
>
>
>
>  typedef void (*new_handler)();
>
>
>
>  new_handler set_new_handler(new_handler) throw();
>}
># 91 "/usr/include/c++/4.8.0/new" 3
>void* operator new(std::size_t) throw(std::bad_alloc)
>  __attribute__((__externally_visible__));
>void* operator new[](std::size_t) throw(std::bad_alloc)
>  __attribute__((__externally_visible__));
>void operator delete(void*) throw()
>  __attribute__((__externally_visible__));
>void operator delete[](void*) throw()
>  __attribute__((__externally_visible__));
>void* operator new(std::size_t, const std::nothrow_t&) throw()
>  __attribute__((__externally_visible__));
>void* operator new[](std::size_t, const std::nothrow_t&) throw()
>  __attribute__((__externally_visible__));
>void operator delete(void*, const std::nothrow_t&) throw()
>  __attribute__((__externally_visible__));
>void operator delete[](void*, const std::nothrow_t&) throw()
>  __attribute__((__externally_visible__));
>
>
>inline void* operator new(std::size_t, void* __p) throw()
>{ return __p; }
>inline void* operator new[](std::size_t, void* __p) throw()
>{ return __p; }
>
>
>inline void operator delete (void*, void*) throw() { }
>inline void operator delete[](void*, void*) throw() { }
>
>}
>
>#pragma GCC visibility pop
># 60 "/usr/include/c++/4.8.0/bits/stl_construct.h" 2 3
>
># 1 "/usr/include/c++/4.8.0/ext/alloc_traits.h" 1 3
># 32 "/usr/include/c++/4.8.0/ext/alloc_traits.h" 3
>       
># 33 "/usr/include/c++/4.8.0/ext/alloc_traits.h" 3
>
>
>
>
>
># 1 "/usr/include/c++/4.8.0/bits/allocator.h" 1 3
># 47 "/usr/include/c++/4.8.0/bits/allocator.h" 3
># 1 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++allocator.h" 1 3
># 33 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++allocator.h" 3
># 1 "/usr/include/c++/4.8.0/ext/new_allocator.h" 1 3
># 40 "/usr/include/c++/4.8.0/ext/new_allocator.h" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>  using std::size_t;
>  using std::ptrdiff_t;
># 57 "/usr/include/c++/4.8.0/ext/new_allocator.h" 3
>  template<typename _Tp>
>    class new_allocator
>    {
>    public:
>      typedef size_t size_type;
>      typedef ptrdiff_t difference_type;
>      typedef _Tp* pointer;
>      typedef const _Tp* const_pointer;
>      typedef _Tp& reference;
>      typedef const _Tp& const_reference;
>      typedef _Tp value_type;
>
>      template<typename _Tp1>
>        struct rebind
>        { typedef new_allocator<_Tp1> other; };
>
>
>
>
>
>
>
>      new_allocator() throw() { }
>
>      new_allocator(const new_allocator&) throw() { }
>
>      template<typename _Tp1>
>        new_allocator(const new_allocator<_Tp1>&) throw() { }
>
>      ~new_allocator() throw() { }
>
>      pointer
>      address(reference __x) const
>      { return std::__addressof(__x); }
>
>      const_pointer
>      address(const_reference __x) const
>      { return std::__addressof(__x); }
>
>
>
>      pointer
>      allocate(size_type __n, const void* = 0)
>      {
> if (__n > this->max_size())
>   std::__throw_bad_alloc();
>
> return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
>      }
>
>
>      void
>      deallocate(pointer __p, size_type)
>      { ::operator delete(__p); }
>
>      size_type
>      max_size() const throw()
>      { return size_t(-1) / sizeof(_Tp); }
># 128 "/usr/include/c++/4.8.0/ext/new_allocator.h" 3
>      void
>      construct(pointer __p, const _Tp& __val)
>      { ::new((void *)__p) _Tp(__val); }
>
>      void
>      destroy(pointer __p) { __p->~_Tp(); }
>
>    };
>
>  template<typename _Tp>
>    inline bool
>    operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
>    { return true; }
>
>  template<typename _Tp>
>    inline bool
>    operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
>    { return false; }
>
>
>}
># 34 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++allocator.h" 2 3
># 48 "/usr/include/c++/4.8.0/bits/allocator.h" 2 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 65 "/usr/include/c++/4.8.0/bits/allocator.h" 3
>  template<typename _Tp>
>    class allocator;
>
>
>  template<>
>    class allocator<void>
>    {
>    public:
>      typedef size_t size_type;
>      typedef ptrdiff_t difference_type;
>      typedef void* pointer;
>      typedef const void* const_pointer;
>      typedef void value_type;
>
>      template<typename _Tp1>
>        struct rebind
>        { typedef allocator<_Tp1> other; };
>
>
>
>
>
>
>    };
># 98 "/usr/include/c++/4.8.0/bits/allocator.h" 3
>  template<typename _Tp>
>    class allocator: public __gnu_cxx::new_allocator<_Tp>
>    {
>   public:
>      typedef size_t size_type;
>      typedef ptrdiff_t difference_type;
>      typedef _Tp* pointer;
>      typedef const _Tp* const_pointer;
>      typedef _Tp& reference;
>      typedef const _Tp& const_reference;
>      typedef _Tp value_type;
>
>      template<typename _Tp1>
>        struct rebind
>        { typedef allocator<_Tp1> other; };
>
>
>
>
>
>
>
>      allocator() throw() { }
>
>      allocator(const allocator& __a) throw()
>      : __gnu_cxx::new_allocator<_Tp>(__a) { }
>
>      template<typename _Tp1>
>        allocator(const allocator<_Tp1>&) throw() { }
>
>      ~allocator() throw() { }
>
>
>    };
>
>  template<typename _T1, typename _T2>
>    inline bool
>    operator==(const allocator<_T1>&, const allocator<_T2>&)
>    { return true; }
>
>  template<typename _Tp>
>    inline bool
>    operator==(const allocator<_Tp>&, const allocator<_Tp>&)
>    { return true; }
>
>  template<typename _T1, typename _T2>
>    inline bool
>    operator!=(const allocator<_T1>&, const allocator<_T2>&)
>    { return false; }
>
>  template<typename _Tp>
>    inline bool
>    operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
>    { return false; }
>
>
>  template<typename, typename>
>    struct uses_allocator;
># 164 "/usr/include/c++/4.8.0/bits/allocator.h" 3
>  extern template class allocator<char>;
>  extern template class allocator<wchar_t>;
>
>
>
>
>
>
>  template<typename _Alloc, bool = __is_empty(_Alloc)>
>    struct __alloc_swap
>    { static void _S_do_it(_Alloc&, _Alloc&) { } };
>
>  template<typename _Alloc>
>    struct __alloc_swap<_Alloc, false>
>    {
>      static void
>      _S_do_it(_Alloc& __one, _Alloc& __two)
>      {
>
> if (__one != __two)
>   swap(__one, __two);
>      }
>    };
>
>
>  template<typename _Alloc, bool = __is_empty(_Alloc)>
>    struct __alloc_neq
>    {
>      static bool
>      _S_do_it(const _Alloc&, const _Alloc&)
>      { return false; }
>    };
>
>  template<typename _Alloc>
>    struct __alloc_neq<_Alloc, false>
>    {
>      static bool
>      _S_do_it(const _Alloc& __one, const _Alloc& __two)
>      { return __one != __two; }
>    };
># 231 "/usr/include/c++/4.8.0/bits/allocator.h" 3
>
>}
># 39 "/usr/include/c++/4.8.0/ext/alloc_traits.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>  template<typename> struct allocator;
>
>}
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 127 "/usr/include/c++/4.8.0/ext/alloc_traits.h" 3
>template<typename _Alloc>
>  struct __alloc_traits
>
>
>
>  {
>    typedef _Alloc allocator_type;
># 206 "/usr/include/c++/4.8.0/ext/alloc_traits.h" 3
>    typedef typename _Alloc::pointer pointer;
>    typedef typename _Alloc::const_pointer const_pointer;
>    typedef typename _Alloc::value_type value_type;
>    typedef typename _Alloc::reference reference;
>    typedef typename _Alloc::const_reference const_reference;
>    typedef typename _Alloc::size_type size_type;
>    typedef typename _Alloc::difference_type difference_type;
>
>    static pointer
>    allocate(_Alloc& __a, size_type __n)
>    { return __a.allocate(__n); }
>
>    static void deallocate(_Alloc& __a, pointer __p, size_type __n)
>    { __a.deallocate(__p, __n); }
>
>    template<typename _Tp>
>      static void construct(_Alloc& __a, pointer __p, const _Tp& __arg)
>      { __a.construct(__p, __arg); }
>
>    static void destroy(_Alloc& __a, pointer __p)
>    { __a.destroy(__p); }
>
>    static size_type max_size(const _Alloc& __a)
>    { return __a.max_size(); }
>
>    static const _Alloc& _S_select_on_copy(const _Alloc& __a) { return __a; }
>
>    static void _S_on_swap(_Alloc& __a, _Alloc& __b)
>    {
>
>
>      std::__alloc_swap<_Alloc>::_S_do_it(__a, __b);
>    }
>
>    template<typename _Tp>
>      struct rebind
>      { typedef typename _Alloc::template rebind<_Tp>::other other; };
>
>  };
>
>
>}
># 62 "/usr/include/c++/4.8.0/bits/stl_construct.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 77 "/usr/include/c++/4.8.0/bits/stl_construct.h" 3
>  template<typename _T1, typename _T2>
>    inline void
>    _Construct(_T1* __p, const _T2& __value)
>    {
>
>
>      ::new(static_cast<void*>(__p)) _T1(__value);
>    }
>
>
>
>
>
>  template<typename _Tp>
>    inline void
>    _Destroy(_Tp* __pointer)
>    { __pointer->~_Tp(); }
>
>  template<bool>
>    struct _Destroy_aux
>    {
>      template<typename _ForwardIterator>
>        static void
>        __destroy(_ForwardIterator __first, _ForwardIterator __last)
> {
>   for (; __first != __last; ++__first)
>     std::_Destroy(std::__addressof(*__first));
> }
>    };
>
>  template<>
>    struct _Destroy_aux<true>
>    {
>      template<typename _ForwardIterator>
>        static void
>        __destroy(_ForwardIterator, _ForwardIterator) { }
>    };
>
>
>
>
>
>
>  template<typename _ForwardIterator>
>    inline void
>    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
>    {
>      typedef typename iterator_traits<_ForwardIterator>::value_type
>                       _Value_type;
>      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
> __destroy(__first, __last);
>    }
>
>
>
>
>
>
>
>  template <typename _Tp> class allocator;
>
>  template<typename _ForwardIterator, typename _Allocator>
>    void
>    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
>      _Allocator& __alloc)
>    {
>      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
>      for (; __first != __last; ++__first)
> __traits::destroy(__alloc, std::__addressof(*__first));
>    }
>
>  template<typename _ForwardIterator, typename _Tp>
>    inline void
>    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
>      allocator<_Tp>&)
>    {
>      _Destroy(__first, __last);
>    }
>
>
>}
># 61 "/usr/include/c++/4.8.0/bits/stl_tempbuf.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 83 "/usr/include/c++/4.8.0/bits/stl_tempbuf.h" 3
>  template<typename _Tp>
>    pair<_Tp*, ptrdiff_t>
>    get_temporary_buffer(ptrdiff_t __len)
>    {
>      const ptrdiff_t __max =
> __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
>      if (__len > __max)
> __len = __max;
>
>      while (__len > 0)
> {
>   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
>       std::nothrow));
>   if (__tmp != 0)
>     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
>   __len /= 2;
> }
>      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
>    }
># 110 "/usr/include/c++/4.8.0/bits/stl_tempbuf.h" 3
>  template<typename _Tp>
>    inline void
>    return_temporary_buffer(_Tp* __p)
>    { ::operator delete(__p, std::nothrow); }
>
>
>
>
>
>
>
>  template<typename _ForwardIterator, typename _Tp>
>    class _Temporary_buffer
>    {
>
>     
>
>    public:
>      typedef _Tp value_type;
>      typedef value_type* pointer;
>      typedef pointer iterator;
>      typedef ptrdiff_t size_type;
>
>    protected:
>      size_type _M_original_len;
>      size_type _M_len;
>      pointer _M_buffer;
>
>    public:
>
>      size_type
>      size() const
>      { return _M_len; }
>
>
>      size_type
>      requested_size() const
>      { return _M_original_len; }
>
>
>      iterator
>      begin()
>      { return _M_buffer; }
>
>
>      iterator
>      end()
>      { return _M_buffer + _M_len; }
>
>
>
>
>
>      _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
>
>      ~_Temporary_buffer()
>      {
> std::_Destroy(_M_buffer, _M_buffer + _M_len);
> std::return_temporary_buffer(_M_buffer);
>      }
>
>    private:
>
>      _Temporary_buffer(const _Temporary_buffer&);
>
>      void
>      operator=(const _Temporary_buffer&);
>    };
>
>
>  template<bool>
>    struct __uninitialized_construct_buf_dispatch
>    {
>      template<typename _Pointer, typename _ForwardIterator>
>        static void
>        __ucr(_Pointer __first, _Pointer __last,
>       _ForwardIterator __seed)
>        {
>   if(__first == __last)
>     return;
>
>   _Pointer __cur = __first;
>   try
>     {
>       std::_Construct(std::__addressof(*__first),
>         (*__seed));
>       _Pointer __prev = __cur;
>       ++__cur;
>       for(; __cur != __last; ++__cur, ++__prev)
>  std::_Construct(std::__addressof(*__cur),
>    (*__prev));
>       *__seed = (*__prev);
>     }
>   catch(...)
>     {
>       std::_Destroy(__first, __cur);
>       throw;
>     }
> }
>    };
>
>  template<>
>    struct __uninitialized_construct_buf_dispatch<true>
>    {
>      template<typename _Pointer, typename _ForwardIterator>
>        static void
>        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
>    };
># 229 "/usr/include/c++/4.8.0/bits/stl_tempbuf.h" 3
>  template<typename _Pointer, typename _ForwardIterator>
>    inline void
>    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
>      _ForwardIterator __seed)
>    {
>      typedef typename std::iterator_traits<_Pointer>::value_type
> _ValueType;
>
>      std::__uninitialized_construct_buf_dispatch<
>        __has_trivial_constructor(_ValueType)>::
>   __ucr(__first, __last, __seed);
>    }
>
>  template<typename _ForwardIterator, typename _Tp>
>    _Temporary_buffer<_ForwardIterator, _Tp>::
>    _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
>    : _M_original_len(std::distance(__first, __last)),
>      _M_len(0), _M_buffer(0)
>    {
>      try
> {
>   std::pair<pointer, size_type> __p(std::get_temporary_buffer<
>         value_type>(_M_original_len));
>   _M_buffer = __p.first;
>   _M_len = __p.second;
>   if (_M_buffer)
>     std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
>            __first);
> }
>      catch(...)
> {
>   std::return_temporary_buffer(_M_buffer);
>   _M_buffer = 0;
>   _M_len = 0;
>   throw;
> }
>    }
>
>
>}
># 63 "/usr/include/c++/4.8.0/bits/stl_algo.h" 2 3
># 71 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>  template<typename _Iterator>
>    void
>    __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c)
>    {
>
>     
>
>
>      if (*__a < *__b)
> {
>   if (*__b < *__c)
>     std::iter_swap(__a, __b);
>   else if (*__a < *__c)
>     std::iter_swap(__a, __c);
> }
>      else if (*__a < *__c)
> return;
>      else if (*__b < *__c)
> std::iter_swap(__a, __c);
>      else
> std::iter_swap(__a, __b);
>    }
>
>
>  template<typename _Iterator, typename _Compare>
>    void
>    __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c,
>   _Compare __comp)
>    {
>
>     
>
>
>
>      if (__comp(*__a, *__b))
> {
>   if (__comp(*__b, *__c))
>     std::iter_swap(__a, __b);
>   else if (__comp(*__a, *__c))
>     std::iter_swap(__a, __c);
> }
>      else if (__comp(*__a, *__c))
> return;
>      else if (__comp(*__b, *__c))
> std::iter_swap(__a, __c);
>      else
> std::iter_swap(__a, __b);
>    }
>
>
>
>
>  template<typename _InputIterator, typename _Tp>
>    inline _InputIterator
>    __find(_InputIterator __first, _InputIterator __last,
>    const _Tp& __val, input_iterator_tag)
>    {
>      while (__first != __last && !(*__first == __val))
> ++__first;
>      return __first;
>    }
>
>
>  template<typename _InputIterator, typename _Predicate>
>    inline _InputIterator
>    __find_if(_InputIterator __first, _InputIterator __last,
>       _Predicate __pred, input_iterator_tag)
>    {
>      while (__first != __last && !bool(__pred(*__first)))
> ++__first;
>      return __first;
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Tp>
>    _RandomAccessIterator
>    __find(_RandomAccessIterator __first, _RandomAccessIterator __last,
>    const _Tp& __val, random_access_iterator_tag)
>    {
>      typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
>      for (; __trip_count > 0; --__trip_count)
> {
>   if (*__first == __val)
>     return __first;
>   ++__first;
>
>   if (*__first == __val)
>     return __first;
>   ++__first;
>
>   if (*__first == __val)
>     return __first;
>   ++__first;
>
>   if (*__first == __val)
>     return __first;
>   ++__first;
> }
>
>      switch (__last - __first)
> {
> case 3:
>   if (*__first == __val)
>     return __first;
>   ++__first;
> case 2:
>   if (*__first == __val)
>     return __first;
>   ++__first;
> case 1:
>   if (*__first == __val)
>     return __first;
>   ++__first;
> case 0:
> default:
>   return __last;
> }
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Predicate>
>    _RandomAccessIterator
>    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
>       _Predicate __pred, random_access_iterator_tag)
>    {
>      typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
>      for (; __trip_count > 0; --__trip_count)
> {
>   if (__pred(*__first))
>     return __first;
>   ++__first;
>
>   if (__pred(*__first))
>     return __first;
>   ++__first;
>
>   if (__pred(*__first))
>     return __first;
>   ++__first;
>
>   if (__pred(*__first))
>     return __first;
>   ++__first;
> }
>
>      switch (__last - __first)
> {
> case 3:
>   if (__pred(*__first))
>     return __first;
>   ++__first;
> case 2:
>   if (__pred(*__first))
>     return __first;
>   ++__first;
> case 1:
>   if (__pred(*__first))
>     return __first;
>   ++__first;
> case 0:
> default:
>   return __last;
> }
>    }
>
>
>  template<typename _InputIterator, typename _Predicate>
>    inline _InputIterator
>    __find_if_not(_InputIterator __first, _InputIterator __last,
>    _Predicate __pred, input_iterator_tag)
>    {
>      while (__first != __last && bool(__pred(*__first)))
> ++__first;
>      return __first;
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Predicate>
>    _RandomAccessIterator
>    __find_if_not(_RandomAccessIterator __first, _RandomAccessIterator __last,
>    _Predicate __pred, random_access_iterator_tag)
>    {
>      typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
>      for (; __trip_count > 0; --__trip_count)
> {
>   if (!bool(__pred(*__first)))
>     return __first;
>   ++__first;
>
>   if (!bool(__pred(*__first)))
>     return __first;
>   ++__first;
>
>   if (!bool(__pred(*__first)))
>     return __first;
>   ++__first;
>
>   if (!bool(__pred(*__first)))
>     return __first;
>   ++__first;
> }
>
>      switch (__last - __first)
> {
> case 3:
>   if (!bool(__pred(*__first)))
>     return __first;
>   ++__first;
> case 2:
>   if (!bool(__pred(*__first)))
>     return __first;
>   ++__first;
> case 1:
>   if (!bool(__pred(*__first)))
>     return __first;
>   ++__first;
> case 0:
> default:
>   return __last;
> }
>    }
>
>
>  template<typename _InputIterator, typename _Predicate>
>    inline _InputIterator
>    __find_if_not(_InputIterator __first, _InputIterator __last,
>    _Predicate __pred)
>    {
>      return std::__find_if_not(__first, __last, __pred,
>    std::__iterator_category(__first));
>    }
>
>
>
>
>  template<typename _InputIterator, typename _Predicate, typename _Distance>
>    _InputIterator
>    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
>    {
>      for (; __len; --__len, ++__first)
> if (!bool(__pred(*__first)))
>   break;
>      return __first;
>    }
># 345 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Integer, typename _Tp>
>    _ForwardIterator
>    __search_n(_ForwardIterator __first, _ForwardIterator __last,
>        _Integer __count, const _Tp& __val,
>        std::forward_iterator_tag)
>    {
>      __first = std::find(__first, __last, __val);
>      while (__first != __last)
> {
>   typename iterator_traits<_ForwardIterator>::difference_type
>     __n = __count;
>   _ForwardIterator __i = __first;
>   ++__i;
>   while (__i != __last && __n != 1 && *__i == __val)
>     {
>       ++__i;
>       --__n;
>     }
>   if (__n == 1)
>     return __first;
>   if (__i == __last)
>     return __last;
>   __first = std::find(++__i, __last, __val);
> }
>      return __last;
>    }
>
>
>
>
>
>
>  template<typename _RandomAccessIter, typename _Integer, typename _Tp>
>    _RandomAccessIter
>    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
>        _Integer __count, const _Tp& __val,
>        std::random_access_iterator_tag)
>    {
>
>      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
> _DistanceType;
>
>      _DistanceType __tailSize = __last - __first;
>      const _DistanceType __pattSize = __count;
>
>      if (__tailSize < __pattSize)
>        return __last;
>
>      const _DistanceType __skipOffset = __pattSize - 1;
>      _RandomAccessIter __lookAhead = __first + __skipOffset;
>      __tailSize -= __pattSize;
>
>      while (1)
> {
>
>
>   while (!(*__lookAhead == __val))
>     {
>       if (__tailSize < __pattSize)
>  return __last;
>       __lookAhead += __pattSize;
>       __tailSize -= __pattSize;
>     }
>   _DistanceType __remainder = __skipOffset;
>   for (_RandomAccessIter __backTrack = __lookAhead - 1;
>        *__backTrack == __val; --__backTrack)
>     {
>       if (--__remainder == 0)
>  return (__lookAhead - __skipOffset);
>     }
>   if (__remainder > __tailSize)
>     return __last;
>   __lookAhead += __remainder;
>   __tailSize -= __remainder;
> }
>    }
># 430 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Integer, typename _Tp,
>           typename _BinaryPredicate>
>    _ForwardIterator
>    __search_n(_ForwardIterator __first, _ForwardIterator __last,
>        _Integer __count, const _Tp& __val,
>        _BinaryPredicate __binary_pred, std::forward_iterator_tag)
>    {
>      while (__first != __last && !bool(__binary_pred(*__first, __val)))
>        ++__first;
>
>      while (__first != __last)
> {
>   typename iterator_traits<_ForwardIterator>::difference_type
>     __n = __count;
>   _ForwardIterator __i = __first;
>   ++__i;
>   while (__i != __last && __n != 1 && bool(__binary_pred(*__i, __val)))
>     {
>       ++__i;
>       --__n;
>     }
>   if (__n == 1)
>     return __first;
>   if (__i == __last)
>     return __last;
>   __first = ++__i;
>   while (__first != __last
>   && !bool(__binary_pred(*__first, __val)))
>     ++__first;
> }
>      return __last;
>    }
>
>
>
>
>
>
>
>  template<typename _RandomAccessIter, typename _Integer, typename _Tp,
>    typename _BinaryPredicate>
>    _RandomAccessIter
>    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
>        _Integer __count, const _Tp& __val,
>        _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
>    {
>
>      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
> _DistanceType;
>
>      _DistanceType __tailSize = __last - __first;
>      const _DistanceType __pattSize = __count;
>
>      if (__tailSize < __pattSize)
>        return __last;
>
>      const _DistanceType __skipOffset = __pattSize - 1;
>      _RandomAccessIter __lookAhead = __first + __skipOffset;
>      __tailSize -= __pattSize;
>
>      while (1)
> {
>
>
>   while (!bool(__binary_pred(*__lookAhead, __val)))
>     {
>       if (__tailSize < __pattSize)
>  return __last;
>       __lookAhead += __pattSize;
>       __tailSize -= __pattSize;
>     }
>   _DistanceType __remainder = __skipOffset;
>   for (_RandomAccessIter __backTrack = __lookAhead - 1;
>        __binary_pred(*__backTrack, __val); --__backTrack)
>     {
>       if (--__remainder == 0)
>  return (__lookAhead - __skipOffset);
>     }
>   if (__remainder > __tailSize)
>     return __last;
>   __lookAhead += __remainder;
>   __tailSize -= __remainder;
> }
>    }
>
>
>  template<typename _ForwardIterator1, typename _ForwardIterator2>
>    _ForwardIterator1
>    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
>        forward_iterator_tag, forward_iterator_tag)
>    {
>      if (__first2 == __last2)
> return __last1;
>      else
> {
>   _ForwardIterator1 __result = __last1;
>   while (1)
>     {
>       _ForwardIterator1 __new_result
>  = std::search(__first1, __last1, __first2, __last2);
>       if (__new_result == __last1)
>  return __result;
>       else
>  {
>    __result = __new_result;
>    __first1 = __new_result;
>    ++__first1;
>  }
>     }
> }
>    }
>
>  template<typename _ForwardIterator1, typename _ForwardIterator2,
>    typename _BinaryPredicate>
>    _ForwardIterator1
>    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
>        forward_iterator_tag, forward_iterator_tag,
>        _BinaryPredicate __comp)
>    {
>      if (__first2 == __last2)
> return __last1;
>      else
> {
>   _ForwardIterator1 __result = __last1;
>   while (1)
>     {
>       _ForwardIterator1 __new_result
>  = std::search(__first1, __last1, __first2,
>      __last2, __comp);
>       if (__new_result == __last1)
>  return __result;
>       else
>  {
>    __result = __new_result;
>    __first1 = __new_result;
>    ++__first1;
>  }
>     }
> }
>    }
>
>
>  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
>    _BidirectionalIterator1
>    __find_end(_BidirectionalIterator1 __first1,
>        _BidirectionalIterator1 __last1,
>        _BidirectionalIterator2 __first2,
>        _BidirectionalIterator2 __last2,
>        bidirectional_iterator_tag, bidirectional_iterator_tag)
>    {
>
>     
>
>     
>
>
>      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
>      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
>
>      _RevIterator1 __rlast1(__first1);
>      _RevIterator2 __rlast2(__first2);
>      _RevIterator1 __rresult = std::search(_RevIterator1(__last1),
>             __rlast1,
>             _RevIterator2(__last2),
>             __rlast2);
>
>      if (__rresult == __rlast1)
> return __last1;
>      else
> {
>   _BidirectionalIterator1 __result = __rresult.base();
>   std::advance(__result, -std::distance(__first2, __last2));
>   return __result;
> }
>    }
>
>  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
>    typename _BinaryPredicate>
>    _BidirectionalIterator1
>    __find_end(_BidirectionalIterator1 __first1,
>        _BidirectionalIterator1 __last1,
>        _BidirectionalIterator2 __first2,
>        _BidirectionalIterator2 __last2,
>        bidirectional_iterator_tag, bidirectional_iterator_tag,
>        _BinaryPredicate __comp)
>    {
>
>     
>
>     
>
>
>      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
>      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
>
>      _RevIterator1 __rlast1(__first1);
>      _RevIterator2 __rlast2(__first2);
>      _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
>         _RevIterator2(__last2), __rlast2,
>         __comp);
>
>      if (__rresult == __rlast1)
> return __last1;
>      else
> {
>   _BidirectionalIterator1 __result = __rresult.base();
>   std::advance(__result, -std::distance(__first2, __last2));
>   return __result;
> }
>    }
># 669 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator1, typename _ForwardIterator2>
>    inline _ForwardIterator1
>    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
>    {
>
>     
>     
>     
>
>
>      ;
>      ;
>
>      return std::__find_end(__first1, __last1, __first2, __last2,
>        std::__iterator_category(__first1),
>        std::__iterator_category(__first2));
>    }
># 716 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator1, typename _ForwardIterator2,
>    typename _BinaryPredicate>
>    inline _ForwardIterator1
>    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
>      _BinaryPredicate __comp)
>    {
>
>     
>     
>     
>
>
>      ;
>      ;
>
>      return std::__find_end(__first1, __last1, __first2, __last2,
>        std::__iterator_category(__first1),
>        std::__iterator_category(__first2),
>        __comp);
>    }
># 895 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
>    _OutputIterator
>    remove_copy(_InputIterator __first, _InputIterator __last,
>  _OutputIterator __result, const _Tp& __value)
>    {
>
>     
>     
>
>     
>
>      ;
>
>      for (; __first != __last; ++__first)
> if (!(*__first == __value))
>   {
>     *__result = *__first;
>     ++__result;
>   }
>      return __result;
>    }
># 932 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _OutputIterator,
>    typename _Predicate>
>    _OutputIterator
>    remove_copy_if(_InputIterator __first, _InputIterator __last,
>     _OutputIterator __result, _Predicate __pred)
>    {
>
>     
>     
>
>     
>
>      ;
>
>      for (; __first != __last; ++__first)
> if (!bool(__pred(*__first)))
>   {
>     *__result = *__first;
>     ++__result;
>   }
>      return __result;
>    }
># 1113 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Tp>
>    _ForwardIterator
>    remove(_ForwardIterator __first, _ForwardIterator __last,
>    const _Tp& __value)
>    {
>
>     
>
>     
>
>      ;
>
>      __first = std::find(__first, __last, __value);
>      if(__first == __last)
>        return __first;
>      _ForwardIterator __result = __first;
>      ++__first;
>      for(; __first != __last; ++__first)
>        if(!(*__first == __value))
>          {
>            *__result = (*__first);
>            ++__result;
>          }
>      return __result;
>    }
># 1156 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Predicate>
>    _ForwardIterator
>    remove_if(_ForwardIterator __first, _ForwardIterator __last,
>       _Predicate __pred)
>    {
>
>     
>
>     
>
>      ;
>
>      __first = std::find_if(__first, __last, __pred);
>      if(__first == __last)
>        return __first;
>      _ForwardIterator __result = __first;
>      ++__first;
>      for(; __first != __last; ++__first)
>        if(!bool(__pred(*__first)))
>          {
>            *__result = (*__first);
>            ++__result;
>          }
>      return __result;
>    }
># 1196 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator>
>    _ForwardIterator
>    unique(_ForwardIterator __first, _ForwardIterator __last)
>    {
>
>     
>
>     
>
>      ;
>
>
>      __first = std::adjacent_find(__first, __last);
>      if (__first == __last)
> return __last;
>
>
>      _ForwardIterator __dest = __first;
>      ++__first;
>      while (++__first != __last)
> if (!(*__dest == *__first))
>   *++__dest = (*__first);
>      return ++__dest;
>    }
># 1236 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _BinaryPredicate>
>    _ForwardIterator
>    unique(_ForwardIterator __first, _ForwardIterator __last,
>           _BinaryPredicate __binary_pred)
>    {
>
>     
>
>     
>
>
>      ;
>
>
>      __first = std::adjacent_find(__first, __last, __binary_pred);
>      if (__first == __last)
> return __last;
>
>
>      _ForwardIterator __dest = __first;
>      ++__first;
>      while (++__first != __last)
> if (!bool(__binary_pred(*__dest, *__first)))
>   *++__dest = (*__first);
>      return ++__dest;
>    }
>
>
>
>
>
>
>  template<typename _ForwardIterator, typename _OutputIterator>
>    _OutputIterator
>    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
>    _OutputIterator __result,
>    forward_iterator_tag, output_iterator_tag)
>    {
>
>      _ForwardIterator __next = __first;
>      *__result = *__first;
>      while (++__next != __last)
> if (!(*__first == *__next))
>   {
>     __first = __next;
>     *++__result = *__first;
>   }
>      return ++__result;
>    }
>
>
>
>
>
>
>  template<typename _InputIterator, typename _OutputIterator>
>    _OutputIterator
>    __unique_copy(_InputIterator __first, _InputIterator __last,
>    _OutputIterator __result,
>    input_iterator_tag, output_iterator_tag)
>    {
>
>      typename iterator_traits<_InputIterator>::value_type __value = *__first;
>      *__result = __value;
>      while (++__first != __last)
> if (!(__value == *__first))
>   {
>     __value = *__first;
>     *++__result = __value;
>   }
>      return ++__result;
>    }
>
>
>
>
>
>
>  template<typename _InputIterator, typename _ForwardIterator>
>    _ForwardIterator
>    __unique_copy(_InputIterator __first, _InputIterator __last,
>    _ForwardIterator __result,
>    input_iterator_tag, forward_iterator_tag)
>    {
>
>      *__result = *__first;
>      while (++__first != __last)
> if (!(*__result == *__first))
>   *++__result = *__first;
>      return ++__result;
>    }
>
>
>
>
>
>
>
>  template<typename _ForwardIterator, typename _OutputIterator,
>    typename _BinaryPredicate>
>    _OutputIterator
>    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
>    _OutputIterator __result, _BinaryPredicate __binary_pred,
>    forward_iterator_tag, output_iterator_tag)
>    {
>
>     
>
>
>
>      _ForwardIterator __next = __first;
>      *__result = *__first;
>      while (++__next != __last)
> if (!bool(__binary_pred(*__first, *__next)))
>   {
>     __first = __next;
>     *++__result = *__first;
>   }
>      return ++__result;
>    }
>
>
>
>
>
>
>
>  template<typename _InputIterator, typename _OutputIterator,
>    typename _BinaryPredicate>
>    _OutputIterator
>    __unique_copy(_InputIterator __first, _InputIterator __last,
>    _OutputIterator __result, _BinaryPredicate __binary_pred,
>    input_iterator_tag, output_iterator_tag)
>    {
>
>     
>
>
>
>      typename iterator_traits<_InputIterator>::value_type __value = *__first;
>      *__result = __value;
>      while (++__first != __last)
> if (!bool(__binary_pred(__value, *__first)))
>   {
>     __value = *__first;
>     *++__result = __value;
>   }
>      return ++__result;
>    }
>
>
>
>
>
>
>
>  template<typename _InputIterator, typename _ForwardIterator,
>    typename _BinaryPredicate>
>    _ForwardIterator
>    __unique_copy(_InputIterator __first, _InputIterator __last,
>    _ForwardIterator __result, _BinaryPredicate __binary_pred,
>    input_iterator_tag, forward_iterator_tag)
>    {
>
>     
>
>
>
>      *__result = *__first;
>      while (++__first != __last)
> if (!bool(__binary_pred(*__result, *__first)))
>   *++__result = *__first;
>      return ++__result;
>    }
>
>
>
>
>
>
>  template<typename _BidirectionalIterator>
>    void
>    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
>       bidirectional_iterator_tag)
>    {
>      while (true)
> if (__first == __last || __first == --__last)
>   return;
> else
>   {
>     std::iter_swap(__first, __last);
>     ++__first;
>   }
>    }
>
>
>
>
>
>
>  template<typename _RandomAccessIterator>
>    void
>    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
>       random_access_iterator_tag)
>    {
>      if (__first == __last)
> return;
>      --__last;
>      while (__first < __last)
> {
>   std::iter_swap(__first, __last);
>   ++__first;
>   --__last;
> }
>    }
># 1464 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _BidirectionalIterator>
>    inline void
>    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
>    {
>
>     
>
>      ;
>      std::__reverse(__first, __last, std::__iterator_category(__first));
>    }
># 1491 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _BidirectionalIterator, typename _OutputIterator>
>    _OutputIterator
>    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
>   _OutputIterator __result)
>    {
>
>     
>
>     
>
>      ;
>
>      while (__first != __last)
> {
>   --__last;
>   *__result = *__last;
>   ++__result;
> }
>      return __result;
>    }
>
>
>
>
>
>  template<typename _EuclideanRingElement>
>    _EuclideanRingElement
>    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
>    {
>      while (__n != 0)
> {
>   _EuclideanRingElement __t = __m % __n;
>   __m = __n;
>   __n = __t;
> }
>      return __m;
>    }
>
>
>  template<typename _ForwardIterator>
>    void
>    __rotate(_ForwardIterator __first,
>      _ForwardIterator __middle,
>      _ForwardIterator __last,
>      forward_iterator_tag)
>    {
>      if (__first == __middle || __last == __middle)
> return;
>
>      _ForwardIterator __first2 = __middle;
>      do
> {
>   std::iter_swap(__first, __first2);
>   ++__first;
>   ++__first2;
>   if (__first == __middle)
>     __middle = __first2;
> }
>      while (__first2 != __last);
>
>      __first2 = __middle;
>
>      while (__first2 != __last)
> {
>   std::iter_swap(__first, __first2);
>   ++__first;
>   ++__first2;
>   if (__first == __middle)
>     __middle = __first2;
>   else if (__first2 == __last)
>     __first2 = __middle;
> }
>    }
>
>
>  template<typename _BidirectionalIterator>
>    void
>    __rotate(_BidirectionalIterator __first,
>      _BidirectionalIterator __middle,
>      _BidirectionalIterator __last,
>       bidirectional_iterator_tag)
>    {
>
>     
>
>
>      if (__first == __middle || __last == __middle)
> return;
>
>      std::__reverse(__first, __middle, bidirectional_iterator_tag());
>      std::__reverse(__middle, __last, bidirectional_iterator_tag());
>
>      while (__first != __middle && __middle != __last)
> {
>   std::iter_swap(__first, --__last);
>   ++__first;
> }
>
>      if (__first == __middle)
> std::__reverse(__middle, __last, bidirectional_iterator_tag());
>      else
> std::__reverse(__first, __middle, bidirectional_iterator_tag());
>    }
>
>
>  template<typename _RandomAccessIterator>
>    void
>    __rotate(_RandomAccessIterator __first,
>      _RandomAccessIterator __middle,
>      _RandomAccessIterator __last,
>      random_access_iterator_tag)
>    {
>
>     
>
>
>      if (__first == __middle || __last == __middle)
> return;
>
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>      _Distance __n = __last - __first;
>      _Distance __k = __middle - __first;
>
>      if (__k == __n - __k)
> {
>   std::swap_ranges(__first, __middle, __middle);
>   return;
> }
>
>      _RandomAccessIterator __p = __first;
>
>      for (;;)
> {
>   if (__k < __n - __k)
>     {
>       if (__is_pod(_ValueType) && __k == 1)
>  {
>    _ValueType __t = (*__p);
>    std::copy(__p + 1, __p + __n, __p);
>    *(__p + __n - 1) = (__t);
>    return;
>  }
>       _RandomAccessIterator __q = __p + __k;
>       for (_Distance __i = 0; __i < __n - __k; ++ __i)
>  {
>    std::iter_swap(__p, __q);
>    ++__p;
>    ++__q;
>  }
>       __n %= __k;
>       if (__n == 0)
>  return;
>       std::swap(__n, __k);
>       __k = __n - __k;
>     }
>   else
>     {
>       __k = __n - __k;
>       if (__is_pod(_ValueType) && __k == 1)
>  {
>    _ValueType __t = (*(__p + __n - 1));
>    std::copy_backward(__p, __p + __n - 1, __p + __n);
>    *__p = (__t);
>    return;
>  }
>       _RandomAccessIterator __q = __p + __n;
>       __p = __q - __k;
>       for (_Distance __i = 0; __i < __n - __k; ++ __i)
>  {
>    --__p;
>    --__q;
>    std::iter_swap(__p, __q);
>  }
>       __n %= __k;
>       if (__n == 0)
>  return;
>       std::swap(__n, __k);
>     }
> }
>    }
># 1697 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator>
>    inline void
>    rotate(_ForwardIterator __first, _ForwardIterator __middle,
>    _ForwardIterator __last)
>    {
>
>     
>
>      ;
>      ;
>
>      typedef typename iterator_traits<_ForwardIterator>::iterator_category
> _IterType;
>      std::__rotate(__first, __middle, __last, _IterType());
>    }
># 1733 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _OutputIterator>
>    _OutputIterator
>    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
>                _ForwardIterator __last, _OutputIterator __result)
>    {
>
>     
>     
>
>      ;
>      ;
>
>      return std::copy(__first, __middle,
>                       std::copy(__middle, __last, __result));
>    }
>
>
>  template<typename _ForwardIterator, typename _Predicate>
>    _ForwardIterator
>    __partition(_ForwardIterator __first, _ForwardIterator __last,
>  _Predicate __pred, forward_iterator_tag)
>    {
>      if (__first == __last)
> return __first;
>
>      while (__pred(*__first))
> if (++__first == __last)
>   return __first;
>
>      _ForwardIterator __next = __first;
>
>      while (++__next != __last)
> if (__pred(*__next))
>   {
>     std::iter_swap(__first, __next);
>     ++__first;
>   }
>
>      return __first;
>    }
>
>
>  template<typename _BidirectionalIterator, typename _Predicate>
>    _BidirectionalIterator
>    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
>  _Predicate __pred, bidirectional_iterator_tag)
>    {
>      while (true)
> {
>   while (true)
>     if (__first == __last)
>       return __first;
>     else if (__pred(*__first))
>       ++__first;
>     else
>       break;
>   --__last;
>   while (true)
>     if (__first == __last)
>       return __first;
>     else if (!bool(__pred(*__last)))
>       --__last;
>     else
>       break;
>   std::iter_swap(__first, __last);
>   ++__first;
> }
>    }
>
>
>
>
>
>
>  template<typename _ForwardIterator, typename _Predicate, typename _Distance>
>    _ForwardIterator
>    __inplace_stable_partition(_ForwardIterator __first,
>          _Predicate __pred, _Distance __len)
>    {
>      if (__len == 1)
> return __first;
>      _ForwardIterator __middle = __first;
>      std::advance(__middle, __len / 2);
>      _ForwardIterator __left_split =
> std::__inplace_stable_partition(__first, __pred, __len / 2);
>
>
>      _Distance __right_len = __len - __len / 2;
>      _ForwardIterator __right_split =
> std::__find_if_not_n(__middle, __right_len, __pred);
>      if (__right_len)
> __right_split = std::__inplace_stable_partition(__middle,
>       __pred,
>       __right_len);
>      std::rotate(__left_split, __middle, __right_split);
>      std::advance(__left_split, std::distance(__middle, __right_split));
>      return __left_split;
>    }
>
>
>
>
>
>
>
>  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
>    typename _Distance>
>    _ForwardIterator
>    __stable_partition_adaptive(_ForwardIterator __first,
>    _ForwardIterator __last,
>    _Predicate __pred, _Distance __len,
>    _Pointer __buffer,
>    _Distance __buffer_size)
>    {
>      if (__len <= __buffer_size)
> {
>   _ForwardIterator __result1 = __first;
>   _Pointer __result2 = __buffer;
>
>
>
>   *__result2 = (*__first);
>   ++__result2;
>   ++__first;
>   for (; __first != __last; ++__first)
>     if (__pred(*__first))
>       {
>  *__result1 = (*__first);
>  ++__result1;
>       }
>     else
>       {
>  *__result2 = (*__first);
>  ++__result2;
>       }
>   std::copy(__buffer, __result2, __result1);
>   return __result1;
> }
>      else
> {
>   _ForwardIterator __middle = __first;
>   std::advance(__middle, __len / 2);
>   _ForwardIterator __left_split =
>     std::__stable_partition_adaptive(__first, __middle, __pred,
>          __len / 2, __buffer,
>          __buffer_size);
>
>
>   _Distance __right_len = __len - __len / 2;
>   _ForwardIterator __right_split =
>     std::__find_if_not_n(__middle, __right_len, __pred);
>   if (__right_len)
>     __right_split =
>       std::__stable_partition_adaptive(__right_split, __last, __pred,
>            __right_len,
>            __buffer, __buffer_size);
>   std::rotate(__left_split, __middle, __right_split);
>   std::advance(__left_split, std::distance(__middle, __right_split));
>   return __left_split;
> }
>    }
># 1912 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Predicate>
>    _ForwardIterator
>    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
>       _Predicate __pred)
>    {
>
>     
>
>     
>
>      ;
>
>      __first = std::__find_if_not(__first, __last, __pred);
>
>      if (__first == __last)
> return __first;
>      else
> {
>   typedef typename iterator_traits<_ForwardIterator>::value_type
>     _ValueType;
>   typedef typename iterator_traits<_ForwardIterator>::difference_type
>     _DistanceType;
>
>   _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
>        __last);
> if (__buf.size() > 0)
>   return
>     std::__stable_partition_adaptive(__first, __last, __pred,
>       _DistanceType(__buf.requested_size()),
>       __buf.begin(),
>       _DistanceType(__buf.size()));
> else
>   return
>     std::__inplace_stable_partition(__first, __pred,
>      _DistanceType(__buf.requested_size()));
> }
>    }
>
>
>  template<typename _RandomAccessIterator>
>    void
>    __heap_select(_RandomAccessIterator __first,
>    _RandomAccessIterator __middle,
>    _RandomAccessIterator __last)
>    {
>      std::make_heap(__first, __middle);
>      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> if (*__i < *__first)
>   std::__pop_heap(__first, __middle, __i);
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Compare>
>    void
>    __heap_select(_RandomAccessIterator __first,
>    _RandomAccessIterator __middle,
>    _RandomAccessIterator __last, _Compare __comp)
>    {
>      std::make_heap(__first, __middle, __comp);
>      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> if (__comp(*__i, *__first))
>   std::__pop_heap(__first, __middle, __i, __comp);
>    }
># 1996 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _RandomAccessIterator>
>    _RandomAccessIterator
>    partial_sort_copy(_InputIterator __first, _InputIterator __last,
>        _RandomAccessIterator __result_first,
>        _RandomAccessIterator __result_last)
>    {
>      typedef typename iterator_traits<_InputIterator>::value_type
> _InputValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _OutputValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
>     
>     
>
>     
>
>     
>      ;
>      ;
>
>      if (__result_first == __result_last)
> return __result_last;
>      _RandomAccessIterator __result_real_last = __result_first;
>      while(__first != __last && __result_real_last != __result_last)
> {
>   *__result_real_last = *__first;
>   ++__result_real_last;
>   ++__first;
> }
>      std::make_heap(__result_first, __result_real_last);
>      while (__first != __last)
> {
>   if (*__first < *__result_first)
>     std::__adjust_heap(__result_first, _DistanceType(0),
>          _DistanceType(__result_real_last
>          - __result_first),
>          _InputValueType(*__first));
>   ++__first;
> }
>      std::sort_heap(__result_first, __result_real_last);
>      return __result_real_last;
>    }
># 2062 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
>    _RandomAccessIterator
>    partial_sort_copy(_InputIterator __first, _InputIterator __last,
>        _RandomAccessIterator __result_first,
>        _RandomAccessIterator __result_last,
>        _Compare __comp)
>    {
>      typedef typename iterator_traits<_InputIterator>::value_type
> _InputValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _OutputValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
>     
>     
>
>     
>
>     
>
>     
>
>      ;
>      ;
>
>      if (__result_first == __result_last)
> return __result_last;
>      _RandomAccessIterator __result_real_last = __result_first;
>      while(__first != __last && __result_real_last != __result_last)
> {
>   *__result_real_last = *__first;
>   ++__result_real_last;
>   ++__first;
> }
>      std::make_heap(__result_first, __result_real_last, __comp);
>      while (__first != __last)
> {
>   if (__comp(*__first, *__result_first))
>     std::__adjust_heap(__result_first, _DistanceType(0),
>          _DistanceType(__result_real_last
>          - __result_first),
>          _InputValueType(*__first),
>          __comp);
>   ++__first;
> }
>      std::sort_heap(__result_first, __result_real_last, __comp);
>      return __result_real_last;
>    }
>
>
>  template<typename _RandomAccessIterator>
>    void
>    __unguarded_linear_insert(_RandomAccessIterator __last)
>    {
>      typename iterator_traits<_RandomAccessIterator>::value_type
> __val = (*__last);
>      _RandomAccessIterator __next = __last;
>      --__next;
>      while (__val < *__next)
> {
>   *__last = (*__next);
>   __last = __next;
>   --__next;
> }
>      *__last = (__val);
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Compare>
>    void
>    __unguarded_linear_insert(_RandomAccessIterator __last,
>         _Compare __comp)
>    {
>      typename iterator_traits<_RandomAccessIterator>::value_type
> __val = (*__last);
>      _RandomAccessIterator __next = __last;
>      --__next;
>      while (__comp(__val, *__next))
> {
>   *__last = (*__next);
>   __last = __next;
>   --__next;
> }
>      *__last = (__val);
>    }
>
>
>  template<typename _RandomAccessIterator>
>    void
>    __insertion_sort(_RandomAccessIterator __first,
>       _RandomAccessIterator __last)
>    {
>      if (__first == __last)
> return;
>
>      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
>   if (*__i < *__first)
>     {
>       typename iterator_traits<_RandomAccessIterator>::value_type
>  __val = (*__i);
>       std::copy_backward(__first, __i, __i + 1);
>       *__first = (__val);
>     }
>   else
>     std::__unguarded_linear_insert(__i);
> }
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Compare>
>    void
>    __insertion_sort(_RandomAccessIterator __first,
>       _RandomAccessIterator __last, _Compare __comp)
>    {
>      if (__first == __last) return;
>
>      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
>   if (__comp(*__i, *__first))
>     {
>       typename iterator_traits<_RandomAccessIterator>::value_type
>  __val = (*__i);
>       std::copy_backward(__first, __i, __i + 1);
>       *__first = (__val);
>     }
>   else
>     std::__unguarded_linear_insert(__i, __comp);
> }
>    }
>
>
>  template<typename _RandomAccessIterator>
>    inline void
>    __unguarded_insertion_sort(_RandomAccessIterator __first,
>          _RandomAccessIterator __last)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i);
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Compare>
>    inline void
>    __unguarded_insertion_sort(_RandomAccessIterator __first,
>          _RandomAccessIterator __last, _Compare __comp)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i, __comp);
>    }
>
>
>
>
>
>  enum { _S_threshold = 16 };
>
>
>  template<typename _RandomAccessIterator>
>    void
>    __final_insertion_sort(_RandomAccessIterator __first,
>      _RandomAccessIterator __last)
>    {
>      if (__last - __first > int(_S_threshold))
> {
>   std::__insertion_sort(__first, __first + int(_S_threshold));
>   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
> }
>      else
> std::__insertion_sort(__first, __last);
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Compare>
>    void
>    __final_insertion_sort(_RandomAccessIterator __first,
>      _RandomAccessIterator __last, _Compare __comp)
>    {
>      if (__last - __first > int(_S_threshold))
> {
>   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
>   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
>       __comp);
> }
>      else
> std::__insertion_sort(__first, __last, __comp);
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Tp>
>    _RandomAccessIterator
>    __unguarded_partition(_RandomAccessIterator __first,
>     _RandomAccessIterator __last, const _Tp& __pivot)
>    {
>      while (true)
> {
>   while (*__first < __pivot)
>     ++__first;
>   --__last;
>   while (__pivot < *__last)
>     --__last;
>   if (!(__first < __last))
>     return __first;
>   std::iter_swap(__first, __last);
>   ++__first;
> }
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
>    _RandomAccessIterator
>    __unguarded_partition(_RandomAccessIterator __first,
>     _RandomAccessIterator __last,
>     const _Tp& __pivot, _Compare __comp)
>    {
>      while (true)
> {
>   while (__comp(*__first, __pivot))
>     ++__first;
>   --__last;
>   while (__comp(__pivot, *__last))
>     --__last;
>   if (!(__first < __last))
>     return __first;
>   std::iter_swap(__first, __last);
>   ++__first;
> }
>    }
>
>
>  template<typename _RandomAccessIterator>
>    inline _RandomAccessIterator
>    __unguarded_partition_pivot(_RandomAccessIterator __first,
>    _RandomAccessIterator __last)
>    {
>      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
>      std::__move_median_first(__first, __mid, (__last - 1));
>      return std::__unguarded_partition(__first + 1, __last, *__first);
>    }
>
>
>
>  template<typename _RandomAccessIterator, typename _Compare>
>    inline _RandomAccessIterator
>    __unguarded_partition_pivot(_RandomAccessIterator __first,
>    _RandomAccessIterator __last, _Compare __comp)
>    {
>      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
>      std::__move_median_first(__first, __mid, (__last - 1), __comp);
>      return std::__unguarded_partition(__first + 1, __last, *__first, __comp);
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Size>
>    void
>    __introsort_loop(_RandomAccessIterator __first,
>       _RandomAccessIterator __last,
>       _Size __depth_limit)
>    {
>      while (__last - __first > int(_S_threshold))
> {
>   if (__depth_limit == 0)
>     {
>       std::partial_sort(__first, __last, __last);
>       return;
>     }
>   --__depth_limit;
>   _RandomAccessIterator __cut =
>     std::__unguarded_partition_pivot(__first, __last);
>   std::__introsort_loop(__cut, __last, __depth_limit);
>   __last = __cut;
> }
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
>    void
>    __introsort_loop(_RandomAccessIterator __first,
>       _RandomAccessIterator __last,
>       _Size __depth_limit, _Compare __comp)
>    {
>      while (__last - __first > int(_S_threshold))
> {
>   if (__depth_limit == 0)
>     {
>       std::partial_sort(__first, __last, __last, __comp);
>       return;
>     }
>   --__depth_limit;
>   _RandomAccessIterator __cut =
>     std::__unguarded_partition_pivot(__first, __last, __comp);
>   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
>   __last = __cut;
> }
>    }
>
>
>
>  template<typename _RandomAccessIterator, typename _Size>
>    void
>    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
>    _RandomAccessIterator __last, _Size __depth_limit)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>      while (__last - __first > 3)
> {
>   if (__depth_limit == 0)
>     {
>       std::__heap_select(__first, __nth + 1, __last);
>
>
>       std::iter_swap(__first, __nth);
>       return;
>     }
>   --__depth_limit;
>   _RandomAccessIterator __cut =
>     std::__unguarded_partition_pivot(__first, __last);
>   if (__cut <= __nth)
>     __first = __cut;
>   else
>     __last = __cut;
> }
>      std::__insertion_sort(__first, __last);
>    }
>
>  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
>    void
>    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
>    _RandomAccessIterator __last, _Size __depth_limit,
>    _Compare __comp)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>      while (__last - __first > 3)
> {
>   if (__depth_limit == 0)
>     {
>       std::__heap_select(__first, __nth + 1, __last, __comp);
>
>       std::iter_swap(__first, __nth);
>       return;
>     }
>   --__depth_limit;
>   _RandomAccessIterator __cut =
>     std::__unguarded_partition_pivot(__first, __last, __comp);
>   if (__cut <= __nth)
>     __first = __cut;
>   else
>     __last = __cut;
> }
>      std::__insertion_sort(__first, __last, __comp);
>    }
># 2446 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Tp, typename _Compare>
>    _ForwardIterator
>    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
>  const _Tp& __val, _Compare __comp)
>    {
>      typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>      typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>     
>     
>
>     
>                    ;
>
>      _DistanceType __len = std::distance(__first, __last);
>
>      while (__len > 0)
> {
>   _DistanceType __half = __len >> 1;
>   _ForwardIterator __middle = __first;
>   std::advance(__middle, __half);
>   if (__comp(*__middle, __val))
>     {
>       __first = __middle;
>       ++__first;
>       __len = __len - __half - 1;
>     }
>   else
>     __len = __half;
> }
>      return __first;
>    }
># 2493 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Tp>
>    _ForwardIterator
>    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
>  const _Tp& __val)
>    {
>      typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>      typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>     
>     
>      ;
>
>      _DistanceType __len = std::distance(__first, __last);
>
>      while (__len > 0)
> {
>   _DistanceType __half = __len >> 1;
>   _ForwardIterator __middle = __first;
>   std::advance(__middle, __half);
>   if (__val < *__middle)
>     __len = __half;
>   else
>     {
>       __first = __middle;
>       ++__first;
>       __len = __len - __half - 1;
>     }
> }
>      return __first;
>    }
># 2542 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Tp, typename _Compare>
>    _ForwardIterator
>    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
>  const _Tp& __val, _Compare __comp)
>    {
>      typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>      typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>     
>     
>
>     
>                    ;
>
>      _DistanceType __len = std::distance(__first, __last);
>
>      while (__len > 0)
> {
>   _DistanceType __half = __len >> 1;
>   _ForwardIterator __middle = __first;
>   std::advance(__middle, __half);
>   if (__comp(__val, *__middle))
>     __len = __half;
>   else
>     {
>       __first = __middle;
>       ++__first;
>       __len = __len - __half - 1;
>     }
> }
>      return __first;
>    }
># 2595 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Tp>
>    pair<_ForwardIterator, _ForwardIterator>
>    equal_range(_ForwardIterator __first, _ForwardIterator __last,
>  const _Tp& __val)
>    {
>      typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>      typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>     
>     
>     
>      ;
>      ;
>
>      _DistanceType __len = std::distance(__first, __last);
>
>      while (__len > 0)
> {
>   _DistanceType __half = __len >> 1;
>   _ForwardIterator __middle = __first;
>   std::advance(__middle, __half);
>   if (*__middle < __val)
>     {
>       __first = __middle;
>       ++__first;
>       __len = __len - __half - 1;
>     }
>   else if (__val < *__middle)
>     __len = __half;
>   else
>     {
>       _ForwardIterator __left = std::lower_bound(__first, __middle,
>        __val);
>       std::advance(__first, __len);
>       _ForwardIterator __right = std::upper_bound(++__middle, __first,
>         __val);
>       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
>     }
> }
>      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
>    }
># 2657 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Tp, typename _Compare>
>    pair<_ForwardIterator, _ForwardIterator>
>    equal_range(_ForwardIterator __first, _ForwardIterator __last,
>  const _Tp& __val, _Compare __comp)
>    {
>      typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>      typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>     
>     
>
>     
>
>     
>                    ;
>     
>                    ;
>
>      _DistanceType __len = std::distance(__first, __last);
>
>      while (__len > 0)
> {
>   _DistanceType __half = __len >> 1;
>   _ForwardIterator __middle = __first;
>   std::advance(__middle, __half);
>   if (__comp(*__middle, __val))
>     {
>       __first = __middle;
>       ++__first;
>       __len = __len - __half - 1;
>     }
>   else if (__comp(__val, *__middle))
>     __len = __half;
>   else
>     {
>       _ForwardIterator __left = std::lower_bound(__first, __middle,
>        __val, __comp);
>       std::advance(__first, __len);
>       _ForwardIterator __right = std::upper_bound(++__middle, __first,
>         __val, __comp);
>       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
>     }
> }
>      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
>    }
># 2718 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Tp>
>    bool
>    binary_search(_ForwardIterator __first, _ForwardIterator __last,
>                  const _Tp& __val)
>    {
>      typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
>
>     
>     
>      ;
>      ;
>
>      _ForwardIterator __i = std::lower_bound(__first, __last, __val);
>      return __i != __last && !(__val < *__i);
>    }
># 2751 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Tp, typename _Compare>
>    bool
>    binary_search(_ForwardIterator __first, _ForwardIterator __last,
>                  const _Tp& __val, _Compare __comp)
>    {
>      typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
>
>     
>     
>
>     
>                    ;
>     
>                    ;
>
>      _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
>      return __i != __last && !bool(__comp(__val, *__i));
>    }
>
>
>
>
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator>
>    void
>    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
>     _InputIterator2 __first2, _InputIterator2 __last2,
>     _OutputIterator __result)
>    {
>      while (__first1 != __last1 && __first2 != __last2)
> {
>   if (*__first2 < *__first1)
>     {
>       *__result = (*__first2);
>       ++__first2;
>     }
>   else
>     {
>       *__result = (*__first1);
>       ++__first1;
>     }
>   ++__result;
> }
>      if (__first1 != __last1)
> std::copy(__first1, __last1, __result);
>    }
>
>
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator, typename _Compare>
>    void
>    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
>     _InputIterator2 __first2, _InputIterator2 __last2,
>     _OutputIterator __result, _Compare __comp)
>    {
>      while (__first1 != __last1 && __first2 != __last2)
> {
>   if (__comp(*__first2, *__first1))
>     {
>       *__result = (*__first2);
>       ++__first2;
>     }
>   else
>     {
>       *__result = (*__first1);
>       ++__first1;
>     }
>   ++__result;
> }
>      if (__first1 != __last1)
> std::copy(__first1, __last1, __result);
>    }
>
>
>  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
>    typename _BidirectionalIterator3>
>    void
>    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
>       _BidirectionalIterator1 __last1,
>       _BidirectionalIterator2 __first2,
>       _BidirectionalIterator2 __last2,
>       _BidirectionalIterator3 __result)
>    {
>      if (__first1 == __last1)
> {
>   std::copy_backward(__first2, __last2, __result);
>   return;
> }
>      else if (__first2 == __last2)
> return;
>
>      --__last1;
>      --__last2;
>      while (true)
> {
>   if (*__last2 < *__last1)
>     {
>       *--__result = (*__last1);
>       if (__first1 == __last1)
>  {
>    std::copy_backward(__first2, ++__last2, __result);
>    return;
>  }
>       --__last1;
>     }
>   else
>     {
>       *--__result = (*__last2);
>       if (__first2 == __last2)
>  return;
>       --__last2;
>     }
> }
>    }
>
>
>  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
>    typename _BidirectionalIterator3, typename _Compare>
>    void
>    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
>       _BidirectionalIterator1 __last1,
>       _BidirectionalIterator2 __first2,
>       _BidirectionalIterator2 __last2,
>       _BidirectionalIterator3 __result,
>       _Compare __comp)
>    {
>      if (__first1 == __last1)
> {
>   std::copy_backward(__first2, __last2, __result);
>   return;
> }
>      else if (__first2 == __last2)
> return;
>
>      --__last1;
>      --__last2;
>      while (true)
> {
>   if (__comp(*__last2, *__last1))
>     {
>       *--__result = (*__last1);
>       if (__first1 == __last1)
>  {
>    std::copy_backward(__first2, ++__last2, __result);
>    return;
>  }
>       --__last1;
>     }
>   else
>     {
>       *--__result = (*__last2);
>       if (__first2 == __last2)
>  return;
>       --__last2;
>     }
> }
>    }
>
>
>  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
>    typename _Distance>
>    _BidirectionalIterator1
>    __rotate_adaptive(_BidirectionalIterator1 __first,
>        _BidirectionalIterator1 __middle,
>        _BidirectionalIterator1 __last,
>        _Distance __len1, _Distance __len2,
>        _BidirectionalIterator2 __buffer,
>        _Distance __buffer_size)
>    {
>      _BidirectionalIterator2 __buffer_end;
>      if (__len1 > __len2 && __len2 <= __buffer_size)
> {
>   if (__len2)
>     {
>       __buffer_end = std::copy(__middle, __last, __buffer);
>       std::copy_backward(__first, __middle, __last);
>       return std::copy(__buffer, __buffer_end, __first);
>     }
>   else
>     return __first;
> }
>      else if (__len1 <= __buffer_size)
> {
>   if (__len1)
>     {
>       __buffer_end = std::copy(__first, __middle, __buffer);
>       std::copy(__middle, __last, __first);
>       return std::copy_backward(__buffer, __buffer_end, __last);
>     }
>   else
>     return __last;
> }
>      else
> {
>   std::rotate(__first, __middle, __last);
>   std::advance(__first, std::distance(__middle, __last));
>   return __first;
> }
>    }
>
>
>  template<typename _BidirectionalIterator, typename _Distance,
>    typename _Pointer>
>    void
>    __merge_adaptive(_BidirectionalIterator __first,
>                     _BidirectionalIterator __middle,
>       _BidirectionalIterator __last,
>       _Distance __len1, _Distance __len2,
>       _Pointer __buffer, _Distance __buffer_size)
>    {
>      if (__len1 <= __len2 && __len1 <= __buffer_size)
> {
>   _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
>   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
>         __first);
> }
>      else if (__len2 <= __buffer_size)
> {
>   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
>   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
>           __buffer_end, __last);
> }
>      else
> {
>   _BidirectionalIterator __first_cut = __first;
>   _BidirectionalIterator __second_cut = __middle;
>   _Distance __len11 = 0;
>   _Distance __len22 = 0;
>   if (__len1 > __len2)
>     {
>       __len11 = __len1 / 2;
>       std::advance(__first_cut, __len11);
>       __second_cut = std::lower_bound(__middle, __last,
>           *__first_cut);
>       __len22 = std::distance(__middle, __second_cut);
>     }
>   else
>     {
>       __len22 = __len2 / 2;
>       std::advance(__second_cut, __len22);
>       __first_cut = std::upper_bound(__first, __middle,
>          *__second_cut);
>       __len11 = std::distance(__first, __first_cut);
>     }
>   _BidirectionalIterator __new_middle =
>     std::__rotate_adaptive(__first_cut, __middle, __second_cut,
>       __len1 - __len11, __len22, __buffer,
>       __buffer_size);
>   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
>    __len22, __buffer, __buffer_size);
>   std::__merge_adaptive(__new_middle, __second_cut, __last,
>    __len1 - __len11,
>    __len2 - __len22, __buffer, __buffer_size);
> }
>    }
>
>
>  template<typename _BidirectionalIterator, typename _Distance,
>    typename _Pointer, typename _Compare>
>    void
>    __merge_adaptive(_BidirectionalIterator __first,
>                     _BidirectionalIterator __middle,
>       _BidirectionalIterator __last,
>       _Distance __len1, _Distance __len2,
>       _Pointer __buffer, _Distance __buffer_size,
>       _Compare __comp)
>    {
>      if (__len1 <= __len2 && __len1 <= __buffer_size)
> {
>   _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
>   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
>         __first, __comp);
> }
>      else if (__len2 <= __buffer_size)
> {
>   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
>   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
>           __buffer_end, __last, __comp);
> }
>      else
> {
>   _BidirectionalIterator __first_cut = __first;
>   _BidirectionalIterator __second_cut = __middle;
>   _Distance __len11 = 0;
>   _Distance __len22 = 0;
>   if (__len1 > __len2)
>     {
>       __len11 = __len1 / 2;
>       std::advance(__first_cut, __len11);
>       __second_cut = std::lower_bound(__middle, __last, *__first_cut,
>           __comp);
>       __len22 = std::distance(__middle, __second_cut);
>     }
>   else
>     {
>       __len22 = __len2 / 2;
>       std::advance(__second_cut, __len22);
>       __first_cut = std::upper_bound(__first, __middle, *__second_cut,
>          __comp);
>       __len11 = std::distance(__first, __first_cut);
>     }
>   _BidirectionalIterator __new_middle =
>     std::__rotate_adaptive(__first_cut, __middle, __second_cut,
>       __len1 - __len11, __len22, __buffer,
>       __buffer_size);
>   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
>    __len22, __buffer, __buffer_size, __comp);
>   std::__merge_adaptive(__new_middle, __second_cut, __last,
>    __len1 - __len11,
>    __len2 - __len22, __buffer,
>    __buffer_size, __comp);
> }
>    }
>
>
>  template<typename _BidirectionalIterator, typename _Distance>
>    void
>    __merge_without_buffer(_BidirectionalIterator __first,
>      _BidirectionalIterator __middle,
>      _BidirectionalIterator __last,
>      _Distance __len1, _Distance __len2)
>    {
>      if (__len1 == 0 || __len2 == 0)
> return;
>      if (__len1 + __len2 == 2)
> {
>   if (*__middle < *__first)
>     std::iter_swap(__first, __middle);
>   return;
> }
>      _BidirectionalIterator __first_cut = __first;
>      _BidirectionalIterator __second_cut = __middle;
>      _Distance __len11 = 0;
>      _Distance __len22 = 0;
>      if (__len1 > __len2)
> {
>   __len11 = __len1 / 2;
>   std::advance(__first_cut, __len11);
>   __second_cut = std::lower_bound(__middle, __last, *__first_cut);
>   __len22 = std::distance(__middle, __second_cut);
> }
>      else
> {
>   __len22 = __len2 / 2;
>   std::advance(__second_cut, __len22);
>   __first_cut = std::upper_bound(__first, __middle, *__second_cut);
>   __len11 = std::distance(__first, __first_cut);
> }
>      std::rotate(__first_cut, __middle, __second_cut);
>      _BidirectionalIterator __new_middle = __first_cut;
>      std::advance(__new_middle, std::distance(__middle, __second_cut));
>      std::__merge_without_buffer(__first, __first_cut, __new_middle,
>      __len11, __len22);
>      std::__merge_without_buffer(__new_middle, __second_cut, __last,
>      __len1 - __len11, __len2 - __len22);
>    }
>
>
>  template<typename _BidirectionalIterator, typename _Distance,
>    typename _Compare>
>    void
>    __merge_without_buffer(_BidirectionalIterator __first,
>                           _BidirectionalIterator __middle,
>      _BidirectionalIterator __last,
>      _Distance __len1, _Distance __len2,
>      _Compare __comp)
>    {
>      if (__len1 == 0 || __len2 == 0)
> return;
>      if (__len1 + __len2 == 2)
> {
>   if (__comp(*__middle, *__first))
>     std::iter_swap(__first, __middle);
>   return;
> }
>      _BidirectionalIterator __first_cut = __first;
>      _BidirectionalIterator __second_cut = __middle;
>      _Distance __len11 = 0;
>      _Distance __len22 = 0;
>      if (__len1 > __len2)
> {
>   __len11 = __len1 / 2;
>   std::advance(__first_cut, __len11);
>   __second_cut = std::lower_bound(__middle, __last, *__first_cut,
>       __comp);
>   __len22 = std::distance(__middle, __second_cut);
> }
>      else
> {
>   __len22 = __len2 / 2;
>   std::advance(__second_cut, __len22);
>   __first_cut = std::upper_bound(__first, __middle, *__second_cut,
>      __comp);
>   __len11 = std::distance(__first, __first_cut);
> }
>      std::rotate(__first_cut, __middle, __second_cut);
>      _BidirectionalIterator __new_middle = __first_cut;
>      std::advance(__new_middle, std::distance(__middle, __second_cut));
>      std::__merge_without_buffer(__first, __first_cut, __new_middle,
>      __len11, __len22, __comp);
>      std::__merge_without_buffer(__new_middle, __second_cut, __last,
>      __len1 - __len11, __len2 - __len22, __comp);
>    }
># 3175 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _BidirectionalIterator>
>    void
>    inplace_merge(_BidirectionalIterator __first,
>    _BidirectionalIterator __middle,
>    _BidirectionalIterator __last)
>    {
>      typedef typename iterator_traits<_BidirectionalIterator>::value_type
>          _ValueType;
>      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
>          _DistanceType;
>
>
>     
>
>     
>      ;
>      ;
>
>      if (__first == __middle || __middle == __last)
> return;
>
>      _DistanceType __len1 = std::distance(__first, __middle);
>      _DistanceType __len2 = std::distance(__middle, __last);
>
>      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
>          __last);
>      if (__buf.begin() == 0)
> std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
>      else
> std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
>         __buf.begin(), _DistanceType(__buf.size()));
>    }
># 3230 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _BidirectionalIterator, typename _Compare>
>    void
>    inplace_merge(_BidirectionalIterator __first,
>    _BidirectionalIterator __middle,
>    _BidirectionalIterator __last,
>    _Compare __comp)
>    {
>      typedef typename iterator_traits<_BidirectionalIterator>::value_type
>          _ValueType;
>      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
>          _DistanceType;
>
>
>     
>
>     
>
>      ;
>      ;
>
>      if (__first == __middle || __middle == __last)
> return;
>
>      const _DistanceType __len1 = std::distance(__first, __middle);
>      const _DistanceType __len2 = std::distance(__middle, __last);
>
>      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
>          __last);
>      if (__buf.begin() == 0)
> std::__merge_without_buffer(__first, __middle, __last, __len1,
>        __len2, __comp);
>      else
> std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
>         __buf.begin(), _DistanceType(__buf.size()),
>         __comp);
>    }
>
>
>
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator>
>    _OutputIterator
>    __move_merge(_InputIterator1 __first1, _InputIterator1 __last1,
>   _InputIterator2 __first2, _InputIterator2 __last2,
>   _OutputIterator __result)
>    {
>      while (__first1 != __last1 && __first2 != __last2)
> {
>   if (*__first2 < *__first1)
>     {
>       *__result = (*__first2);
>       ++__first2;
>     }
>   else
>     {
>       *__result = (*__first1);
>       ++__first1;
>     }
>   ++__result;
> }
>      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result))
>
>                  ;
>    }
>
>
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator, typename _Compare>
>    _OutputIterator
>    __move_merge(_InputIterator1 __first1, _InputIterator1 __last1,
>   _InputIterator2 __first2, _InputIterator2 __last2,
>   _OutputIterator __result, _Compare __comp)
>    {
>      while (__first1 != __last1 && __first2 != __last2)
> {
>   if (__comp(*__first2, *__first1))
>     {
>       *__result = (*__first2);
>       ++__first2;
>     }
>   else
>     {
>       *__result = (*__first1);
>       ++__first1;
>     }
>   ++__result;
> }
>      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result))
>
>                  ;
>    }
>
>  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
>    typename _Distance>
>    void
>    __merge_sort_loop(_RandomAccessIterator1 __first,
>        _RandomAccessIterator1 __last,
>        _RandomAccessIterator2 __result,
>        _Distance __step_size)
>    {
>      const _Distance __two_step = 2 * __step_size;
>
>      while (__last - __first >= __two_step)
> {
>   __result = std::__move_merge(__first, __first + __step_size,
>           __first + __step_size,
>           __first + __two_step, __result);
>   __first += __two_step;
> }
>
>      __step_size = std::min(_Distance(__last - __first), __step_size);
>      std::__move_merge(__first, __first + __step_size,
>   __first + __step_size, __last, __result);
>    }
>
>  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
>    typename _Distance, typename _Compare>
>    void
>    __merge_sort_loop(_RandomAccessIterator1 __first,
>        _RandomAccessIterator1 __last,
>        _RandomAccessIterator2 __result, _Distance __step_size,
>        _Compare __comp)
>    {
>      const _Distance __two_step = 2 * __step_size;
>
>      while (__last - __first >= __two_step)
> {
>   __result = std::__move_merge(__first, __first + __step_size,
>           __first + __step_size,
>           __first + __two_step,
>           __result, __comp);
>   __first += __two_step;
> }
>      __step_size = std::min(_Distance(__last - __first), __step_size);
>
>      std::__move_merge(__first,__first + __step_size,
>   __first + __step_size, __last, __result, __comp);
>    }
>
>  template<typename _RandomAccessIterator, typename _Distance>
>    void
>    __chunk_insertion_sort(_RandomAccessIterator __first,
>      _RandomAccessIterator __last,
>      _Distance __chunk_size)
>    {
>      while (__last - __first >= __chunk_size)
> {
>   std::__insertion_sort(__first, __first + __chunk_size);
>   __first += __chunk_size;
> }
>      std::__insertion_sort(__first, __last);
>    }
>
>  template<typename _RandomAccessIterator, typename _Distance,
>    typename _Compare>
>    void
>    __chunk_insertion_sort(_RandomAccessIterator __first,
>      _RandomAccessIterator __last,
>      _Distance __chunk_size, _Compare __comp)
>    {
>      while (__last - __first >= __chunk_size)
> {
>   std::__insertion_sort(__first, __first + __chunk_size, __comp);
>   __first += __chunk_size;
> }
>      std::__insertion_sort(__first, __last, __comp);
>    }
>
>  enum { _S_chunk_size = 7 };
>
>  template<typename _RandomAccessIterator, typename _Pointer>
>    void
>    __merge_sort_with_buffer(_RandomAccessIterator __first,
>        _RandomAccessIterator __last,
>                             _Pointer __buffer)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
>
>      const _Distance __len = __last - __first;
>      const _Pointer __buffer_last = __buffer + __len;
>
>      _Distance __step_size = _S_chunk_size;
>      std::__chunk_insertion_sort(__first, __last, __step_size);
>
>      while (__step_size < __len)
> {
>   std::__merge_sort_loop(__first, __last, __buffer, __step_size);
>   __step_size *= 2;
>   std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
>   __step_size *= 2;
> }
>    }
>
>  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
>    void
>    __merge_sort_with_buffer(_RandomAccessIterator __first,
>        _RandomAccessIterator __last,
>                             _Pointer __buffer, _Compare __comp)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
>
>      const _Distance __len = __last - __first;
>      const _Pointer __buffer_last = __buffer + __len;
>
>      _Distance __step_size = _S_chunk_size;
>      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
>
>      while (__step_size < __len)
> {
>   std::__merge_sort_loop(__first, __last, __buffer,
>     __step_size, __comp);
>   __step_size *= 2;
>   std::__merge_sort_loop(__buffer, __buffer_last, __first,
>     __step_size, __comp);
>   __step_size *= 2;
> }
>    }
>
>  template<typename _RandomAccessIterator, typename _Pointer,
>    typename _Distance>
>    void
>    __stable_sort_adaptive(_RandomAccessIterator __first,
>      _RandomAccessIterator __last,
>                           _Pointer __buffer, _Distance __buffer_size)
>    {
>      const _Distance __len = (__last - __first + 1) / 2;
>      const _RandomAccessIterator __middle = __first + __len;
>      if (__len > __buffer_size)
> {
>   std::__stable_sort_adaptive(__first, __middle,
>          __buffer, __buffer_size);
>   std::__stable_sort_adaptive(__middle, __last,
>          __buffer, __buffer_size);
> }
>      else
> {
>   std::__merge_sort_with_buffer(__first, __middle, __buffer);
>   std::__merge_sort_with_buffer(__middle, __last, __buffer);
> }
>      std::__merge_adaptive(__first, __middle, __last,
>       _Distance(__middle - __first),
>       _Distance(__last - __middle),
>       __buffer, __buffer_size);
>    }
>
>  template<typename _RandomAccessIterator, typename _Pointer,
>    typename _Distance, typename _Compare>
>    void
>    __stable_sort_adaptive(_RandomAccessIterator __first,
>      _RandomAccessIterator __last,
>                           _Pointer __buffer, _Distance __buffer_size,
>                           _Compare __comp)
>    {
>      const _Distance __len = (__last - __first + 1) / 2;
>      const _RandomAccessIterator __middle = __first + __len;
>      if (__len > __buffer_size)
> {
>   std::__stable_sort_adaptive(__first, __middle, __buffer,
>          __buffer_size, __comp);
>   std::__stable_sort_adaptive(__middle, __last, __buffer,
>          __buffer_size, __comp);
> }
>      else
> {
>   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
>   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
> }
>      std::__merge_adaptive(__first, __middle, __last,
>       _Distance(__middle - __first),
>       _Distance(__last - __middle),
>       __buffer, __buffer_size,
>       __comp);
>    }
>
>
>  template<typename _RandomAccessIterator>
>    void
>    __inplace_stable_sort(_RandomAccessIterator __first,
>     _RandomAccessIterator __last)
>    {
>      if (__last - __first < 15)
> {
>   std::__insertion_sort(__first, __last);
>   return;
> }
>      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
>      std::__inplace_stable_sort(__first, __middle);
>      std::__inplace_stable_sort(__middle, __last);
>      std::__merge_without_buffer(__first, __middle, __last,
>      __middle - __first,
>      __last - __middle);
>    }
>
>
>  template<typename _RandomAccessIterator, typename _Compare>
>    void
>    __inplace_stable_sort(_RandomAccessIterator __first,
>     _RandomAccessIterator __last, _Compare __comp)
>    {
>      if (__last - __first < 15)
> {
>   std::__insertion_sort(__first, __last, __comp);
>   return;
> }
>      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
>      std::__inplace_stable_sort(__first, __middle, __comp);
>      std::__inplace_stable_sort(__middle, __last, __comp);
>      std::__merge_without_buffer(__first, __middle, __last,
>      __middle - __first,
>      __last - __middle,
>      __comp);
>    }
># 3570 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2>
>    bool
>    includes(_InputIterator1 __first1, _InputIterator1 __last1,
>      _InputIterator2 __first2, _InputIterator2 __last2)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>     
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> if (*__first2 < *__first1)
>   return false;
> else if(*__first1 < *__first2)
>   ++__first1;
> else
>   ++__first1, ++__first2;
>
>      return __first2 == __last2;
>    }
># 3620 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _Compare>
>    bool
>    includes(_InputIterator1 __first1, _InputIterator1 __last1,
>      _InputIterator2 __first2, _InputIterator2 __last2,
>      _Compare __comp)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first2, *__first1))
>   return false;
> else if(__comp(*__first1, *__first2))
>   ++__first1;
> else
>   ++__first1, ++__first2;
>
>      return __first2 == __last2;
>    }
># 3675 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _BidirectionalIterator>
>    bool
>    next_permutation(_BidirectionalIterator __first,
>       _BidirectionalIterator __last)
>    {
>
>     
>
>     
>
>      ;
>
>      if (__first == __last)
> return false;
>      _BidirectionalIterator __i = __first;
>      ++__i;
>      if (__i == __last)
> return false;
>      __i = __last;
>      --__i;
>
>      for(;;)
> {
>   _BidirectionalIterator __ii = __i;
>   --__i;
>   if (*__i < *__ii)
>     {
>       _BidirectionalIterator __j = __last;
>       while (!(*__i < *--__j))
>  {}
>       std::iter_swap(__i, __j);
>       std::reverse(__ii, __last);
>       return true;
>     }
>   if (__i == __first)
>     {
>       std::reverse(__first, __last);
>       return false;
>     }
> }
>    }
># 3732 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _BidirectionalIterator, typename _Compare>
>    bool
>    next_permutation(_BidirectionalIterator __first,
>       _BidirectionalIterator __last, _Compare __comp)
>    {
>
>     
>
>     
>
>
>      ;
>
>      if (__first == __last)
> return false;
>      _BidirectionalIterator __i = __first;
>      ++__i;
>      if (__i == __last)
> return false;
>      __i = __last;
>      --__i;
>
>      for(;;)
> {
>   _BidirectionalIterator __ii = __i;
>   --__i;
>   if (__comp(*__i, *__ii))
>     {
>       _BidirectionalIterator __j = __last;
>       while (!bool(__comp(*__i, *--__j)))
>  {}
>       std::iter_swap(__i, __j);
>       std::reverse(__ii, __last);
>       return true;
>     }
>   if (__i == __first)
>     {
>       std::reverse(__first, __last);
>       return false;
>     }
> }
>    }
># 3788 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _BidirectionalIterator>
>    bool
>    prev_permutation(_BidirectionalIterator __first,
>       _BidirectionalIterator __last)
>    {
>
>     
>
>     
>
>      ;
>
>      if (__first == __last)
> return false;
>      _BidirectionalIterator __i = __first;
>      ++__i;
>      if (__i == __last)
> return false;
>      __i = __last;
>      --__i;
>
>      for(;;)
> {
>   _BidirectionalIterator __ii = __i;
>   --__i;
>   if (*__ii < *__i)
>     {
>       _BidirectionalIterator __j = __last;
>       while (!(*--__j < *__i))
>  {}
>       std::iter_swap(__i, __j);
>       std::reverse(__ii, __last);
>       return true;
>     }
>   if (__i == __first)
>     {
>       std::reverse(__first, __last);
>       return false;
>     }
> }
>    }
># 3845 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _BidirectionalIterator, typename _Compare>
>    bool
>    prev_permutation(_BidirectionalIterator __first,
>       _BidirectionalIterator __last, _Compare __comp)
>    {
>
>     
>
>     
>
>
>      ;
>
>      if (__first == __last)
> return false;
>      _BidirectionalIterator __i = __first;
>      ++__i;
>      if (__i == __last)
> return false;
>      __i = __last;
>      --__i;
>
>      for(;;)
> {
>   _BidirectionalIterator __ii = __i;
>   --__i;
>   if (__comp(*__ii, *__i))
>     {
>       _BidirectionalIterator __j = __last;
>       while (!bool(__comp(*--__j, *__i)))
>  {}
>       std::iter_swap(__i, __j);
>       std::reverse(__ii, __last);
>       return true;
>     }
>   if (__i == __first)
>     {
>       std::reverse(__first, __last);
>       return false;
>     }
> }
>    }
># 3905 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
>    _OutputIterator
>    replace_copy(_InputIterator __first, _InputIterator __last,
>   _OutputIterator __result,
>   const _Tp& __old_value, const _Tp& __new_value)
>    {
>
>     
>     
>
>     
>
>      ;
>
>      for (; __first != __last; ++__first, ++__result)
> if (*__first == __old_value)
>   *__result = __new_value;
> else
>   *__result = *__first;
>      return __result;
>    }
># 3942 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _OutputIterator,
>    typename _Predicate, typename _Tp>
>    _OutputIterator
>    replace_copy_if(_InputIterator __first, _InputIterator __last,
>      _OutputIterator __result,
>      _Predicate __pred, const _Tp& __new_value)
>    {
>
>     
>     
>
>     
>
>      ;
>
>      for (; __first != __last; ++__first, ++__result)
> if (__pred(*__first))
>   *__result = __new_value;
> else
>   *__result = *__first;
>      return __result;
>    }
># 4416 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>
>
>
># 4432 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _Function>
>    _Function
>    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
>    {
>
>     
>      ;
>      for (; __first != __last; ++__first)
> __f(*__first);
>      return (__f);
>    }
># 4453 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _Tp>
>    inline _InputIterator
>    find(_InputIterator __first, _InputIterator __last,
>  const _Tp& __val)
>    {
>
>     
>     
>
>      ;
>      return std::__find(__first, __last, __val,
>           std::__iterator_category(__first));
>    }
># 4477 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _Predicate>
>    inline _InputIterator
>    find_if(_InputIterator __first, _InputIterator __last,
>     _Predicate __pred)
>    {
>
>     
>     
>
>      ;
>      return std::__find_if(__first, __last, __pred,
>       std::__iterator_category(__first));
>    }
># 4507 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _ForwardIterator>
>    _InputIterator
>    find_first_of(_InputIterator __first1, _InputIterator __last1,
>    _ForwardIterator __first2, _ForwardIterator __last2)
>    {
>
>     
>     
>     
>
>
>      ;
>      ;
>
>      for (; __first1 != __last1; ++__first1)
> for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
>   if (*__first1 == *__iter)
>     return __first1;
>      return __last1;
>    }
># 4547 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _ForwardIterator,
>    typename _BinaryPredicate>
>    _InputIterator
>    find_first_of(_InputIterator __first1, _InputIterator __last1,
>    _ForwardIterator __first2, _ForwardIterator __last2,
>    _BinaryPredicate __comp)
>    {
>
>     
>     
>     
>
>
>      ;
>      ;
>
>      for (; __first1 != __last1; ++__first1)
> for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
>   if (__comp(*__first1, *__iter))
>     return __first1;
>      return __last1;
>    }
># 4579 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator>
>    _ForwardIterator
>    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
>    {
>
>     
>     
>
>      ;
>      if (__first == __last)
> return __last;
>      _ForwardIterator __next = __first;
>      while(++__next != __last)
> {
>   if (*__first == *__next)
>     return __first;
>   __first = __next;
> }
>      return __last;
>    }
># 4611 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _BinaryPredicate>
>    _ForwardIterator
>    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
>    _BinaryPredicate __binary_pred)
>    {
>
>     
>     
>
>
>      ;
>      if (__first == __last)
> return __last;
>      _ForwardIterator __next = __first;
>      while(++__next != __last)
> {
>   if (__binary_pred(*__first, *__next))
>     return __first;
>   __first = __next;
> }
>      return __last;
>    }
># 4643 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _Tp>
>    typename iterator_traits<_InputIterator>::difference_type
>    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
>    {
>
>     
>     
>
>      ;
>      typename iterator_traits<_InputIterator>::difference_type __n = 0;
>      for (; __first != __last; ++__first)
> if (*__first == __value)
>   ++__n;
>      return __n;
>    }
># 4668 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _Predicate>
>    typename iterator_traits<_InputIterator>::difference_type
>    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
>    {
>
>     
>     
>
>      ;
>      typename iterator_traits<_InputIterator>::difference_type __n = 0;
>      for (; __first != __last; ++__first)
> if (__pred(*__first))
>   ++__n;
>      return __n;
>    }
># 4710 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator1, typename _ForwardIterator2>
>    _ForwardIterator1
>    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
>    {
>
>     
>     
>     
>
>
>      ;
>      ;
>
>
>      if (__first1 == __last1 || __first2 == __last2)
> return __first1;
>
>
>      _ForwardIterator2 __p1(__first2);
>      if (++__p1 == __last2)
> return std::find(__first1, __last1, *__first2);
>
>
>      _ForwardIterator2 __p;
>      _ForwardIterator1 __current = __first1;
>
>      for (;;)
> {
>   __first1 = std::find(__first1, __last1, *__first2);
>   if (__first1 == __last1)
>     return __last1;
>
>   __p = __p1;
>   __current = __first1;
>   if (++__current == __last1)
>     return __last1;
>
>   while (*__current == *__p)
>     {
>       if (++__p == __last2)
>  return __first1;
>       if (++__current == __last1)
>  return __last1;
>     }
>   ++__first1;
> }
>      return __first1;
>    }
># 4781 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator1, typename _ForwardIterator2,
>    typename _BinaryPredicate>
>    _ForwardIterator1
>    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
>    _BinaryPredicate __predicate)
>    {
>
>     
>     
>     
>
>
>      ;
>      ;
>
>
>      if (__first1 == __last1 || __first2 == __last2)
> return __first1;
>
>
>      _ForwardIterator2 __p1(__first2);
>      if (++__p1 == __last2)
> {
>   while (__first1 != __last1
>   && !bool(__predicate(*__first1, *__first2)))
>     ++__first1;
>   return __first1;
> }
>
>
>      _ForwardIterator2 __p;
>      _ForwardIterator1 __current = __first1;
>
>      for (;;)
> {
>   while (__first1 != __last1
>   && !bool(__predicate(*__first1, *__first2)))
>     ++__first1;
>   if (__first1 == __last1)
>     return __last1;
>
>   __p = __p1;
>   __current = __first1;
>   if (++__current == __last1)
>     return __last1;
>
>   while (__predicate(*__current, *__p))
>     {
>       if (++__p == __last2)
>  return __first1;
>       if (++__current == __last1)
>  return __last1;
>     }
>   ++__first1;
> }
>      return __first1;
>    }
># 4856 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Integer, typename _Tp>
>    _ForwardIterator
>    search_n(_ForwardIterator __first, _ForwardIterator __last,
>      _Integer __count, const _Tp& __val)
>    {
>
>     
>     
>
>      ;
>
>      if (__count <= 0)
> return __first;
>      if (__count == 1)
> return std::find(__first, __last, __val);
>      return std::__search_n(__first, __last, __count, __val,
>        std::__iterator_category(__first));
>    }
># 4893 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Integer, typename _Tp,
>           typename _BinaryPredicate>
>    _ForwardIterator
>    search_n(_ForwardIterator __first, _ForwardIterator __last,
>      _Integer __count, const _Tp& __val,
>      _BinaryPredicate __binary_pred)
>    {
>
>     
>     
>
>      ;
>
>      if (__count <= 0)
> return __first;
>      if (__count == 1)
> {
>   while (__first != __last && !bool(__binary_pred(*__first, __val)))
>     ++__first;
>   return __first;
> }
>      return std::__search_n(__first, __last, __count, __val, __binary_pred,
>        std::__iterator_category(__first));
>    }
># 4935 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _OutputIterator,
>    typename _UnaryOperation>
>    _OutputIterator
>    transform(_InputIterator __first, _InputIterator __last,
>       _OutputIterator __result, _UnaryOperation __unary_op)
>    {
>
>     
>     
>
>
>      ;
>
>      for (; __first != __last; ++__first, ++__result)
> *__result = __unary_op(*__first);
>      return __result;
>    }
># 4972 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator, typename _BinaryOperation>
>    _OutputIterator
>    transform(_InputIterator1 __first1, _InputIterator1 __last1,
>       _InputIterator2 __first2, _OutputIterator __result,
>       _BinaryOperation __binary_op)
>    {
>
>     
>     
>     
>
>
>      ;
>
>      for (; __first1 != __last1; ++__first1, ++__first2, ++__result)
> *__result = __binary_op(*__first1, *__first2);
>      return __result;
>    }
># 5005 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Tp>
>    void
>    replace(_ForwardIterator __first, _ForwardIterator __last,
>     const _Tp& __old_value, const _Tp& __new_value)
>    {
>
>     
>
>     
>
>     
>
>      ;
>
>      for (; __first != __last; ++__first)
> if (*__first == __old_value)
>   *__first = __new_value;
>    }
># 5037 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
>    void
>    replace_if(_ForwardIterator __first, _ForwardIterator __last,
>        _Predicate __pred, const _Tp& __new_value)
>    {
>
>     
>
>     
>
>     
>
>      ;
>
>      for (; __first != __last; ++__first)
> if (__pred(*__first))
>   *__first = __new_value;
>    }
># 5069 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Generator>
>    void
>    generate(_ForwardIterator __first, _ForwardIterator __last,
>      _Generator __gen)
>    {
>
>     
>     
>
>      ;
>
>      for (; __first != __last; ++__first)
> *__first = __gen();
>    }
># 5100 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _OutputIterator, typename _Size, typename _Generator>
>    _OutputIterator
>    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
>    {
>
>     
>
>
>
>      for (__decltype(__n + 0) __niter = __n;
>    __niter > 0; --__niter, ++__first)
> *__first = __gen();
>      return __first;
>    }
># 5137 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _OutputIterator>
>    inline _OutputIterator
>    unique_copy(_InputIterator __first, _InputIterator __last,
>  _OutputIterator __result)
>    {
>
>     
>     
>
>     
>
>      ;
>
>      if (__first == __last)
> return __result;
>      return std::__unique_copy(__first, __last, __result,
>    std::__iterator_category(__first),
>    std::__iterator_category(__result));
>    }
># 5176 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator, typename _OutputIterator,
>    typename _BinaryPredicate>
>    inline _OutputIterator
>    unique_copy(_InputIterator __first, _InputIterator __last,
>  _OutputIterator __result,
>  _BinaryPredicate __binary_pred)
>    {
>
>     
>     
>
>      ;
>
>      if (__first == __last)
> return __result;
>      return std::__unique_copy(__first, __last, __result, __binary_pred,
>    std::__iterator_category(__first),
>    std::__iterator_category(__result));
>    }
># 5208 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _RandomAccessIterator>
>    inline void
>    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
>    {
>
>     
>
>      ;
>
>      if (__first != __last)
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
>   std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
>    }
># 5236 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
>    void
>    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
>
>
>
>     _RandomNumberGenerator& __rand)
>
>    {
>
>     
>
>      ;
>
>      if (__first == __last)
> return;
>      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + __rand((__i - __first) + 1));
>    }
># 5272 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Predicate>
>    inline _ForwardIterator
>    partition(_ForwardIterator __first, _ForwardIterator __last,
>       _Predicate __pred)
>    {
>
>     
>
>     
>
>      ;
>
>      return std::__partition(__first, __last, __pred,
>         std::__iterator_category(__first));
>    }
># 5306 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _RandomAccessIterator>
>    inline void
>    partial_sort(_RandomAccessIterator __first,
>   _RandomAccessIterator __middle,
>   _RandomAccessIterator __last)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
>     
>
>     
>      ;
>      ;
>
>      std::__heap_select(__first, __middle, __last);
>      std::sort_heap(__first, __middle);
>    }
># 5345 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _RandomAccessIterator, typename _Compare>
>    inline void
>    partial_sort(_RandomAccessIterator __first,
>   _RandomAccessIterator __middle,
>   _RandomAccessIterator __last,
>   _Compare __comp)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
>     
>
>     
>
>      ;
>      ;
>
>      std::__heap_select(__first, __middle, __last, __comp);
>      std::sort_heap(__first, __middle, __comp);
>    }
># 5382 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _RandomAccessIterator>
>    inline void
>    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
>  _RandomAccessIterator __last)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
>     
>
>     
>      ;
>      ;
>
>      if (__first == __last || __nth == __last)
> return;
>
>      std::__introselect(__first, __nth, __last,
>    std::__lg(__last - __first) * 2);
>    }
># 5421 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _RandomAccessIterator, typename _Compare>
>    inline void
>    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
>  _RandomAccessIterator __last, _Compare __comp)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
>     
>
>     
>
>      ;
>      ;
>
>      if (__first == __last || __nth == __last)
> return;
>
>      std::__introselect(__first, __nth, __last,
>    std::__lg(__last - __first) * 2, __comp);
>    }
># 5459 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _RandomAccessIterator>
>    inline void
>    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
>     
>
>     
>      ;
>
>      if (__first != __last)
> {
>   std::__introsort_loop(__first, __last,
>    std::__lg(__last - __first) * 2);
>   std::__final_insertion_sort(__first, __last);
> }
>    }
># 5495 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _RandomAccessIterator, typename _Compare>
>    inline void
>    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
>  _Compare __comp)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
>     
>
>     
>
>      ;
>
>      if (__first != __last)
> {
>   std::__introsort_loop(__first, __last,
>    std::__lg(__last - __first) * 2, __comp);
>   std::__final_insertion_sort(__first, __last, __comp);
> }
>    }
># 5537 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator>
>    _OutputIterator
>    merge(_InputIterator1 __first1, _InputIterator1 __last1,
>   _InputIterator2 __first2, _InputIterator2 __last2,
>   _OutputIterator __result)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>
>     
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> {
>   if (*__first2 < *__first1)
>     {
>       *__result = *__first2;
>       ++__first2;
>     }
>   else
>     {
>       *__result = *__first1;
>       ++__first1;
>     }
>   ++__result;
> }
>      return std::copy(__first2, __last2, std::copy(__first1, __last1,
>          __result));
>    }
># 5601 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator, typename _Compare>
>    _OutputIterator
>    merge(_InputIterator1 __first1, _InputIterator1 __last1,
>   _InputIterator2 __first2, _InputIterator2 __last2,
>   _OutputIterator __result, _Compare __comp)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>
>     
>
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> {
>   if (__comp(*__first2, *__first1))
>     {
>       *__result = *__first2;
>       ++__first2;
>     }
>   else
>     {
>       *__result = *__first1;
>       ++__first1;
>     }
>   ++__result;
> }
>      return std::copy(__first2, __last2, std::copy(__first1, __last1,
>          __result));
>    }
># 5661 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _RandomAccessIterator>
>    inline void
>    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
>     
>
>     
>      ;
>
>      _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
>         __last);
>      if (__buf.begin() == 0)
> std::__inplace_stable_sort(__first, __last);
>      else
> std::__stable_sort_adaptive(__first, __last, __buf.begin(),
>        _DistanceType(__buf.size()));
>    }
># 5703 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _RandomAccessIterator, typename _Compare>
>    inline void
>    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
>  _Compare __comp)
>    {
>      typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
>     
>
>     
>
>
>      ;
>
>      _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
>         __last);
>      if (__buf.begin() == 0)
> std::__inplace_stable_sort(__first, __last, __comp);
>      else
> std::__stable_sort_adaptive(__first, __last, __buf.begin(),
>        _DistanceType(__buf.size()), __comp);
>    }
># 5749 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator>
>    _OutputIterator
>    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
>       _InputIterator2 __first2, _InputIterator2 __last2,
>       _OutputIterator __result)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>
>     
>     
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> {
>   if (*__first1 < *__first2)
>     {
>       *__result = *__first1;
>       ++__first1;
>     }
>   else if (*__first2 < *__first1)
>     {
>       *__result = *__first2;
>       ++__first2;
>     }
>   else
>     {
>       *__result = *__first1;
>       ++__first1;
>       ++__first2;
>     }
>   ++__result;
> }
>      return std::copy(__first2, __last2, std::copy(__first1, __last1,
>          __result));
>    }
># 5816 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator, typename _Compare>
>    _OutputIterator
>    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
>       _InputIterator2 __first2, _InputIterator2 __last2,
>       _OutputIterator __result, _Compare __comp)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>
>     
>
>     
>
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> {
>   if (__comp(*__first1, *__first2))
>     {
>       *__result = *__first1;
>       ++__first1;
>     }
>   else if (__comp(*__first2, *__first1))
>     {
>       *__result = *__first2;
>       ++__first2;
>     }
>   else
>     {
>       *__result = *__first1;
>       ++__first1;
>       ++__first2;
>     }
>   ++__result;
> }
>      return std::copy(__first2, __last2, std::copy(__first1, __last1,
>          __result));
>    }
># 5883 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator>
>    _OutputIterator
>    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
>       _InputIterator2 __first2, _InputIterator2 __last2,
>       _OutputIterator __result)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>     
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
>   ++__first1;
> else if (*__first2 < *__first1)
>   ++__first2;
> else
>   {
>     *__result = *__first1;
>     ++__first1;
>     ++__first2;
>     ++__result;
>   }
>      return __result;
>    }
># 5940 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator, typename _Compare>
>    _OutputIterator
>    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
>       _InputIterator2 __first2, _InputIterator2 __last2,
>       _OutputIterator __result, _Compare __comp)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>
>     
>
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
>   ++__first1;
> else if (__comp(*__first2, *__first1))
>   ++__first2;
> else
>   {
>     *__result = *__first1;
>     ++__first1;
>     ++__first2;
>     ++__result;
>   }
>      return __result;
>    }
># 5998 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator>
>    _OutputIterator
>    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
>     _InputIterator2 __first2, _InputIterator2 __last2,
>     _OutputIterator __result)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>     
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
>   {
>     *__result = *__first1;
>     ++__first1;
>     ++__result;
>   }
> else if (*__first2 < *__first1)
>   ++__first2;
> else
>   {
>     ++__first1;
>     ++__first2;
>   }
>      return std::copy(__first1, __last1, __result);
>    }
># 6059 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator, typename _Compare>
>    _OutputIterator
>    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
>     _InputIterator2 __first2, _InputIterator2 __last2,
>     _OutputIterator __result, _Compare __comp)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>
>     
>
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
>   {
>     *__result = *__first1;
>     ++__first1;
>     ++__result;
>   }
> else if (__comp(*__first2, *__first1))
>   ++__first2;
> else
>   {
>     ++__first1;
>     ++__first2;
>   }
>      return std::copy(__first1, __last1, __result);
>    }
># 6117 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator>
>    _OutputIterator
>    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
>        _InputIterator2 __first2, _InputIterator2 __last2,
>        _OutputIterator __result)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>
>     
>     
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
>   {
>     *__result = *__first1;
>     ++__first1;
>     ++__result;
>   }
> else if (*__first2 < *__first1)
>   {
>     *__result = *__first2;
>     ++__first2;
>     ++__result;
>   }
> else
>   {
>     ++__first1;
>     ++__first2;
>   }
>      return std::copy(__first2, __last2, std::copy(__first1,
>          __last1, __result));
>    }
># 6183 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _InputIterator1, typename _InputIterator2,
>    typename _OutputIterator, typename _Compare>
>    _OutputIterator
>    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
>        _InputIterator2 __first2, _InputIterator2 __last2,
>        _OutputIterator __result,
>        _Compare __comp)
>    {
>      typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
>      typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
>     
>     
>     
>
>     
>
>     
>
>     
>
>      ;
>      ;
>
>      while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
>   {
>     *__result = *__first1;
>     ++__first1;
>     ++__result;
>   }
> else if (__comp(*__first2, *__first1))
>   {
>     *__result = *__first2;
>     ++__first2;
>     ++__result;
>   }
> else
>   {
>     ++__first1;
>     ++__first2;
>   }
>      return std::copy(__first2, __last2,
>         std::copy(__first1, __last1, __result));
>    }
># 6240 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator>
>    _ForwardIterator
>    min_element(_ForwardIterator __first, _ForwardIterator __last)
>    {
>
>     
>     
>
>      ;
>
>      if (__first == __last)
> return __first;
>      _ForwardIterator __result = __first;
>      while (++__first != __last)
> if (*__first < *__result)
>   __result = __first;
>      return __result;
>    }
># 6268 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Compare>
>    _ForwardIterator
>    min_element(_ForwardIterator __first, _ForwardIterator __last,
>  _Compare __comp)
>    {
>
>     
>     
>
>
>      ;
>
>      if (__first == __last)
> return __first;
>      _ForwardIterator __result = __first;
>      while (++__first != __last)
> if (__comp(*__first, *__result))
>   __result = __first;
>      return __result;
>    }
># 6296 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator>
>    _ForwardIterator
>    max_element(_ForwardIterator __first, _ForwardIterator __last)
>    {
>
>     
>     
>
>      ;
>
>      if (__first == __last)
> return __first;
>      _ForwardIterator __result = __first;
>      while (++__first != __last)
> if (*__result < *__first)
>   __result = __first;
>      return __result;
>    }
># 6324 "/usr/include/c++/4.8.0/bits/stl_algo.h" 3
>  template<typename _ForwardIterator, typename _Compare>
>    _ForwardIterator
>    max_element(_ForwardIterator __first, _ForwardIterator __last,
>  _Compare __comp)
>    {
>
>     
>     
>
>
>      ;
>
>      if (__first == __last) return __first;
>      _ForwardIterator __result = __first;
>      while (++__first != __last)
> if (__comp(*__result, *__first))
>   __result = __first;
>      return __result;
>    }
>
>
>}
># 63 "/usr/include/c++/4.8.0/algorithm" 2 3
># 10 "../src/CoinFloatEqual.hpp" 2
># 1 "/usr/include/c++/4.8.0/cmath" 1 3
># 39 "/usr/include/c++/4.8.0/cmath" 3
>       
># 40 "/usr/include/c++/4.8.0/cmath" 3
>
>
>
>
># 1 "/usr/include/math.h" 1 3 4
># 29 "/usr/include/math.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/include/bits/huge_val.h" 1 3 4
># 34 "/usr/include/math.h" 2 3 4
>
># 1 "/usr/include/bits/huge_valf.h" 1 3 4
># 36 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/huge_vall.h" 1 3 4
># 37 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/inf.h" 1 3 4
># 40 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/nan.h" 1 3 4
># 43 "/usr/include/math.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/mathdef.h" 1 3 4
># 28 "/usr/include/bits/mathdef.h" 3 4
>typedef float float_t;
>typedef double double_t;
># 47 "/usr/include/math.h" 2 3 4
># 70 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
>
>extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
>
>extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
>
>extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
>
>
>extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
>
>extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
>
>extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
>
>
>
>
>extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
>
>extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
>
>extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
>
>
>
>
>extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
>                                                           ;
>
>
>
>
>
>extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
>
>extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
>
>extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
>
>
>
>
>
>
>
>extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
>
>
>extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
>
>
>extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
>
>
>extern double log (double __x) throw (); extern double __log (double __x) throw ();
>
>
>extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
>
>
>extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ()
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
>
>extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
>
>
>
>
>
>extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
>
>
>extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
>
>
>extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
>
>
>
>
>
>
>extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
>
>
>extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
>
>
>
>
>
>
>
>
>extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
>
>
>extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
>
>
>
>
>
>extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
>
>
>
>
>
>
>extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
>
>
>
>
>
>
>
>
>extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
>
>
>extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
>
>
>
>
>extern int __isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finite (double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int finite (double __value) throw () __attribute__ ((__const__));
>
>
>extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
>
>
>
>extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
>
>
>
>
>
>extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnan (double __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnan (double __value) throw () __attribute__ ((__const__));
>
>
>extern double j0 (double) throw (); extern double __j0 (double) throw ();
>extern double j1 (double) throw (); extern double __j1 (double) throw ();
>extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
>extern double y0 (double) throw (); extern double __y0 (double) throw ();
>extern double y1 (double) throw (); extern double __y1 (double) throw ();
>extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
>
>
>
>
>
>
>extern double erf (double) throw (); extern double __erf (double) throw ();
>extern double erfc (double) throw (); extern double __erfc (double) throw ();
>extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
>
>
>
>
>
>
>extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
>
>
>
>
>
>extern double gamma (double) throw (); extern double __gamma (double) throw ();
>
>
>
>
>
>
>extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
>
>
>extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
>
>extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
>
>
>
>extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
>
>
>
>extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
>
>
>
>
>extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
>
>
>
>extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
>
>
>
>extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
>
>
>
>extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
>extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
>
>
>
>extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
>extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
>
>
>
>extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
>
>
>extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>
>extern int __fpclassify (double __value) throw ()
>     __attribute__ ((__const__));
>
>
>extern int __signbit (double __value) throw ()
>     __attribute__ ((__const__));
>
>
>
>extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
>
>
>
>
>
>
>
>
>extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
># 71 "/usr/include/math.h" 2 3 4
># 89 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
>
>extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
>
>extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
>
>extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
>
>
>extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
>
>extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
>
>extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
>
>
>
>
>extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
>
>extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
>
>extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
>
>
>
>
>extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ()
>                                                           ;
>
>
>
>
>
>extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
>
>extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
>
>extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
>
>
>
>
>
>
>
>extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
>
>
>extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
>
>
>extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
>
>
>extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
>
>
>extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
>
>
>extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ()
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
>
>extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
>
>
>
>
>
>extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
>
>
>extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
>
>
>extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
>
>
>
>
>
>
>extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
>
>
>extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
>
>
>
>
>
>
>
>
>extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
>
>
>extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
>
>
>
>
>
>extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
>
>
>
>
>
>
>extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
>
>
>
>
>
>
>
>
>extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
>
>
>
>
>extern int __isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitef (float __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int finitef (float __value) throw () __attribute__ ((__const__));
>
>
>extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
>
>
>
>extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
>
>
>
>
>
>extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>extern float j0f (float) throw (); extern float __j0f (float) throw ();
>extern float j1f (float) throw (); extern float __j1f (float) throw ();
>extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
>extern float y0f (float) throw (); extern float __y0f (float) throw ();
>extern float y1f (float) throw (); extern float __y1f (float) throw ();
>extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
>
>
>
>
>
>
>extern float erff (float) throw (); extern float __erff (float) throw ();
>extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
>extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
>
>
>
>
>
>
>extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
>
>
>
>
>
>extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
>
>
>
>
>
>
>extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
>
>
>extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
>
>extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
>
>
>
>extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
>
>
>
>extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
>
>
>
>
>extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
>
>
>
>extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
>
>
>
>extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
>
>
>
>extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
>extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
>
>
>
>extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
>extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
>
>
>
>extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
>
>
>extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>
>extern int __fpclassifyf (float __value) throw ()
>     __attribute__ ((__const__));
>
>
>extern int __signbitf (float __value) throw ()
>     __attribute__ ((__const__));
>
>
>
>extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
>
>
>
>
>
>
>
>
>extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
># 90 "/usr/include/math.h" 2 3 4
># 133 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
>
>extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
>
>extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
>
>extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
>
>
>extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
>
>extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
>
>extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
>
>
>
>
>extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
>
>extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
>
>extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
>
>
>
>
>extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ()
>                                                           ;
>
>
>
>
>
>extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
>
>extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
>
>extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
>
>
>
>
>
>
>
>extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
>
>
>extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
>
>
>extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
>
>
>extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
>
>
>extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
>
>
>extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ()
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
>
>extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
>
>
>
>
>
>extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
>
>
>extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
>
>
>extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
>
>
>
>
>
>
>extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
>
>
>extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
>
>
>
>
>
>
>
>
>extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
>
>
>extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
>
>
>
>
>
>extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
>
>
>
>
>
>
>extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
>
>
>
>
>
>
>
>
>extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
>
>
>
>
>extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
>
>
>
>extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
>
>
>
>
>
>extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
>extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
>extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
>extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
>extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
>extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
>
>
>
>
>
>
>extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
>extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
>extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
>
>
>
>
>
>
>extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
>
>
>
>
>
>extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
>
>
>
>
>
>
>extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
>
>
>extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
>
>
>
>extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
>
>
>
>extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
>
>
>
>
>extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
>
>
>
>extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
>
>
>
>extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
>extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
>
>
>
>extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
>extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
>
>
>
>extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
>
>
>extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern int __fpclassifyl (long double __value) throw ()
>     __attribute__ ((__const__));
>
>
>extern int __signbitl (long double __value) throw ()
>     __attribute__ ((__const__));
>
>
>
>extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
>
>
>
>
>
>
>
>
>extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
># 134 "/usr/include/math.h" 2 3 4
># 149 "/usr/include/math.h" 3 4
>extern int signgam;
># 190 "/usr/include/math.h" 3 4
>enum
>  {
>    FP_NAN =
>
>      0,
>    FP_INFINITE =
>
>      1,
>    FP_ZERO =
>
>      2,
>    FP_SUBNORMAL =
>
>      3,
>    FP_NORMAL =
>
>      4
>  };
># 288 "/usr/include/math.h" 3 4
>typedef enum
>{
>  _IEEE_ = -1,
>  _SVID_,
>  _XOPEN_,
>  _POSIX_,
>  _ISOC_
>} _LIB_VERSION_TYPE;
>
>
>
>
>extern _LIB_VERSION_TYPE _LIB_VERSION;
># 311 "/usr/include/math.h" 3 4
>struct __exception
>
>
>
>  {
>    int type;
>    char *name;
>    double arg1;
>    double arg2;
>    double retval;
>  };
>
>
>extern int matherr (struct __exception *__exc) throw ();
># 413 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathinline.h" 1 3 4
># 123 "/usr/include/bits/mathinline.h" 3 4
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) __signbitf (float __x) throw ()
>{
>
>  int __m;
>  __asm ("pmovmskb %1, %0" : "=r" (__m) : "x" (__x));
>  return (__m & 0x8) != 0;
>
>
>
>
>}
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) __signbit (double __x) throw ()
>{
>
>  int __m;
>  __asm ("pmovmskb %1, %0" : "=r" (__m) : "x" (__x));
>  return (__m & 0x80) != 0;
>
>
>
>
>}
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) __signbitl (long double __x) throw ()
>{
>  __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
>  return (__u.__i[2] & 0x8000) != 0;
>}
>
>
># 414 "/usr/include/math.h" 2 3 4
># 475 "/usr/include/math.h" 3 4
>}
># 45 "/usr/include/c++/4.8.0/cmath" 2 3
># 75 "/usr/include/c++/4.8.0/cmath" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>  inline double
>  abs(double __x)
>  { return __builtin_fabs(__x); }
>
>
>
>  inline float
>  abs(float __x)
>  { return __builtin_fabsf(__x); }
>
>  inline long double
>  abs(long double __x)
>  { return __builtin_fabsl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    abs(_Tp __x)
>    { return __builtin_fabs(__x); }
>
>  using ::acos;
>
>
>  inline float
>  acos(float __x)
>  { return __builtin_acosf(__x); }
>
>  inline long double
>  acos(long double __x)
>  { return __builtin_acosl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    acos(_Tp __x)
>    { return __builtin_acos(__x); }
>
>  using ::asin;
>
>
>  inline float
>  asin(float __x)
>  { return __builtin_asinf(__x); }
>
>  inline long double
>  asin(long double __x)
>  { return __builtin_asinl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    asin(_Tp __x)
>    { return __builtin_asin(__x); }
>
>  using ::atan;
>
>
>  inline float
>  atan(float __x)
>  { return __builtin_atanf(__x); }
>
>  inline long double
>  atan(long double __x)
>  { return __builtin_atanl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    atan(_Tp __x)
>    { return __builtin_atan(__x); }
>
>  using ::atan2;
>
>
>  inline float
>  atan2(float __y, float __x)
>  { return __builtin_atan2f(__y, __x); }
>
>  inline long double
>  atan2(long double __y, long double __x)
>  { return __builtin_atan2l(__y, __x); }
>
>
>  template<typename _Tp, typename _Up>
>    inline
>    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
>    atan2(_Tp __y, _Up __x)
>    {
>      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
>      return atan2(__type(__y), __type(__x));
>    }
>
>  using ::ceil;
>
>
>  inline float
>  ceil(float __x)
>  { return __builtin_ceilf(__x); }
>
>  inline long double
>  ceil(long double __x)
>  { return __builtin_ceill(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    ceil(_Tp __x)
>    { return __builtin_ceil(__x); }
>
>  using ::cos;
>
>
>  inline float
>  cos(float __x)
>  { return __builtin_cosf(__x); }
>
>  inline long double
>  cos(long double __x)
>  { return __builtin_cosl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    cos(_Tp __x)
>    { return __builtin_cos(__x); }
>
>  using ::cosh;
>
>
>  inline float
>  cosh(float __x)
>  { return __builtin_coshf(__x); }
>
>  inline long double
>  cosh(long double __x)
>  { return __builtin_coshl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    cosh(_Tp __x)
>    { return __builtin_cosh(__x); }
>
>  using ::exp;
>
>
>  inline float
>  exp(float __x)
>  { return __builtin_expf(__x); }
>
>  inline long double
>  exp(long double __x)
>  { return __builtin_expl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    exp(_Tp __x)
>    { return __builtin_exp(__x); }
>
>  using ::fabs;
>
>
>  inline float
>  fabs(float __x)
>  { return __builtin_fabsf(__x); }
>
>  inline long double
>  fabs(long double __x)
>  { return __builtin_fabsl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    fabs(_Tp __x)
>    { return __builtin_fabs(__x); }
>
>  using ::floor;
>
>
>  inline float
>  floor(float __x)
>  { return __builtin_floorf(__x); }
>
>  inline long double
>  floor(long double __x)
>  { return __builtin_floorl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    floor(_Tp __x)
>    { return __builtin_floor(__x); }
>
>  using ::fmod;
>
>
>  inline float
>  fmod(float __x, float __y)
>  { return __builtin_fmodf(__x, __y); }
>
>  inline long double
>  fmod(long double __x, long double __y)
>  { return __builtin_fmodl(__x, __y); }
>
>
>  template<typename _Tp, typename _Up>
>    inline
>    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
>    fmod(_Tp __x, _Up __y)
>    {
>      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
>      return fmod(__type(__x), __type(__y));
>    }
>
>  using ::frexp;
>
>
>  inline float
>  frexp(float __x, int* __exp)
>  { return __builtin_frexpf(__x, __exp); }
>
>  inline long double
>  frexp(long double __x, int* __exp)
>  { return __builtin_frexpl(__x, __exp); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    frexp(_Tp __x, int* __exp)
>    { return __builtin_frexp(__x, __exp); }
>
>  using ::ldexp;
>
>
>  inline float
>  ldexp(float __x, int __exp)
>  { return __builtin_ldexpf(__x, __exp); }
>
>  inline long double
>  ldexp(long double __x, int __exp)
>  { return __builtin_ldexpl(__x, __exp); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    ldexp(_Tp __x, int __exp)
>    { return __builtin_ldexp(__x, __exp); }
>
>  using ::log;
>
>
>  inline float
>  log(float __x)
>  { return __builtin_logf(__x); }
>
>  inline long double
>  log(long double __x)
>  { return __builtin_logl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    log(_Tp __x)
>    { return __builtin_log(__x); }
>
>  using ::log10;
>
>
>  inline float
>  log10(float __x)
>  { return __builtin_log10f(__x); }
>
>  inline long double
>  log10(long double __x)
>  { return __builtin_log10l(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    log10(_Tp __x)
>    { return __builtin_log10(__x); }
>
>  using ::modf;
>
>
>  inline float
>  modf(float __x, float* __iptr)
>  { return __builtin_modff(__x, __iptr); }
>
>  inline long double
>  modf(long double __x, long double* __iptr)
>  { return __builtin_modfl(__x, __iptr); }
>
>
>  using ::pow;
>
>
>  inline float
>  pow(float __x, float __y)
>  { return __builtin_powf(__x, __y); }
>
>  inline long double
>  pow(long double __x, long double __y)
>  { return __builtin_powl(__x, __y); }
>
>
>
>
>  inline double
>  pow(double __x, int __i)
>  { return __builtin_powi(__x, __i); }
>
>  inline float
>  pow(float __x, int __n)
>  { return __builtin_powif(__x, __n); }
>
>  inline long double
>  pow(long double __x, int __n)
>  { return __builtin_powil(__x, __n); }
>
>
>
>  template<typename _Tp, typename _Up>
>    inline
>    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
>    pow(_Tp __x, _Up __y)
>    {
>      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
>      return pow(__type(__x), __type(__y));
>    }
>
>  using ::sin;
>
>
>  inline float
>  sin(float __x)
>  { return __builtin_sinf(__x); }
>
>  inline long double
>  sin(long double __x)
>  { return __builtin_sinl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    sin(_Tp __x)
>    { return __builtin_sin(__x); }
>
>  using ::sinh;
>
>
>  inline float
>  sinh(float __x)
>  { return __builtin_sinhf(__x); }
>
>  inline long double
>  sinh(long double __x)
>  { return __builtin_sinhl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    sinh(_Tp __x)
>    { return __builtin_sinh(__x); }
>
>  using ::sqrt;
>
>
>  inline float
>  sqrt(float __x)
>  { return __builtin_sqrtf(__x); }
>
>  inline long double
>  sqrt(long double __x)
>  { return __builtin_sqrtl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    sqrt(_Tp __x)
>    { return __builtin_sqrt(__x); }
>
>  using ::tan;
>
>
>  inline float
>  tan(float __x)
>  { return __builtin_tanf(__x); }
>
>  inline long double
>  tan(long double __x)
>  { return __builtin_tanl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    tan(_Tp __x)
>    { return __builtin_tan(__x); }
>
>  using ::tanh;
>
>
>  inline float
>  tanh(float __x)
>  { return __builtin_tanhf(__x); }
>
>  inline long double
>  tanh(long double __x)
>  { return __builtin_tanhl(__x); }
>
>
>  template<typename _Tp>
>    inline
>    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
>                                    double>::__type
>    tanh(_Tp __x)
>    { return __builtin_tanh(__x); }
>
>
>}
># 555 "/usr/include/c++/4.8.0/cmath" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 805 "/usr/include/c++/4.8.0/cmath" 3
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    fpclassify(_Tp __f)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_fpclassify(0, 1, 4,
>      3, 2, __type(__f));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    isfinite(_Tp __f)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_isfinite(__type(__f));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    isinf(_Tp __f)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_isinf(__type(__f));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    isnan(_Tp __f)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_isnan(__type(__f));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    isnormal(_Tp __f)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_isnormal(__type(__f));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    signbit(_Tp __f)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_signbit(__type(__f));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    isgreater(_Tp __f1, _Tp __f2)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_isgreater(__type(__f1), __type(__f2));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    isgreaterequal(_Tp __f1, _Tp __f2)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    isless(_Tp __f1, _Tp __f2)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_isless(__type(__f1), __type(__f2));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    islessequal(_Tp __f1, _Tp __f2)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_islessequal(__type(__f1), __type(__f2));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    islessgreater(_Tp __f1, _Tp __f2)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_islessgreater(__type(__f1), __type(__f2));
>    }
>
>  template<typename _Tp>
>    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
>        int>::__type
>    isunordered(_Tp __f1, _Tp __f2)
>    {
>      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>      return __builtin_isunordered(__type(__f1), __type(__f2));
>    }
>
>
>
>
>}
># 11 "../src/CoinFloatEqual.hpp" 2
>
># 1 "../src/CoinFinite.hpp" 1
># 11 "../src/CoinFinite.hpp"
># 1 "/usr/include/c++/4.8.0/limits" 1 3
># 40 "/usr/include/c++/4.8.0/limits" 3
>       
># 41 "/usr/include/c++/4.8.0/limits" 3
># 147 "/usr/include/c++/4.8.0/limits" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>  enum float_round_style
>  {
>    round_indeterminate = -1,
>    round_toward_zero = 0,
>    round_to_nearest = 1,
>    round_toward_infinity = 2,
>    round_toward_neg_infinity = 3
>  };
>
>
>
>
>
>
>
>  enum float_denorm_style
>  {
>
>    denorm_indeterminate = -1,
>
>    denorm_absent = 0,
>
>    denorm_present = 1
>  };
># 191 "/usr/include/c++/4.8.0/limits" 3
>  struct __numeric_limits_base
>  {
>
>
>    static const bool is_specialized = false;
>
>
>
>
>    static const int digits = 0;
>
>
>    static const int digits10 = 0;
># 212 "/usr/include/c++/4.8.0/limits" 3
>    static const bool is_signed = false;
>
>
>
>    static const bool is_integer = false;
>
>
>
>
>
>    static const bool is_exact = false;
>
>
>
>    static const int radix = 0;
>
>
>
>    static const int min_exponent = 0;
>
>
>
>    static const int min_exponent10 = 0;
>
>
>
>
>    static const int max_exponent = 0;
>
>
>
>    static const int max_exponent10 = 0;
>
>
>    static const bool has_infinity = false;
>
>
>
>    static const bool has_quiet_NaN = false;
>
>
>
>    static const bool has_signaling_NaN = false;
>
>
>    static const float_denorm_style has_denorm = denorm_absent;
>
>
>
>    static const bool has_denorm_loss = false;
>
>
>
>    static const bool is_iec559 = false;
>
>
>
>
>    static const bool is_bounded = false;
># 279 "/usr/include/c++/4.8.0/limits" 3
>    static const bool is_modulo = false;
>
>
>    static const bool traps = false;
>
>
>    static const bool tinyness_before = false;
>
>
>
>
>    static const float_round_style round_style =
>          round_toward_zero;
>  };
># 305 "/usr/include/c++/4.8.0/limits" 3
>  template<typename _Tp>
>    struct numeric_limits : public __numeric_limits_base
>    {
>
>
>      static _Tp
>      min() throw() { return _Tp(); }
>
>
>      static _Tp
>      max() throw() { return _Tp(); }
># 326 "/usr/include/c++/4.8.0/limits" 3
>      static _Tp
>      epsilon() throw() { return _Tp(); }
>
>
>      static _Tp
>      round_error() throw() { return _Tp(); }
>
>
>      static _Tp
>      infinity() throw() { return _Tp(); }
>
>
>
>      static _Tp
>      quiet_NaN() throw() { return _Tp(); }
>
>
>
>      static _Tp
>      signaling_NaN() throw() { return _Tp(); }
>
>
>
>
>      static _Tp
>      denorm_min() throw() { return _Tp(); }
>    };
># 372 "/usr/include/c++/4.8.0/limits" 3
>  template<>
>    struct numeric_limits<bool>
>    {
>      static const bool is_specialized = true;
>
>      static bool
>      min() throw() { return false; }
>
>      static bool
>      max() throw() { return true; }
>
>
>
>
>
>      static const int digits = 1;
>      static const int digits10 = 0;
>
>
>
>      static const bool is_signed = false;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static bool
>      epsilon() throw() { return false; }
>
>      static bool
>      round_error() throw() { return false; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static bool
>      infinity() throw() { return false; }
>
>      static bool
>      quiet_NaN() throw() { return false; }
>
>      static bool
>      signaling_NaN() throw() { return false; }
>
>      static bool
>      denorm_min() throw() { return false; }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = false;
>
>
>
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<char>
>    {
>      static const bool is_specialized = true;
>
>      static char
>      min() throw() { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
>
>      static char
>      max() throw() { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
>
>
>
>
>
>
>      static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
>      static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = ((char)(-1) < 0);
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static char
>      epsilon() throw() { return 0; }
>
>      static char
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static
>      char infinity() throw() { return char(); }
>
>      static char
>      quiet_NaN() throw() { return char(); }
>
>      static char
>      signaling_NaN() throw() { return char(); }
>
>      static char
>      denorm_min() throw() { return static_cast<char>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = !is_signed;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<signed char>
>    {
>      static const bool is_specialized = true;
>
>      static signed char
>      min() throw() { return -127 - 1; }
>
>      static signed char
>      max() throw() { return 127; }
>
>
>
>
>
>
>      static const int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
>      static const int digits10
>       = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = true;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static signed char
>      epsilon() throw() { return 0; }
>
>      static signed char
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static signed char
>      infinity() throw() { return static_cast<signed char>(0); }
>
>      static signed char
>      quiet_NaN() throw() { return static_cast<signed char>(0); }
>
>      static signed char
>      signaling_NaN() throw()
>      { return static_cast<signed char>(0); }
>
>      static signed char
>      denorm_min() throw()
>      { return static_cast<signed char>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = false;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<unsigned char>
>    {
>      static const bool is_specialized = true;
>
>      static unsigned char
>      min() throw() { return 0; }
>
>      static unsigned char
>      max() throw() { return 127 * 2U + 1; }
>
>
>
>
>
>
>      static const int digits
>       = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
>      static const int digits10
>       = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = false;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static unsigned char
>      epsilon() throw() { return 0; }
>
>      static unsigned char
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static unsigned char
>      infinity() throw()
>      { return static_cast<unsigned char>(0); }
>
>      static unsigned char
>      quiet_NaN() throw()
>      { return static_cast<unsigned char>(0); }
>
>      static unsigned char
>      signaling_NaN() throw()
>      { return static_cast<unsigned char>(0); }
>
>      static unsigned char
>      denorm_min() throw()
>      { return static_cast<unsigned char>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = true;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<wchar_t>
>    {
>      static const bool is_specialized = true;
>
>      static wchar_t
>      min() throw() { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
>
>      static wchar_t
>      max() throw() { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
>
>
>
>
>
>
>      static const int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
>      static const int digits10
>       = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = ((wchar_t)(-1) < 0);
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static wchar_t
>      epsilon() throw() { return 0; }
>
>      static wchar_t
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static wchar_t
>      infinity() throw() { return wchar_t(); }
>
>      static wchar_t
>      quiet_NaN() throw() { return wchar_t(); }
>
>      static wchar_t
>      signaling_NaN() throw() { return wchar_t(); }
>
>      static wchar_t
>      denorm_min() throw() { return wchar_t(); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = !is_signed;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
># 843 "/usr/include/c++/4.8.0/limits" 3
>  template<>
>    struct numeric_limits<short>
>    {
>      static const bool is_specialized = true;
>
>      static short
>      min() throw() { return -32767 - 1; }
>
>      static short
>      max() throw() { return 32767; }
>
>
>
>
>
>
>      static const int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
>      static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = true;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static short
>      epsilon() throw() { return 0; }
>
>      static short
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static short
>      infinity() throw() { return short(); }
>
>      static short
>      quiet_NaN() throw() { return short(); }
>
>      static short
>      signaling_NaN() throw() { return short(); }
>
>      static short
>      denorm_min() throw() { return short(); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = false;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<unsigned short>
>    {
>      static const bool is_specialized = true;
>
>      static unsigned short
>      min() throw() { return 0; }
>
>      static unsigned short
>      max() throw() { return 32767 * 2U + 1; }
>
>
>
>
>
>
>      static const int digits
>       = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
>      static const int digits10
>       = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = false;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static unsigned short
>      epsilon() throw() { return 0; }
>
>      static unsigned short
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static unsigned short
>      infinity() throw()
>      { return static_cast<unsigned short>(0); }
>
>      static unsigned short
>      quiet_NaN() throw()
>      { return static_cast<unsigned short>(0); }
>
>      static unsigned short
>      signaling_NaN() throw()
>      { return static_cast<unsigned short>(0); }
>
>      static unsigned short
>      denorm_min() throw()
>      { return static_cast<unsigned short>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = true;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<int>
>    {
>      static const bool is_specialized = true;
>
>      static int
>      min() throw() { return -2147483647 - 1; }
>
>      static int
>      max() throw() { return 2147483647; }
>
>
>
>
>
>
>      static const int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
>      static const int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = true;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static int
>      epsilon() throw() { return 0; }
>
>      static int
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static int
>      infinity() throw() { return static_cast<int>(0); }
>
>      static int
>      quiet_NaN() throw() { return static_cast<int>(0); }
>
>      static int
>      signaling_NaN() throw() { return static_cast<int>(0); }
>
>      static int
>      denorm_min() throw() { return static_cast<int>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = false;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<unsigned int>
>    {
>      static const bool is_specialized = true;
>
>      static unsigned int
>      min() throw() { return 0; }
>
>      static unsigned int
>      max() throw() { return 2147483647 * 2U + 1; }
>
>
>
>
>
>
>      static const int digits
>       = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
>      static const int digits10
>       = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = false;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static unsigned int
>      epsilon() throw() { return 0; }
>
>      static unsigned int
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static unsigned int
>      infinity() throw() { return static_cast<unsigned int>(0); }
>
>      static unsigned int
>      quiet_NaN() throw()
>      { return static_cast<unsigned int>(0); }
>
>      static unsigned int
>      signaling_NaN() throw()
>      { return static_cast<unsigned int>(0); }
>
>      static unsigned int
>      denorm_min() throw()
>      { return static_cast<unsigned int>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = true;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<long>
>    {
>      static const bool is_specialized = true;
>
>      static long
>      min() throw() { return -9223372036854775807L - 1; }
>
>      static long
>      max() throw() { return 9223372036854775807L; }
>
>
>
>
>
>
>      static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
>      static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = true;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static long
>      epsilon() throw() { return 0; }
>
>      static long
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static long
>      infinity() throw() { return static_cast<long>(0); }
>
>      static long
>      quiet_NaN() throw() { return static_cast<long>(0); }
>
>      static long
>      signaling_NaN() throw() { return static_cast<long>(0); }
>
>      static long
>      denorm_min() throw() { return static_cast<long>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = false;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<unsigned long>
>    {
>      static const bool is_specialized = true;
>
>      static unsigned long
>      min() throw() { return 0; }
>
>      static unsigned long
>      max() throw() { return 9223372036854775807L * 2UL + 1; }
>
>
>
>
>
>
>      static const int digits
>       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
>      static const int digits10
>       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = false;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static unsigned long
>      epsilon() throw() { return 0; }
>
>      static unsigned long
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static unsigned long
>      infinity() throw()
>      { return static_cast<unsigned long>(0); }
>
>      static unsigned long
>      quiet_NaN() throw()
>      { return static_cast<unsigned long>(0); }
>
>      static unsigned long
>      signaling_NaN() throw()
>      { return static_cast<unsigned long>(0); }
>
>      static unsigned long
>      denorm_min() throw()
>      { return static_cast<unsigned long>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = true;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<long long>
>    {
>      static const bool is_specialized = true;
>
>      static long long
>      min() throw() { return -9223372036854775807LL - 1; }
>
>      static long long
>      max() throw() { return 9223372036854775807LL; }
>
>
>
>
>
>
>      static const int digits
>       = (sizeof(long long) * 8 - ((long long)(-1) < 0));
>      static const int digits10
>       = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = true;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static long long
>      epsilon() throw() { return 0; }
>
>      static long long
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static long long
>      infinity() throw() { return static_cast<long long>(0); }
>
>      static long long
>      quiet_NaN() throw() { return static_cast<long long>(0); }
>
>      static long long
>      signaling_NaN() throw()
>      { return static_cast<long long>(0); }
>
>      static long long
>      denorm_min() throw() { return static_cast<long long>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = false;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<unsigned long long>
>    {
>      static const bool is_specialized = true;
>
>      static unsigned long long
>      min() throw() { return 0; }
>
>      static unsigned long long
>      max() throw() { return 9223372036854775807LL * 2ULL + 1; }
>
>
>
>
>
>
>      static const int digits
>       = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
>      static const int digits10
>       = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = false;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static unsigned long long
>      epsilon() throw() { return 0; }
>
>      static unsigned long long
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static unsigned long long
>      infinity() throw()
>      { return static_cast<unsigned long long>(0); }
>
>      static unsigned long long
>      quiet_NaN() throw()
>      { return static_cast<unsigned long long>(0); }
>
>      static unsigned long long
>      signaling_NaN() throw()
>      { return static_cast<unsigned long long>(0); }
>
>      static unsigned long long
>      denorm_min() throw()
>      { return static_cast<unsigned long long>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = true;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>
>  template<>
>    struct numeric_limits<__int128>
>    {
>      static const bool is_specialized = true;
>
>      static __int128
>      min() throw() { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((sizeof(__int128) * 8 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); }
>
>      static __int128
>      max() throw() { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((sizeof(__int128) * 8 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); }
>
>
>
>
>
>
>      static const int digits
>       = (sizeof(__int128) * 8 - ((__int128)(-1) < 0));
>      static const int digits10
>       = ((sizeof(__int128) * 8 - ((__int128)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = true;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static __int128
>      epsilon() throw() { return 0; }
>
>      static __int128
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static __int128
>      infinity() throw()
>      { return static_cast<__int128>(0); }
>
>      static __int128
>      quiet_NaN() throw()
>      { return static_cast<__int128>(0); }
>
>      static __int128
>      signaling_NaN() throw()
>      { return static_cast<__int128>(0); }
>
>      static __int128
>      denorm_min() throw()
>      { return static_cast<__int128>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = false;
>
>      static const bool traps
>       = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>  template<>
>    struct numeric_limits<unsigned __int128>
>    {
>      static const bool is_specialized = true;
>
>      static unsigned __int128
>      min() throw() { return 0; }
>
>      static unsigned __int128
>      max() throw() { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((sizeof(unsigned __int128) * 8 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); }
>
>
>
>
>
>
>      static const int digits
>       = (sizeof(unsigned __int128) * 8 - ((unsigned __int128)(-1) < 0));
>      static const int digits10
>       = ((sizeof(unsigned __int128) * 8 - ((unsigned __int128)(-1) < 0)) * 643L / 2136);
>
>
>
>      static const bool is_signed = false;
>      static const bool is_integer = true;
>      static const bool is_exact = true;
>      static const int radix = 2;
>
>      static unsigned __int128
>      epsilon() throw() { return 0; }
>
>      static unsigned __int128
>      round_error() throw() { return 0; }
>
>      static const int min_exponent = 0;
>      static const int min_exponent10 = 0;
>      static const int max_exponent = 0;
>      static const int max_exponent10 = 0;
>
>      static const bool has_infinity = false;
>      static const bool has_quiet_NaN = false;
>      static const bool has_signaling_NaN = false;
>      static const float_denorm_style has_denorm
>       = denorm_absent;
>      static const bool has_denorm_loss = false;
>
>      static unsigned __int128
>      infinity() throw()
>      { return static_cast<unsigned __int128>(0); }
>
>      static unsigned __int128
>      quiet_NaN() throw()
>      { return static_cast<unsigned __int128>(0); }
>
>      static unsigned __int128
>      signaling_NaN() throw()
>      { return static_cast<unsigned __int128>(0); }
>
>      static unsigned __int128
>      denorm_min() throw()
>      { return static_cast<unsigned __int128>(0); }
>
>      static const bool is_iec559 = false;
>      static const bool is_bounded = true;
>      static const bool is_modulo = true;
>
>      static const bool traps = true;
>      static const bool tinyness_before = false;
>      static const float_round_style round_style
>       = round_toward_zero;
>    };
>
>
>
>  template<>
>    struct numeric_limits<float>
>    {
>      static const bool is_specialized = true;
>
>      static float
>      min() throw() { return 1.17549435082228750797e-38F; }
>
>      static float
>      max() throw() { return 3.40282346638528859812e+38F; }
>
>
>
>
>
>
>      static const int digits = 24;
>      static const int digits10 = 6;
>
>
>
>
>      static const bool is_signed = true;
>      static const bool is_integer = false;
>      static const bool is_exact = false;
>      static const int radix = 2;
>
>      static float
>      epsilon() throw() { return 1.19209289550781250000e-7F; }
>
>      static float
>      round_error() throw() { return 0.5F; }
>
>      static const int min_exponent = (-125);
>      static const int min_exponent10 = (-37);
>      static const int max_exponent = 128;
>      static const int max_exponent10 = 38;
>
>      static const bool has_infinity = 1;
>      static const bool has_quiet_NaN = 1;
>      static const bool has_signaling_NaN = has_quiet_NaN;
>      static const float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
>      static const bool has_denorm_loss
>       = false;
>
>      static float
>      infinity() throw() { return __builtin_huge_valf(); }
>
>      static float
>      quiet_NaN() throw() { return __builtin_nanf(""); }
>
>      static float
>      signaling_NaN() throw() { return __builtin_nansf(""); }
>
>      static float
>      denorm_min() throw() { return 1.40129846432481707092e-45F; }
>
>      static const bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
>      static const bool is_bounded = true;
>      static const bool is_modulo = false;
>
>      static const bool traps = false;
>      static const bool tinyness_before
>       = false;
>      static const float_round_style round_style
>       = round_to_nearest;
>    };
>
>
>
>
>
>
>  template<>
>    struct numeric_limits<double>
>    {
>      static const bool is_specialized = true;
>
>      static double
>      min() throw() { return double(2.22507385850720138309e-308L); }
>
>      static double
>      max() throw() { return double(1.79769313486231570815e+308L); }
>
>
>
>
>
>
>      static const int digits = 53;
>      static const int digits10 = 15;
>
>
>
>
>      static const bool is_signed = true;
>      static const bool is_integer = false;
>      static const bool is_exact = false;
>      static const int radix = 2;
>
>      static double
>      epsilon() throw() { return double(2.22044604925031308085e-16L); }
>
>      static double
>      round_error() throw() { return 0.5; }
>
>      static const int min_exponent = (-1021);
>      static const int min_exponent10 = (-307);
>      static const int max_exponent = 1024;
>      static const int max_exponent10 = 308;
>
>      static const bool has_infinity = 1;
>      static const bool has_quiet_NaN = 1;
>      static const bool has_signaling_NaN = has_quiet_NaN;
>      static const float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
>      static const bool has_denorm_loss
>        = false;
>
>      static double
>      infinity() throw() { return __builtin_huge_val(); }
>
>      static double
>      quiet_NaN() throw() { return __builtin_nan(""); }
>
>      static double
>      signaling_NaN() throw() { return __builtin_nans(""); }
>
>      static double
>      denorm_min() throw() { return double(4.94065645841246544177e-324L); }
>
>      static const bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
>      static const bool is_bounded = true;
>      static const bool is_modulo = false;
>
>      static const bool traps = false;
>      static const bool tinyness_before
>       = false;
>      static const float_round_style round_style
>       = round_to_nearest;
>    };
>
>
>
>
>
>
>  template<>
>    struct numeric_limits<long double>
>    {
>      static const bool is_specialized = true;
>
>      static long double
>      min() throw() { return 3.36210314311209350626e-4932L; }
>
>      static long double
>      max() throw() { return 1.18973149535723176502e+4932L; }
>
>
>
>
>
>
>      static const int digits = 64;
>      static const int digits10 = 18;
>
>
>
>
>      static const bool is_signed = true;
>      static const bool is_integer = false;
>      static const bool is_exact = false;
>      static const int radix = 2;
>
>      static long double
>      epsilon() throw() { return 1.08420217248550443401e-19L; }
>
>      static long double
>      round_error() throw() { return 0.5L; }
>
>      static const int min_exponent = (-16381);
>      static const int min_exponent10 = (-4931);
>      static const int max_exponent = 16384;
>      static const int max_exponent10 = 4932;
>
>      static const bool has_infinity = 1;
>      static const bool has_quiet_NaN = 1;
>      static const bool has_signaling_NaN = has_quiet_NaN;
>      static const float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
>      static const bool has_denorm_loss
> = false;
>
>      static long double
>      infinity() throw() { return __builtin_huge_vall(); }
>
>      static long double
>      quiet_NaN() throw() { return __builtin_nanl(""); }
>
>      static long double
>      signaling_NaN() throw() { return __builtin_nansl(""); }
>
>      static long double
>      denorm_min() throw() { return 3.64519953188247460253e-4951L; }
>
>      static const bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
>      static const bool is_bounded = true;
>      static const bool is_modulo = false;
>
>      static const bool traps = false;
>      static const bool tinyness_before =
>      false;
>      static const float_round_style round_style =
>            round_to_nearest;
>    };
>
>
>
>
>
>
>}
># 12 "../src/CoinFinite.hpp" 2
>
>
>
>
>
>const double COIN_DBL_MIN = std::numeric_limits<double>::min();
>const double COIN_DBL_MAX = std::numeric_limits<double>::max();
>const int COIN_INT_MAX = std::numeric_limits<int>::max();
>const double COIN_INT_MAX_AS_DOUBLE = std::numeric_limits<int>::max();
># 29 "../src/CoinFinite.hpp"
>extern bool CoinFinite(double val);
>
>
>extern bool CoinIsnan(double val);
># 13 "../src/CoinFloatEqual.hpp" 2
># 46 "../src/CoinFloatEqual.hpp"
>class CoinAbsFltEq
>{
>  public:
>
>
>
>  inline bool operator() (const double f1, const double f2) const
>
>  { if (CoinIsnan(f1) || CoinIsnan(f2)) return false ;
>    if (f1 == f2) return true ;
>    return (fabs(f1-f2) < epsilon_) ; }
># 66 "../src/CoinFloatEqual.hpp"
>  CoinAbsFltEq () : epsilon_(1.e-10) {}
>
>
>
>  CoinAbsFltEq (const double epsilon) : epsilon_(epsilon) {}
>
>
>
>  virtual ~CoinAbsFltEq () {}
>
>
>
>  CoinAbsFltEq (const CoinAbsFltEq& src) : epsilon_(src.epsilon_) {}
>
>
>
>  CoinAbsFltEq& operator= (const CoinAbsFltEq& rhs)
>
>  { if (this != &rhs) epsilon_ = rhs.epsilon_ ;
>    return (*this) ; }
>
>
>
>  private:
>
>
>
>
>
>
>  double epsilon_ ;
>
>
>
>} ;
># 110 "../src/CoinFloatEqual.hpp"
>class CoinRelFltEq
>{
>  public:
>
>
>
>  inline bool operator() (const double f1, const double f2) const
>
>  { if (CoinIsnan(f1) || CoinIsnan(f2)) return false ;
>    if (f1 == f2) return true ;
>    if (!CoinFinite(f1) || !CoinFinite(f2)) return false ;
>
>    double tol = (fabs(f1)>fabs(f2))?fabs(f1):fabs(f2) ;
>
>    return (fabs(f1-f2) <= epsilon_*(1+tol)) ; }
># 134 "../src/CoinFloatEqual.hpp"
>  CoinRelFltEq () : epsilon_(1.e-10) {}
># 145 "../src/CoinFloatEqual.hpp"
>  CoinRelFltEq (const double epsilon) : epsilon_(epsilon) {}
>
>
>
>  virtual ~CoinRelFltEq () {}
>
>
>
>  CoinRelFltEq (const CoinRelFltEq & src) : epsilon_(src.epsilon_) {}
>
>
>
>  CoinRelFltEq& operator= (const CoinRelFltEq& rhs)
>
>  { if (this != &rhs) epsilon_ = rhs.epsilon_ ;
>    return (*this) ; }
>
>
>
>private:
>
>
>
>
>
>
>  double epsilon_ ;
>
>
>
>} ;
># 13 "CoinPackedVectorTest.cpp" 2
># 1 "../src/CoinFinite.hpp" 1
># 14 "CoinPackedVectorTest.cpp" 2
># 1 "../src/CoinPackedVector.hpp" 1
># 9 "../src/CoinPackedVector.hpp"
># 1 "/usr/include/c++/4.8.0/map" 1 3
># 58 "/usr/include/c++/4.8.0/map" 3
>       
># 59 "/usr/include/c++/4.8.0/map" 3
>
># 1 "/usr/include/c++/4.8.0/bits/stl_tree.h" 1 3
># 63 "/usr/include/c++/4.8.0/bits/stl_tree.h" 3
># 1 "/usr/include/c++/4.8.0/bits/stl_function.h" 1 3
># 59 "/usr/include/c++/4.8.0/bits/stl_function.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 100 "/usr/include/c++/4.8.0/bits/stl_function.h" 3
>  template<typename _Arg, typename _Result>
>    struct unary_function
>    {
>
>      typedef _Arg argument_type;
>
>
>      typedef _Result result_type;
>    };
>
>
>
>
>  template<typename _Arg1, typename _Arg2, typename _Result>
>    struct binary_function
>    {
>
>      typedef _Arg1 first_argument_type;
>
>
>      typedef _Arg2 second_argument_type;
>
>
>      typedef _Result result_type;
>    };
># 139 "/usr/include/c++/4.8.0/bits/stl_function.h" 3
>  template<typename _Tp>
>    struct plus : public binary_function<_Tp, _Tp, _Tp>
>    {
>      _Tp
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x + __y; }
>    };
>
>
>  template<typename _Tp>
>    struct minus : public binary_function<_Tp, _Tp, _Tp>
>    {
>      _Tp
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x - __y; }
>    };
>
>
>  template<typename _Tp>
>    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
>    {
>      _Tp
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x * __y; }
>    };
>
>
>  template<typename _Tp>
>    struct divides : public binary_function<_Tp, _Tp, _Tp>
>    {
>      _Tp
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x / __y; }
>    };
>
>
>  template<typename _Tp>
>    struct modulus : public binary_function<_Tp, _Tp, _Tp>
>    {
>      _Tp
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x % __y; }
>    };
>
>
>  template<typename _Tp>
>    struct negate : public unary_function<_Tp, _Tp>
>    {
>      _Tp
>      operator()(const _Tp& __x) const
>      { return -__x; }
>    };
># 203 "/usr/include/c++/4.8.0/bits/stl_function.h" 3
>  template<typename _Tp>
>    struct equal_to : public binary_function<_Tp, _Tp, bool>
>    {
>      bool
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x == __y; }
>    };
>
>
>  template<typename _Tp>
>    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
>    {
>      bool
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x != __y; }
>    };
>
>
>  template<typename _Tp>
>    struct greater : public binary_function<_Tp, _Tp, bool>
>    {
>      bool
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x > __y; }
>    };
>
>
>  template<typename _Tp>
>    struct less : public binary_function<_Tp, _Tp, bool>
>    {
>      bool
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x < __y; }
>    };
>
>
>  template<typename _Tp>
>    struct greater_equal : public binary_function<_Tp, _Tp, bool>
>    {
>      bool
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x >= __y; }
>    };
>
>
>  template<typename _Tp>
>    struct less_equal : public binary_function<_Tp, _Tp, bool>
>    {
>      bool
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x <= __y; }
>    };
># 267 "/usr/include/c++/4.8.0/bits/stl_function.h" 3
>  template<typename _Tp>
>    struct logical_and : public binary_function<_Tp, _Tp, bool>
>    {
>      bool
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x && __y; }
>    };
>
>
>  template<typename _Tp>
>    struct logical_or : public binary_function<_Tp, _Tp, bool>
>    {
>      bool
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x || __y; }
>    };
>
>
>  template<typename _Tp>
>    struct logical_not : public unary_function<_Tp, bool>
>    {
>      bool
>      operator()(const _Tp& __x) const
>      { return !__x; }
>    };
>
>
>
>
>  template<typename _Tp>
>    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
>    {
>      _Tp
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x & __y; }
>    };
>
>  template<typename _Tp>
>    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
>    {
>      _Tp
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x | __y; }
>    };
>
>  template<typename _Tp>
>    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
>    {
>      _Tp
>      operator()(const _Tp& __x, const _Tp& __y) const
>      { return __x ^ __y; }
>    };
># 350 "/usr/include/c++/4.8.0/bits/stl_function.h" 3
>  template<typename _Predicate>
>    class unary_negate
>    : public unary_function<typename _Predicate::argument_type, bool>
>    {
>    protected:
>      _Predicate _M_pred;
>
>    public:
>      explicit
>      unary_negate(const _Predicate& __x) : _M_pred(__x) { }
>
>      bool
>      operator()(const typename _Predicate::argument_type& __x) const
>      { return !_M_pred(__x); }
>    };
>
>
>  template<typename _Predicate>
>    inline unary_negate<_Predicate>
>    not1(const _Predicate& __pred)
>    { return unary_negate<_Predicate>(__pred); }
>
>
>  template<typename _Predicate>
>    class binary_negate
>    : public binary_function<typename _Predicate::first_argument_type,
>        typename _Predicate::second_argument_type, bool>
>    {
>    protected:
>      _Predicate _M_pred;
>
>    public:
>      explicit
>      binary_negate(const _Predicate& __x) : _M_pred(__x) { }
>
>      bool
>      operator()(const typename _Predicate::first_argument_type& __x,
>   const typename _Predicate::second_argument_type& __y) const
>      { return !_M_pred(__x, __y); }
>    };
>
>
>  template<typename _Predicate>
>    inline binary_negate<_Predicate>
>    not2(const _Predicate& __pred)
>    { return binary_negate<_Predicate>(__pred); }
># 421 "/usr/include/c++/4.8.0/bits/stl_function.h" 3
>  template<typename _Arg, typename _Result>
>    class pointer_to_unary_function : public unary_function<_Arg, _Result>
>    {
>    protected:
>      _Result (*_M_ptr)(_Arg);
>
>    public:
>      pointer_to_unary_function() { }
>
>      explicit
>      pointer_to_unary_function(_Result (*__x)(_Arg))
>      : _M_ptr(__x) { }
>
>      _Result
>      operator()(_Arg __x) const
>      { return _M_ptr(__x); }
>    };
>
>
>  template<typename _Arg, typename _Result>
>    inline pointer_to_unary_function<_Arg, _Result>
>    ptr_fun(_Result (*__x)(_Arg))
>    { return pointer_to_unary_function<_Arg, _Result>(__x); }
>
>
>  template<typename _Arg1, typename _Arg2, typename _Result>
>    class pointer_to_binary_function
>    : public binary_function<_Arg1, _Arg2, _Result>
>    {
>    protected:
>      _Result (*_M_ptr)(_Arg1, _Arg2);
>
>    public:
>      pointer_to_binary_function() { }
>
>      explicit
>      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
>      : _M_ptr(__x) { }
>
>      _Result
>      operator()(_Arg1 __x, _Arg2 __y) const
>      { return _M_ptr(__x, __y); }
>    };
>
>
>  template<typename _Arg1, typename _Arg2, typename _Result>
>    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
>    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
>    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
>
>
>  template<typename _Tp>
>    struct _Identity
>    : public unary_function<_Tp,_Tp>
>    {
>      _Tp&
>      operator()(_Tp& __x) const
>      { return __x; }
>
>      const _Tp&
>      operator()(const _Tp& __x) const
>      { return __x; }
>    };
>
>  template<typename _Pair>
>    struct _Select1st
>    : public unary_function<_Pair, typename _Pair::first_type>
>    {
>      typename _Pair::first_type&
>      operator()(_Pair& __x) const
>      { return __x.first; }
>
>      const typename _Pair::first_type&
>      operator()(const _Pair& __x) const
>      { return __x.first; }
># 508 "/usr/include/c++/4.8.0/bits/stl_function.h" 3
>    };
>
>  template<typename _Pair>
>    struct _Select2nd
>    : public unary_function<_Pair, typename _Pair::second_type>
>    {
>      typename _Pair::second_type&
>      operator()(_Pair& __x) const
>      { return __x.second; }
>
>      const typename _Pair::second_type&
>      operator()(const _Pair& __x) const
>      { return __x.second; }
>    };
># 541 "/usr/include/c++/4.8.0/bits/stl_function.h" 3
>  template<typename _Ret, typename _Tp>
>    class mem_fun_t : public unary_function<_Tp*, _Ret>
>    {
>    public:
>      explicit
>      mem_fun_t(_Ret (_Tp::*__pf)())
>      : _M_f(__pf) { }
>
>      _Ret
>      operator()(_Tp* __p) const
>      { return (__p->*_M_f)(); }
>
>    private:
>      _Ret (_Tp::*_M_f)();
>    };
>
>
>
>  template<typename _Ret, typename _Tp>
>    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
>    {
>    public:
>      explicit
>      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
>      : _M_f(__pf) { }
>
>      _Ret
>      operator()(const _Tp* __p) const
>      { return (__p->*_M_f)(); }
>
>    private:
>      _Ret (_Tp::*_M_f)() const;
>    };
>
>
>
>  template<typename _Ret, typename _Tp>
>    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
>    {
>    public:
>      explicit
>      mem_fun_ref_t(_Ret (_Tp::*__pf)())
>      : _M_f(__pf) { }
>
>      _Ret
>      operator()(_Tp& __r) const
>      { return (__r.*_M_f)(); }
>
>    private:
>      _Ret (_Tp::*_M_f)();
>  };
>
>
>
>  template<typename _Ret, typename _Tp>
>    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
>    {
>    public:
>      explicit
>      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
>      : _M_f(__pf) { }
>
>      _Ret
>      operator()(const _Tp& __r) const
>      { return (__r.*_M_f)(); }
>
>    private:
>      _Ret (_Tp::*_M_f)() const;
>    };
>
>
>
>  template<typename _Ret, typename _Tp, typename _Arg>
>    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
>    {
>    public:
>      explicit
>      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
>      : _M_f(__pf) { }
>
>      _Ret
>      operator()(_Tp* __p, _Arg __x) const
>      { return (__p->*_M_f)(__x); }
>
>    private:
>      _Ret (_Tp::*_M_f)(_Arg);
>    };
>
>
>
>  template<typename _Ret, typename _Tp, typename _Arg>
>    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
>    {
>    public:
>      explicit
>      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
>      : _M_f(__pf) { }
>
>      _Ret
>      operator()(const _Tp* __p, _Arg __x) const
>      { return (__p->*_M_f)(__x); }
>
>    private:
>      _Ret (_Tp::*_M_f)(_Arg) const;
>    };
>
>
>
>  template<typename _Ret, typename _Tp, typename _Arg>
>    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
>    {
>    public:
>      explicit
>      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
>      : _M_f(__pf) { }
>
>      _Ret
>      operator()(_Tp& __r, _Arg __x) const
>      { return (__r.*_M_f)(__x); }
>
>    private:
>      _Ret (_Tp::*_M_f)(_Arg);
>    };
>
>
>
>  template<typename _Ret, typename _Tp, typename _Arg>
>    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
>    {
>    public:
>      explicit
>      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
>      : _M_f(__pf) { }
>
>      _Ret
>      operator()(const _Tp& __r, _Arg __x) const
>      { return (__r.*_M_f)(__x); }
>
>    private:
>      _Ret (_Tp::*_M_f)(_Arg) const;
>    };
>
>
>
>  template<typename _Ret, typename _Tp>
>    inline mem_fun_t<_Ret, _Tp>
>    mem_fun(_Ret (_Tp::*__f)())
>    { return mem_fun_t<_Ret, _Tp>(__f); }
>
>  template<typename _Ret, typename _Tp>
>    inline const_mem_fun_t<_Ret, _Tp>
>    mem_fun(_Ret (_Tp::*__f)() const)
>    { return const_mem_fun_t<_Ret, _Tp>(__f); }
>
>  template<typename _Ret, typename _Tp>
>    inline mem_fun_ref_t<_Ret, _Tp>
>    mem_fun_ref(_Ret (_Tp::*__f)())
>    { return mem_fun_ref_t<_Ret, _Tp>(__f); }
>
>  template<typename _Ret, typename _Tp>
>    inline const_mem_fun_ref_t<_Ret, _Tp>
>    mem_fun_ref(_Ret (_Tp::*__f)() const)
>    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
>
>  template<typename _Ret, typename _Tp, typename _Arg>
>    inline mem_fun1_t<_Ret, _Tp, _Arg>
>    mem_fun(_Ret (_Tp::*__f)(_Arg))
>    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
>  template<typename _Ret, typename _Tp, typename _Arg>
>    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
>    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
>    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
>  template<typename _Ret, typename _Tp, typename _Arg>
>    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
>    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
>    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
>
>  template<typename _Ret, typename _Tp, typename _Arg>
>    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
>    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
>    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
>
>
>
>
>}
>
>
># 1 "/usr/include/c++/4.8.0/backward/binders.h" 1 3
># 59 "/usr/include/c++/4.8.0/backward/binders.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 103 "/usr/include/c++/4.8.0/backward/binders.h" 3
>  template<typename _Operation>
>    class binder1st
>    : public unary_function<typename _Operation::second_argument_type,
>       typename _Operation::result_type>
>    {
>    protected:
>      _Operation op;
>      typename _Operation::first_argument_type value;
>
>    public:
>      binder1st(const _Operation& __x,
>  const typename _Operation::first_argument_type& __y)
>      : op(__x), value(__y) { }
>
>      typename _Operation::result_type
>      operator()(const typename _Operation::second_argument_type& __x) const
>      { return op(value, __x); }
>
>
>
>      typename _Operation::result_type
>      operator()(typename _Operation::second_argument_type& __x) const
>      { return op(value, __x); }
>    } ;
>
>
>  template<typename _Operation, typename _Tp>
>    inline binder1st<_Operation>
>    bind1st(const _Operation& __fn, const _Tp& __x)
>    {
>      typedef typename _Operation::first_argument_type _Arg1_type;
>      return binder1st<_Operation>(__fn, _Arg1_type(__x));
>    }
>
>
>  template<typename _Operation>
>    class binder2nd
>    : public unary_function<typename _Operation::first_argument_type,
>       typename _Operation::result_type>
>    {
>    protected:
>      _Operation op;
>      typename _Operation::second_argument_type value;
>
>    public:
>      binder2nd(const _Operation& __x,
>  const typename _Operation::second_argument_type& __y)
>      : op(__x), value(__y) { }
>
>      typename _Operation::result_type
>      operator()(const typename _Operation::first_argument_type& __x) const
>      { return op(__x, value); }
>
>
>
>      typename _Operation::result_type
>      operator()(typename _Operation::first_argument_type& __x) const
>      { return op(__x, value); }
>    } ;
>
>
>  template<typename _Operation, typename _Tp>
>    inline binder2nd<_Operation>
>    bind2nd(const _Operation& __fn, const _Tp& __x)
>    {
>      typedef typename _Operation::second_argument_type _Arg2_type;
>      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
>    }
>
>
>
>}
># 732 "/usr/include/c++/4.8.0/bits/stl_function.h" 2 3
># 64 "/usr/include/c++/4.8.0/bits/stl_tree.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 86 "/usr/include/c++/4.8.0/bits/stl_tree.h" 3
>  enum _Rb_tree_color { _S_red = false, _S_black = true };
>
>  struct _Rb_tree_node_base
>  {
>    typedef _Rb_tree_node_base* _Base_ptr;
>    typedef const _Rb_tree_node_base* _Const_Base_ptr;
>
>    _Rb_tree_color _M_color;
>    _Base_ptr _M_parent;
>    _Base_ptr _M_left;
>    _Base_ptr _M_right;
>
>    static _Base_ptr
>    _S_minimum(_Base_ptr __x)
>    {
>      while (__x->_M_left != 0) __x = __x->_M_left;
>      return __x;
>    }
>
>    static _Const_Base_ptr
>    _S_minimum(_Const_Base_ptr __x)
>    {
>      while (__x->_M_left != 0) __x = __x->_M_left;
>      return __x;
>    }
>
>    static _Base_ptr
>    _S_maximum(_Base_ptr __x)
>    {
>      while (__x->_M_right != 0) __x = __x->_M_right;
>      return __x;
>    }
>
>    static _Const_Base_ptr
>    _S_maximum(_Const_Base_ptr __x)
>    {
>      while (__x->_M_right != 0) __x = __x->_M_right;
>      return __x;
>    }
>  };
>
>  template<typename _Val>
>    struct _Rb_tree_node : public _Rb_tree_node_base
>    {
>      typedef _Rb_tree_node<_Val>* _Link_type;
>      _Val _M_value_field;
>
>
>
>
>
>
>
>    };
>
>  __attribute__ ((__pure__)) _Rb_tree_node_base*
>  _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
>
>  __attribute__ ((__pure__)) const _Rb_tree_node_base*
>  _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();
>
>  __attribute__ ((__pure__)) _Rb_tree_node_base*
>  _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
>
>  __attribute__ ((__pure__)) const _Rb_tree_node_base*
>  _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();
>
>  template<typename _Tp>
>    struct _Rb_tree_iterator
>    {
>      typedef _Tp value_type;
>      typedef _Tp& reference;
>      typedef _Tp* pointer;
>
>      typedef bidirectional_iterator_tag iterator_category;
>      typedef ptrdiff_t difference_type;
>
>      typedef _Rb_tree_iterator<_Tp> _Self;
>      typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
>      typedef _Rb_tree_node<_Tp>* _Link_type;
>
>      _Rb_tree_iterator()
>      : _M_node() { }
>
>      explicit
>      _Rb_tree_iterator(_Link_type __x)
>      : _M_node(__x) { }
>
>      reference
>      operator*() const
>      { return static_cast<_Link_type>(_M_node)->_M_value_field; }
>
>      pointer
>      operator->() const
>      { return std::__addressof(static_cast<_Link_type>
>    (_M_node)->_M_value_field); }
>
>      _Self&
>      operator++()
>      {
> _M_node = _Rb_tree_increment(_M_node);
> return *this;
>      }
>
>      _Self
>      operator++(int)
>      {
> _Self __tmp = *this;
> _M_node = _Rb_tree_increment(_M_node);
> return __tmp;
>      }
>
>      _Self&
>      operator--()
>      {
> _M_node = _Rb_tree_decrement(_M_node);
> return *this;
>      }
>
>      _Self
>      operator--(int)
>      {
> _Self __tmp = *this;
> _M_node = _Rb_tree_decrement(_M_node);
> return __tmp;
>      }
>
>      bool
>      operator==(const _Self& __x) const
>      { return _M_node == __x._M_node; }
>
>      bool
>      operator!=(const _Self& __x) const
>      { return _M_node != __x._M_node; }
>
>      _Base_ptr _M_node;
>  };
>
>  template<typename _Tp>
>    struct _Rb_tree_const_iterator
>    {
>      typedef _Tp value_type;
>      typedef const _Tp& reference;
>      typedef const _Tp* pointer;
>
>      typedef _Rb_tree_iterator<_Tp> iterator;
>
>      typedef bidirectional_iterator_tag iterator_category;
>      typedef ptrdiff_t difference_type;
>
>      typedef _Rb_tree_const_iterator<_Tp> _Self;
>      typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
>      typedef const _Rb_tree_node<_Tp>* _Link_type;
>
>      _Rb_tree_const_iterator()
>      : _M_node() { }
>
>      explicit
>      _Rb_tree_const_iterator(_Link_type __x)
>      : _M_node(__x) { }
>
>      _Rb_tree_const_iterator(const iterator& __it)
>      : _M_node(__it._M_node) { }
>
>      iterator
>      _M_const_cast() const
>      { return iterator(static_cast<typename iterator::_Link_type>
>   (const_cast<typename iterator::_Base_ptr>(_M_node))); }
>
>      reference
>      operator*() const
>      { return static_cast<_Link_type>(_M_node)->_M_value_field; }
>
>      pointer
>      operator->() const
>      { return std::__addressof(static_cast<_Link_type>
>    (_M_node)->_M_value_field); }
>
>      _Self&
>      operator++()
>      {
> _M_node = _Rb_tree_increment(_M_node);
> return *this;
>      }
>
>      _Self
>      operator++(int)
>      {
> _Self __tmp = *this;
> _M_node = _Rb_tree_increment(_M_node);
> return __tmp;
>      }
>
>      _Self&
>      operator--()
>      {
> _M_node = _Rb_tree_decrement(_M_node);
> return *this;
>      }
>
>      _Self
>      operator--(int)
>      {
> _Self __tmp = *this;
> _M_node = _Rb_tree_decrement(_M_node);
> return __tmp;
>      }
>
>      bool
>      operator==(const _Self& __x) const
>      { return _M_node == __x._M_node; }
>
>      bool
>      operator!=(const _Self& __x) const
>      { return _M_node != __x._M_node; }
>
>      _Base_ptr _M_node;
>    };
>
>  template<typename _Val>
>    inline bool
>    operator==(const _Rb_tree_iterator<_Val>& __x,
>               const _Rb_tree_const_iterator<_Val>& __y)
>    { return __x._M_node == __y._M_node; }
>
>  template<typename _Val>
>    inline bool
>    operator!=(const _Rb_tree_iterator<_Val>& __x,
>               const _Rb_tree_const_iterator<_Val>& __y)
>    { return __x._M_node != __y._M_node; }
>
>  void
>  _Rb_tree_insert_and_rebalance(const bool __insert_left,
>                                _Rb_tree_node_base* __x,
>                                _Rb_tree_node_base* __p,
>                                _Rb_tree_node_base& __header) throw ();
>
>  _Rb_tree_node_base*
>  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
>          _Rb_tree_node_base& __header) throw ();
>
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc = allocator<_Val> >
>    class _Rb_tree
>    {
>      typedef typename _Alloc::template rebind<_Rb_tree_node<_Val> >::other
>              _Node_allocator;
>
>    protected:
>      typedef _Rb_tree_node_base* _Base_ptr;
>      typedef const _Rb_tree_node_base* _Const_Base_ptr;
>
>    public:
>      typedef _Key key_type;
>      typedef _Val value_type;
>      typedef value_type* pointer;
>      typedef const value_type* const_pointer;
>      typedef value_type& reference;
>      typedef const value_type& const_reference;
>      typedef _Rb_tree_node<_Val>* _Link_type;
>      typedef const _Rb_tree_node<_Val>* _Const_Link_type;
>      typedef size_t size_type;
>      typedef ptrdiff_t difference_type;
>      typedef _Alloc allocator_type;
>
>      _Node_allocator&
>      _M_get_Node_allocator()
>      { return *static_cast<_Node_allocator*>(&this->_M_impl); }
>
>      const _Node_allocator&
>      _M_get_Node_allocator() const
>      { return *static_cast<const _Node_allocator*>(&this->_M_impl); }
>
>      allocator_type
>      get_allocator() const
>      { return allocator_type(_M_get_Node_allocator()); }
>
>    protected:
>      _Link_type
>      _M_get_node()
>      { return _M_impl._Node_allocator::allocate(1); }
>
>      void
>      _M_put_node(_Link_type __p)
>      { _M_impl._Node_allocator::deallocate(__p, 1); }
>
>
>      _Link_type
>      _M_create_node(const value_type& __x)
>      {
> _Link_type __tmp = _M_get_node();
> try
>   { get_allocator().construct
>       (std::__addressof(__tmp->_M_value_field), __x); }
> catch(...)
>   {
>     _M_put_node(__tmp);
>     throw;
>   }
> return __tmp;
>      }
>
>      void
>      _M_destroy_node(_Link_type __p)
>      {
> get_allocator().destroy(std::__addressof(__p->_M_value_field));
> _M_put_node(__p);
>      }
># 422 "/usr/include/c++/4.8.0/bits/stl_tree.h" 3
>      _Link_type
>      _M_clone_node(_Const_Link_type __x)
>      {
> _Link_type __tmp = _M_create_node(__x->_M_value_field);
> __tmp->_M_color = __x->_M_color;
> __tmp->_M_left = 0;
> __tmp->_M_right = 0;
> return __tmp;
>      }
>
>    protected:
>      template<typename _Key_compare,
>        bool _Is_pod_comparator = __is_pod(_Key_compare)>
>        struct _Rb_tree_impl : public _Node_allocator
>        {
>   _Key_compare _M_key_compare;
>   _Rb_tree_node_base _M_header;
>   size_type _M_node_count;
>
>   _Rb_tree_impl()
>   : _Node_allocator(), _M_key_compare(), _M_header(),
>     _M_node_count(0)
>   { _M_initialize(); }
>
>   _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
>   : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
>     _M_node_count(0)
>   { _M_initialize(); }
># 458 "/usr/include/c++/4.8.0/bits/stl_tree.h" 3
> private:
>   void
>   _M_initialize()
>   {
>     this->_M_header._M_color = _S_red;
>     this->_M_header._M_parent = 0;
>     this->_M_header._M_left = &this->_M_header;
>     this->_M_header._M_right = &this->_M_header;
>   }
> };
>
>      _Rb_tree_impl<_Compare> _M_impl;
>
>    protected:
>      _Base_ptr&
>      _M_root()
>      { return this->_M_impl._M_header._M_parent; }
>
>      _Const_Base_ptr
>      _M_root() const
>      { return this->_M_impl._M_header._M_parent; }
>
>      _Base_ptr&
>      _M_leftmost()
>      { return this->_M_impl._M_header._M_left; }
>
>      _Const_Base_ptr
>      _M_leftmost() const
>      { return this->_M_impl._M_header._M_left; }
>
>      _Base_ptr&
>      _M_rightmost()
>      { return this->_M_impl._M_header._M_right; }
>
>      _Const_Base_ptr
>      _M_rightmost() const
>      { return this->_M_impl._M_header._M_right; }
>
>      _Link_type
>      _M_begin()
>      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
>
>      _Const_Link_type
>      _M_begin() const
>      {
> return static_cast<_Const_Link_type>
>   (this->_M_impl._M_header._M_parent);
>      }
>
>      _Link_type
>      _M_end()
>      { return static_cast<_Link_type>(&this->_M_impl._M_header); }
>
>      _Const_Link_type
>      _M_end() const
>      { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }
>
>      static const_reference
>      _S_value(_Const_Link_type __x)
>      { return __x->_M_value_field; }
>
>      static const _Key&
>      _S_key(_Const_Link_type __x)
>      { return _KeyOfValue()(_S_value(__x)); }
>
>      static _Link_type
>      _S_left(_Base_ptr __x)
>      { return static_cast<_Link_type>(__x->_M_left); }
>
>      static _Const_Link_type
>      _S_left(_Const_Base_ptr __x)
>      { return static_cast<_Const_Link_type>(__x->_M_left); }
>
>      static _Link_type
>      _S_right(_Base_ptr __x)
>      { return static_cast<_Link_type>(__x->_M_right); }
>
>      static _Const_Link_type
>      _S_right(_Const_Base_ptr __x)
>      { return static_cast<_Const_Link_type>(__x->_M_right); }
>
>      static const_reference
>      _S_value(_Const_Base_ptr __x)
>      { return static_cast<_Const_Link_type>(__x)->_M_value_field; }
>
>      static const _Key&
>      _S_key(_Const_Base_ptr __x)
>      { return _KeyOfValue()(_S_value(__x)); }
>
>      static _Base_ptr
>      _S_minimum(_Base_ptr __x)
>      { return _Rb_tree_node_base::_S_minimum(__x); }
>
>      static _Const_Base_ptr
>      _S_minimum(_Const_Base_ptr __x)
>      { return _Rb_tree_node_base::_S_minimum(__x); }
>
>      static _Base_ptr
>      _S_maximum(_Base_ptr __x)
>      { return _Rb_tree_node_base::_S_maximum(__x); }
>
>      static _Const_Base_ptr
>      _S_maximum(_Const_Base_ptr __x)
>      { return _Rb_tree_node_base::_S_maximum(__x); }
>
>    public:
>      typedef _Rb_tree_iterator<value_type> iterator;
>      typedef _Rb_tree_const_iterator<value_type> const_iterator;
>
>      typedef std::reverse_iterator<iterator> reverse_iterator;
>      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
>
>    private:
>      pair<_Base_ptr, _Base_ptr>
>      _M_get_insert_unique_pos(const key_type& __k);
>
>      pair<_Base_ptr, _Base_ptr>
>      _M_get_insert_equal_pos(const key_type& __k);
>
>      pair<_Base_ptr, _Base_ptr>
>      _M_get_insert_hint_unique_pos(const_iterator __pos,
>        const key_type& __k);
>
>      pair<_Base_ptr, _Base_ptr>
>      _M_get_insert_hint_equal_pos(const_iterator __pos,
>       const key_type& __k);
># 607 "/usr/include/c++/4.8.0/bits/stl_tree.h" 3
>      iterator
>      _M_insert_(_Base_ptr __x, _Base_ptr __y,
>   const value_type& __v);
>
>
>
>      iterator
>      _M_insert_lower(_Base_ptr __y, const value_type& __v);
>
>      iterator
>      _M_insert_equal_lower(const value_type& __x);
>
>
>      _Link_type
>      _M_copy(_Const_Link_type __x, _Link_type __p);
>
>      void
>      _M_erase(_Link_type __x);
>
>      iterator
>      _M_lower_bound(_Link_type __x, _Link_type __y,
>       const _Key& __k);
>
>      const_iterator
>      _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
>       const _Key& __k) const;
>
>      iterator
>      _M_upper_bound(_Link_type __x, _Link_type __y,
>       const _Key& __k);
>
>      const_iterator
>      _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
>       const _Key& __k) const;
>
>    public:
>
>      _Rb_tree() { }
>
>      _Rb_tree(const _Compare& __comp,
>        const allocator_type& __a = allocator_type())
>      : _M_impl(__comp, _Node_allocator(__a)) { }
>
>      _Rb_tree(const _Rb_tree& __x)
>      : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
>      {
> if (__x._M_root() != 0)
>   {
>     _M_root() = _M_copy(__x._M_begin(), _M_end());
>     _M_leftmost() = _S_minimum(_M_root());
>     _M_rightmost() = _S_maximum(_M_root());
>     _M_impl._M_node_count = __x._M_impl._M_node_count;
>   }
>      }
>
>
>
>
>
>      ~_Rb_tree()
>      { _M_erase(_M_begin()); }
>
>      _Rb_tree&
>      operator=(const _Rb_tree& __x);
>
>
>      _Compare
>      key_comp() const
>      { return _M_impl._M_key_compare; }
>
>      iterator
>      begin()
>      {
> return iterator(static_cast<_Link_type>
>   (this->_M_impl._M_header._M_left));
>      }
>
>      const_iterator
>      begin() const
>      {
> return const_iterator(static_cast<_Const_Link_type>
>         (this->_M_impl._M_header._M_left));
>      }
>
>      iterator
>      end()
>      { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
>
>      const_iterator
>      end() const
>      {
> return const_iterator(static_cast<_Const_Link_type>
>         (&this->_M_impl._M_header));
>      }
>
>      reverse_iterator
>      rbegin()
>      { return reverse_iterator(end()); }
>
>      const_reverse_iterator
>      rbegin() const
>      { return const_reverse_iterator(end()); }
>
>      reverse_iterator
>      rend()
>      { return reverse_iterator(begin()); }
>
>      const_reverse_iterator
>      rend() const
>      { return const_reverse_iterator(begin()); }
>
>      bool
>      empty() const
>      { return _M_impl._M_node_count == 0; }
>
>      size_type
>      size() const
>      { return _M_impl._M_node_count; }
>
>      size_type
>      max_size() const
>      { return _M_get_Node_allocator().max_size(); }
>
>      void
>      swap(_Rb_tree& __t);
># 767 "/usr/include/c++/4.8.0/bits/stl_tree.h" 3
>      pair<iterator, bool>
>      _M_insert_unique(const value_type& __x);
>
>      iterator
>      _M_insert_equal(const value_type& __x);
>
>      iterator
>      _M_insert_unique_(const_iterator __position, const value_type& __x);
>
>      iterator
>      _M_insert_equal_(const_iterator __position, const value_type& __x);
>
>
>      template<typename _InputIterator>
>        void
>        _M_insert_unique(_InputIterator __first, _InputIterator __last);
>
>      template<typename _InputIterator>
>        void
>        _M_insert_equal(_InputIterator __first, _InputIterator __last);
>
>    private:
>      void
>      _M_erase_aux(const_iterator __position);
>
>      void
>      _M_erase_aux(const_iterator __first, const_iterator __last);
>
>    public:
># 818 "/usr/include/c++/4.8.0/bits/stl_tree.h" 3
>      void
>      erase(iterator __position)
>      { _M_erase_aux(__position); }
>
>      void
>      erase(const_iterator __position)
>      { _M_erase_aux(__position); }
>
>      size_type
>      erase(const key_type& __x);
># 839 "/usr/include/c++/4.8.0/bits/stl_tree.h" 3
>      void
>      erase(iterator __first, iterator __last)
>      { _M_erase_aux(__first, __last); }
>
>      void
>      erase(const_iterator __first, const_iterator __last)
>      { _M_erase_aux(__first, __last); }
>
>      void
>      erase(const key_type* __first, const key_type* __last);
>
>      void
>      clear()
>      {
>        _M_erase(_M_begin());
>        _M_leftmost() = _M_end();
>        _M_root() = 0;
>        _M_rightmost() = _M_end();
>        _M_impl._M_node_count = 0;
>      }
>
>
>      iterator
>      find(const key_type& __k);
>
>      const_iterator
>      find(const key_type& __k) const;
>
>      size_type
>      count(const key_type& __k) const;
>
>      iterator
>      lower_bound(const key_type& __k)
>      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
>
>      const_iterator
>      lower_bound(const key_type& __k) const
>      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
>
>      iterator
>      upper_bound(const key_type& __k)
>      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
>
>      const_iterator
>      upper_bound(const key_type& __k) const
>      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
>
>      pair<iterator, iterator>
>      equal_range(const key_type& __k);
>
>      pair<const_iterator, const_iterator>
>      equal_range(const key_type& __k) const;
>
>
>      bool
>      __rb_verify() const;
>    };
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    inline bool
>    operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
>        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
>    {
>      return __x.size() == __y.size()
>      && std::equal(__x.begin(), __x.end(), __y.begin());
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    inline bool
>    operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
>       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
>    {
>      return std::lexicographical_compare(__x.begin(), __x.end(),
>       __y.begin(), __y.end());
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    inline bool
>    operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
>        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
>    { return !(__x == __y); }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    inline bool
>    operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
>       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
>    { return __y < __x; }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    inline bool
>    operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
>        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
>    { return !(__y < __x); }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    inline bool
>    operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
>        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
>    { return !(__x < __y); }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    inline void
>    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
>  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
>    { __x.swap(__y); }
># 977 "/usr/include/c++/4.8.0/bits/stl_tree.h" 3
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
>    {
>      if (this != &__x)
> {
>
>   clear();
>   _M_impl._M_key_compare = __x._M_impl._M_key_compare;
>   if (__x._M_root() != 0)
>     {
>       _M_root() = _M_copy(__x._M_begin(), _M_end());
>       _M_leftmost() = _S_minimum(_M_root());
>       _M_rightmost() = _S_maximum(_M_root());
>       _M_impl._M_node_count = __x._M_impl._M_node_count;
>     }
> }
>      return *this;
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>
>
>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
>
>
>    _M_insert_(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
>
>    {
>      bool __insert_left = (__x != 0 || __p == _M_end()
>       || _M_impl._M_key_compare(_KeyOfValue()(__v),
>            _S_key(__p)));
>
>      _Link_type __z = _M_create_node((__v));
>
>      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
>        this->_M_impl._M_header);
>      ++_M_impl._M_node_count;
>      return iterator(__z);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>
>
>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
>
>
>    _M_insert_lower(_Base_ptr __p, const _Val& __v)
>
>    {
>      bool __insert_left = (__p == _M_end()
>       || !_M_impl._M_key_compare(_S_key(__p),
>             _KeyOfValue()(__v)));
>
>      _Link_type __z = _M_create_node((__v));
>
>      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
>        this->_M_impl._M_header);
>      ++_M_impl._M_node_count;
>      return iterator(__z);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>
>
>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
>
>
>    _M_insert_equal_lower(const _Val& __v)
>
>    {
>      _Link_type __x = _M_begin();
>      _Link_type __y = _M_end();
>      while (__x != 0)
> {
>   __y = __x;
>   __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
>         _S_left(__x) : _S_right(__x);
> }
>      return _M_insert_lower(__y, (__v));
>    }
>
>  template<typename _Key, typename _Val, typename _KoV,
>           typename _Compare, typename _Alloc>
>    typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
>    _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
>    _M_copy(_Const_Link_type __x, _Link_type __p)
>    {
>
>      _Link_type __top = _M_clone_node(__x);
>      __top->_M_parent = __p;
>
>      try
> {
>   if (__x->_M_right)
>     __top->_M_right = _M_copy(_S_right(__x), __top);
>   __p = __top;
>   __x = _S_left(__x);
>
>   while (__x != 0)
>     {
>       _Link_type __y = _M_clone_node(__x);
>       __p->_M_left = __y;
>       __y->_M_parent = __p;
>       if (__x->_M_right)
>  __y->_M_right = _M_copy(_S_right(__x), __y);
>       __p = __y;
>       __x = _S_left(__x);
>     }
> }
>      catch(...)
> {
>   _M_erase(__top);
>   throw;
> }
>      return __top;
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    void
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_erase(_Link_type __x)
>    {
>
>      while (__x != 0)
> {
>   _M_erase(_S_right(__x));
>   _Link_type __y = _S_left(__x);
>   _M_destroy_node(__x);
>   __x = __y;
> }
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue,
>        _Compare, _Alloc>::iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_lower_bound(_Link_type __x, _Link_type __y,
>     const _Key& __k)
>    {
>      while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
>   __y = __x, __x = _S_left(__x);
> else
>   __x = _S_right(__x);
>      return iterator(__y);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue,
>        _Compare, _Alloc>::const_iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
>     const _Key& __k) const
>    {
>      while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
>   __y = __x, __x = _S_left(__x);
> else
>   __x = _S_right(__x);
>      return const_iterator(__y);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue,
>        _Compare, _Alloc>::iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_upper_bound(_Link_type __x, _Link_type __y,
>     const _Key& __k)
>    {
>      while (__x != 0)
> if (_M_impl._M_key_compare(__k, _S_key(__x)))
>   __y = __x, __x = _S_left(__x);
> else
>   __x = _S_right(__x);
>      return iterator(__y);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue,
>        _Compare, _Alloc>::const_iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
>     const _Key& __k) const
>    {
>      while (__x != 0)
> if (_M_impl._M_key_compare(__k, _S_key(__x)))
>   __y = __x, __x = _S_left(__x);
> else
>   __x = _S_right(__x);
>      return const_iterator(__y);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::iterator,
>  typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::iterator>
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    equal_range(const _Key& __k)
>    {
>      _Link_type __x = _M_begin();
>      _Link_type __y = _M_end();
>      while (__x != 0)
> {
>   if (_M_impl._M_key_compare(_S_key(__x), __k))
>     __x = _S_right(__x);
>   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
>     __y = __x, __x = _S_left(__x);
>   else
>     {
>       _Link_type __xu(__x), __yu(__y);
>       __y = __x, __x = _S_left(__x);
>       __xu = _S_right(__xu);
>       return pair<iterator,
>            iterator>(_M_lower_bound(__x, __y, __k),
>        _M_upper_bound(__xu, __yu, __k));
>     }
> }
>      return pair<iterator, iterator>(iterator(__y),
>          iterator(__y));
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::const_iterator,
>  typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::const_iterator>
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    equal_range(const _Key& __k) const
>    {
>      _Const_Link_type __x = _M_begin();
>      _Const_Link_type __y = _M_end();
>      while (__x != 0)
> {
>   if (_M_impl._M_key_compare(_S_key(__x), __k))
>     __x = _S_right(__x);
>   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
>     __y = __x, __x = _S_left(__x);
>   else
>     {
>       _Const_Link_type __xu(__x), __yu(__y);
>       __y = __x, __x = _S_left(__x);
>       __xu = _S_right(__xu);
>       return pair<const_iterator,
>            const_iterator>(_M_lower_bound(__x, __y, __k),
>       _M_upper_bound(__xu, __yu, __k));
>     }
> }
>      return pair<const_iterator, const_iterator>(const_iterator(__y),
>        const_iterator(__y));
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    void
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
>    {
>      if (_M_root() == 0)
> {
>   if (__t._M_root() != 0)
>     {
>       _M_root() = __t._M_root();
>       _M_leftmost() = __t._M_leftmost();
>       _M_rightmost() = __t._M_rightmost();
>       _M_root()->_M_parent = _M_end();
>
>       __t._M_root() = 0;
>       __t._M_leftmost() = __t._M_end();
>       __t._M_rightmost() = __t._M_end();
>     }
> }
>      else if (__t._M_root() == 0)
> {
>   __t._M_root() = _M_root();
>   __t._M_leftmost() = _M_leftmost();
>   __t._M_rightmost() = _M_rightmost();
>   __t._M_root()->_M_parent = __t._M_end();
>
>   _M_root() = 0;
>   _M_leftmost() = _M_end();
>   _M_rightmost() = _M_end();
> }
>      else
> {
>   std::swap(_M_root(),__t._M_root());
>   std::swap(_M_leftmost(),__t._M_leftmost());
>   std::swap(_M_rightmost(),__t._M_rightmost());
>
>   _M_root()->_M_parent = _M_end();
>   __t._M_root()->_M_parent = __t._M_end();
> }
>
>      std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
>      std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
>
>
>
>      std::__alloc_swap<_Node_allocator>::
> _S_do_it(_M_get_Node_allocator(), __t._M_get_Node_allocator());
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::_Base_ptr,
>  typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::_Base_ptr>
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_get_insert_unique_pos(const key_type& __k)
>    {
>      typedef pair<_Base_ptr, _Base_ptr> _Res;
>      _Link_type __x = _M_begin();
>      _Link_type __y = _M_end();
>      bool __comp = true;
>      while (__x != 0)
> {
>   __y = __x;
>   __comp = _M_impl._M_key_compare(__k, _S_key(__x));
>   __x = __comp ? _S_left(__x) : _S_right(__x);
> }
>      iterator __j = iterator(__y);
>      if (__comp)
> {
>   if (__j == begin())
>     return _Res(__x, __y);
>   else
>     --__j;
> }
>      if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
> return _Res(__x, __y);
>      return _Res(__j._M_node, 0);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::_Base_ptr,
>  typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::_Base_ptr>
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_get_insert_equal_pos(const key_type& __k)
>    {
>      typedef pair<_Base_ptr, _Base_ptr> _Res;
>      _Link_type __x = _M_begin();
>      _Link_type __y = _M_end();
>      while (__x != 0)
> {
>   __y = __x;
>   __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
>         _S_left(__x) : _S_right(__x);
> }
>      return _Res(__x, __y);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>
>
>
>    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::iterator, bool>
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
>
>
>    _M_insert_unique(const _Val& __v)
>
>    {
>      typedef pair<iterator, bool> _Res;
>      pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_unique_pos(_KeyOfValue()(__v));
>
>      if (__res.second)
> return _Res(_M_insert_(__res.first, __res.second,
>          (__v)),
>      true);
>
>      return _Res(iterator(static_cast<_Link_type>(__res.first)), false);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>
>
>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
>
>
>    _M_insert_equal(const _Val& __v)
>
>    {
>      pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_equal_pos(_KeyOfValue()(__v));
>      return _M_insert_(__res.first, __res.second, (__v));
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::_Base_ptr,
>         typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::_Base_ptr>
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_get_insert_hint_unique_pos(const_iterator __position,
>      const key_type& __k)
>    {
>      iterator __pos = __position._M_const_cast();
>      typedef pair<_Base_ptr, _Base_ptr> _Res;
>
>
>      if (__pos._M_node == _M_end())
> {
>   if (size() > 0
>       && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
>     return _Res(0, _M_rightmost());
>   else
>     return _M_get_insert_unique_pos(__k);
> }
>      else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
> {
>
>   iterator __before = __pos;
>   if (__pos._M_node == _M_leftmost())
>     return _Res(_M_leftmost(), _M_leftmost());
>   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
>     {
>       if (_S_right(__before._M_node) == 0)
>  return _Res(0, __before._M_node);
>       else
>  return _Res(__pos._M_node, __pos._M_node);
>     }
>   else
>     return _M_get_insert_unique_pos(__k);
> }
>      else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
> {
>
>   iterator __after = __pos;
>   if (__pos._M_node == _M_rightmost())
>     return _Res(0, _M_rightmost());
>   else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
>     {
>       if (_S_right(__pos._M_node) == 0)
>  return _Res(0, __pos._M_node);
>       else
>  return _Res(__after._M_node, __after._M_node);
>     }
>   else
>     return _M_get_insert_unique_pos(__k);
> }
>      else
>
> return _Res(__pos._M_node, 0);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>
>
>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
>
>
>    _M_insert_unique_(const_iterator __position, const _Val& __v)
>
>    {
>      pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));
>
>      if (__res.second)
> return _M_insert_(__res.first, __res.second,
>     (__v));
>      return iterator(static_cast<_Link_type>(__res.first));
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::_Base_ptr,
>         typename _Rb_tree<_Key, _Val, _KeyOfValue,
>      _Compare, _Alloc>::_Base_ptr>
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
>    {
>      iterator __pos = __position._M_const_cast();
>      typedef pair<_Base_ptr, _Base_ptr> _Res;
>
>
>      if (__pos._M_node == _M_end())
> {
>   if (size() > 0
>       && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
>     return _Res(0, _M_rightmost());
>   else
>     return _M_get_insert_equal_pos(__k);
> }
>      else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
> {
>
>   iterator __before = __pos;
>   if (__pos._M_node == _M_leftmost())
>     return _Res(_M_leftmost(), _M_leftmost());
>   else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
>     {
>       if (_S_right(__before._M_node) == 0)
>  return _Res(0, __before._M_node);
>       else
>  return _Res(__pos._M_node, __pos._M_node);
>     }
>   else
>     return _M_get_insert_equal_pos(__k);
> }
>      else
> {
>
>   iterator __after = __pos;
>   if (__pos._M_node == _M_rightmost())
>     return _Res(0, _M_rightmost());
>   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
>     {
>       if (_S_right(__pos._M_node) == 0)
>  return _Res(0, __pos._M_node);
>       else
>  return _Res(__after._M_node, __after._M_node);
>     }
>   else
>     return _Res(0, 0);
> }
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>
>
>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
>
>
>    _M_insert_equal_(const_iterator __position, const _Val& __v)
>
>    {
>      pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));
>
>      if (__res.second)
> return _M_insert_(__res.first, __res.second,
>     (__v));
>
>      return _M_insert_equal_lower((__v));
>    }
># 1707 "/usr/include/c++/4.8.0/bits/stl_tree.h" 3
>  template<typename _Key, typename _Val, typename _KoV,
>           typename _Cmp, typename _Alloc>
>    template<class _II>
>      void
>      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
>      _M_insert_unique(_II __first, _II __last)
>      {
> for (; __first != __last; ++__first)
>   _M_insert_unique_(end(), *__first);
>      }
>
>  template<typename _Key, typename _Val, typename _KoV,
>           typename _Cmp, typename _Alloc>
>    template<class _II>
>      void
>      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
>      _M_insert_equal(_II __first, _II __last)
>      {
> for (; __first != __last; ++__first)
>   _M_insert_equal_(end(), *__first);
>      }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    void
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_erase_aux(const_iterator __position)
>    {
>      _Link_type __y =
> static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
>    (const_cast<_Base_ptr>(__position._M_node),
>     this->_M_impl._M_header));
>      _M_destroy_node(__y);
>      --_M_impl._M_node_count;
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    void
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    _M_erase_aux(const_iterator __first, const_iterator __last)
>    {
>      if (__first == begin() && __last == end())
> clear();
>      else
> while (__first != __last)
>   erase(__first++);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    erase(const _Key& __x)
>    {
>      pair<iterator, iterator> __p = equal_range(__x);
>      const size_type __old_size = size();
>      erase(__p.first, __p.second);
>      return __old_size - size();
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    void
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    erase(const _Key* __first, const _Key* __last)
>    {
>      while (__first != __last)
> erase(*__first++);
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue,
>        _Compare, _Alloc>::iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    find(const _Key& __k)
>    {
>      iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
>      return (__j == end()
>       || _M_impl._M_key_compare(__k,
>     _S_key(__j._M_node))) ? end() : __j;
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue,
>        _Compare, _Alloc>::const_iterator
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    find(const _Key& __k) const
>    {
>      const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
>      return (__j == end()
>       || _M_impl._M_key_compare(__k,
>     _S_key(__j._M_node))) ? end() : __j;
>    }
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
>    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>    count(const _Key& __k) const
>    {
>      pair<const_iterator, const_iterator> __p = equal_range(__k);
>      const size_type __n = std::distance(__p.first, __p.second);
>      return __n;
>    }
>
>  __attribute__ ((__pure__)) unsigned int
>  _Rb_tree_black_count(const _Rb_tree_node_base* __node,
>                       const _Rb_tree_node_base* __root) throw ();
>
>  template<typename _Key, typename _Val, typename _KeyOfValue,
>           typename _Compare, typename _Alloc>
>    bool
>    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
>    {
>      if (_M_impl._M_node_count == 0 || begin() == end())
> return _M_impl._M_node_count == 0 && begin() == end()
>        && this->_M_impl._M_header._M_left == _M_end()
>        && this->_M_impl._M_header._M_right == _M_end();
>
>      unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
>      for (const_iterator __it = begin(); __it != end(); ++__it)
> {
>   _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
>   _Const_Link_type __L = _S_left(__x);
>   _Const_Link_type __R = _S_right(__x);
>
>   if (__x->_M_color == _S_red)
>     if ((__L && __L->_M_color == _S_red)
>  || (__R && __R->_M_color == _S_red))
>       return false;
>
>   if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
>     return false;
>   if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
>     return false;
>
>   if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
>     return false;
> }
>
>      if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
> return false;
>      if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
> return false;
>      return true;
>    }
>
>
>}
># 61 "/usr/include/c++/4.8.0/map" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_map.h" 1 3
># 66 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 94 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>  template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
>            typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
>    class map
>    {
>    public:
>      typedef _Key key_type;
>      typedef _Tp mapped_type;
>      typedef std::pair<const _Key, _Tp> value_type;
>      typedef _Compare key_compare;
>      typedef _Alloc allocator_type;
>
>    private:
>
>      typedef typename _Alloc::value_type _Alloc_value_type;
>     
>     
>
>     
>
>    public:
>      class value_compare
>      : public std::binary_function<value_type, value_type, bool>
>      {
> friend class map<_Key, _Tp, _Compare, _Alloc>;
>      protected:
> _Compare comp;
>
> value_compare(_Compare __c)
> : comp(__c) { }
>
>      public:
> bool operator()(const value_type& __x, const value_type& __y) const
> { return comp(__x.first, __y.first); }
>      };
>
>    private:
>
>      typedef typename _Alloc::template rebind<value_type>::other
>        _Pair_alloc_type;
>
>      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
>         key_compare, _Pair_alloc_type> _Rep_type;
>
>
>      _Rep_type _M_t;
>
>    public:
>
>
>      typedef typename _Pair_alloc_type::pointer pointer;
>      typedef typename _Pair_alloc_type::const_pointer const_pointer;
>      typedef typename _Pair_alloc_type::reference reference;
>      typedef typename _Pair_alloc_type::const_reference const_reference;
>      typedef typename _Rep_type::iterator iterator;
>      typedef typename _Rep_type::const_iterator const_iterator;
>      typedef typename _Rep_type::size_type size_type;
>      typedef typename _Rep_type::difference_type difference_type;
>      typedef typename _Rep_type::reverse_iterator reverse_iterator;
>      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
>
>
>
>
>
>
>
>      map()
>      : _M_t() { }
>
>
>
>
>
>
>      explicit
>      map(const _Compare& __comp,
>   const allocator_type& __a = allocator_type())
>      : _M_t(__comp, _Pair_alloc_type(__a)) { }
># 180 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      map(const map& __x)
>      : _M_t(__x._M_t) { }
># 223 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      template<typename _InputIterator>
>        map(_InputIterator __first, _InputIterator __last)
> : _M_t()
>        { _M_t._M_insert_unique(__first, __last); }
># 240 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      template<typename _InputIterator>
>        map(_InputIterator __first, _InputIterator __last,
>     const _Compare& __comp,
>     const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Pair_alloc_type(__a))
>        { _M_t._M_insert_unique(__first, __last); }
># 263 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      map&
>      operator=(const map& __x)
>      {
> _M_t = __x._M_t;
> return *this;
>      }
># 309 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      allocator_type
>      get_allocator() const
>      { return allocator_type(_M_t.get_allocator()); }
>
>
>
>
>
>
>
>      iterator
>      begin()
>      { return _M_t.begin(); }
>
>
>
>
>
>
>      const_iterator
>      begin() const
>      { return _M_t.begin(); }
>
>
>
>
>
>
>      iterator
>      end()
>      { return _M_t.end(); }
>
>
>
>
>
>
>      const_iterator
>      end() const
>      { return _M_t.end(); }
>
>
>
>
>
>
>      reverse_iterator
>      rbegin()
>      { return _M_t.rbegin(); }
>
>
>
>
>
>
>      const_reverse_iterator
>      rbegin() const
>      { return _M_t.rbegin(); }
>
>
>
>
>
>
>      reverse_iterator
>      rend()
>      { return _M_t.rend(); }
>
>
>
>
>
>
>      const_reverse_iterator
>      rend() const
>      { return _M_t.rend(); }
># 428 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      bool
>      empty() const
>      { return _M_t.empty(); }
>
>
>      size_type
>      size() const
>      { return _M_t.size(); }
>
>
>      size_type
>      max_size() const
>      { return _M_t.max_size(); }
># 455 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      mapped_type&
>      operator[](const key_type& __k)
>      {
>
>
>
> iterator __i = lower_bound(__k);
>
> if (__i == end() || key_comp()(__k, (*__i).first))
>
>
>
>
>
>          __i = insert(__i, value_type(__k, mapped_type()));
>
> return (*__i).second;
>      }
># 500 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      mapped_type&
>      at(const key_type& __k)
>      {
> iterator __i = lower_bound(__k);
> if (__i == end() || key_comp()(__k, (*__i).first))
>   __throw_out_of_range(("map::at"));
> return (*__i).second;
>      }
>
>      const mapped_type&
>      at(const key_type& __k) const
>      {
> const_iterator __i = lower_bound(__k);
> if (__i == end() || key_comp()(__k, (*__i).first))
>   __throw_out_of_range(("map::at"));
> return (*__i).second;
>      }
># 593 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      std::pair<iterator, bool>
>      insert(const value_type& __x)
>      { return _M_t._M_insert_unique(__x); }
># 642 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      iterator
>
>
>
>      insert(iterator __position, const value_type& __x)
>
>      { return _M_t._M_insert_unique_(__position, __x); }
># 668 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      template<typename _InputIterator>
>        void
>        insert(_InputIterator __first, _InputIterator __last)
>        { _M_t._M_insert_unique(__first, __last); }
># 708 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      void
>      erase(iterator __position)
>      { _M_t.erase(__position); }
># 724 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      size_type
>      erase(const key_type& __x)
>      { return _M_t.erase(__x); }
># 760 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      void
>      erase(iterator __first, iterator __last)
>      { _M_t.erase(__first, __last); }
># 776 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      void
>      swap(map& __x)
>      { _M_t.swap(__x._M_t); }
>
>
>
>
>
>
>
>      void
>      clear()
>      { _M_t.clear(); }
>
>
>
>
>
>
>      key_compare
>      key_comp() const
>      { return _M_t.key_comp(); }
>
>
>
>
>
>      value_compare
>      value_comp() const
>      { return value_compare(_M_t.key_comp()); }
># 819 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      iterator
>      find(const key_type& __x)
>      { return _M_t.find(__x); }
># 834 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      const_iterator
>      find(const key_type& __x) const
>      { return _M_t.find(__x); }
># 846 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      size_type
>      count(const key_type& __x) const
>      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
># 861 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      iterator
>      lower_bound(const key_type& __x)
>      { return _M_t.lower_bound(__x); }
># 876 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      const_iterator
>      lower_bound(const key_type& __x) const
>      { return _M_t.lower_bound(__x); }
>
>
>
>
>
>
>
>      iterator
>      upper_bound(const key_type& __x)
>      { return _M_t.upper_bound(__x); }
>
>
>
>
>
>
>
>      const_iterator
>      upper_bound(const key_type& __x) const
>      { return _M_t.upper_bound(__x); }
># 915 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      std::pair<iterator, iterator>
>      equal_range(const key_type& __x)
>      { return _M_t.equal_range(__x); }
># 934 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>      std::pair<const_iterator, const_iterator>
>      equal_range(const key_type& __x) const
>      { return _M_t.equal_range(__x); }
>
>      template<typename _K1, typename _T1, typename _C1, typename _A1>
>        friend bool
>        operator==(const map<_K1, _T1, _C1, _A1>&,
>     const map<_K1, _T1, _C1, _A1>&);
>
>      template<typename _K1, typename _T1, typename _C1, typename _A1>
>        friend bool
>        operator<(const map<_K1, _T1, _C1, _A1>&,
>    const map<_K1, _T1, _C1, _A1>&);
>    };
># 959 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
>               const map<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return __x._M_t == __y._M_t; }
># 976 "/usr/include/c++/4.8.0/bits/stl_map.h" 3
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
>              const map<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return __x._M_t < __y._M_t; }
>
>
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
>               const map<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return !(__x == __y); }
>
>
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
>              const map<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return __y < __x; }
>
>
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
>               const map<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return !(__y < __x); }
>
>
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
>               const map<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return !(__x < __y); }
>
>
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline void
>    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
>  map<_Key, _Tp, _Compare, _Alloc>& __y)
>    { __x.swap(__y); }
>
>
>}
># 62 "/usr/include/c++/4.8.0/map" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 1 3
># 64 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 92 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>  template <typename _Key, typename _Tp,
>     typename _Compare = std::less<_Key>,
>     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
>    class multimap
>    {
>    public:
>      typedef _Key key_type;
>      typedef _Tp mapped_type;
>      typedef std::pair<const _Key, _Tp> value_type;
>      typedef _Compare key_compare;
>      typedef _Alloc allocator_type;
>
>    private:
>
>      typedef typename _Alloc::value_type _Alloc_value_type;
>     
>     
>
>     
>
>    public:
>      class value_compare
>      : public std::binary_function<value_type, value_type, bool>
>      {
> friend class multimap<_Key, _Tp, _Compare, _Alloc>;
>      protected:
> _Compare comp;
>
> value_compare(_Compare __c)
> : comp(__c) { }
>
>      public:
> bool operator()(const value_type& __x, const value_type& __y) const
> { return comp(__x.first, __y.first); }
>      };
>
>    private:
>
>      typedef typename _Alloc::template rebind<value_type>::other
>        _Pair_alloc_type;
>
>      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
>         key_compare, _Pair_alloc_type> _Rep_type;
>
>      _Rep_type _M_t;
>
>    public:
>
>
>      typedef typename _Pair_alloc_type::pointer pointer;
>      typedef typename _Pair_alloc_type::const_pointer const_pointer;
>      typedef typename _Pair_alloc_type::reference reference;
>      typedef typename _Pair_alloc_type::const_reference const_reference;
>      typedef typename _Rep_type::iterator iterator;
>      typedef typename _Rep_type::const_iterator const_iterator;
>      typedef typename _Rep_type::size_type size_type;
>      typedef typename _Rep_type::difference_type difference_type;
>      typedef typename _Rep_type::reverse_iterator reverse_iterator;
>      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
>
>
>
>
>
>
>      multimap()
>      : _M_t() { }
>
>
>
>
>
>
>      explicit
>      multimap(const _Compare& __comp,
>        const allocator_type& __a = allocator_type())
>      : _M_t(__comp, _Pair_alloc_type(__a)) { }
># 177 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      multimap(const multimap& __x)
>      : _M_t(__x._M_t) { }
># 218 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      template<typename _InputIterator>
>        multimap(_InputIterator __first, _InputIterator __last)
> : _M_t()
>        { _M_t._M_insert_equal(__first, __last); }
># 234 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      template<typename _InputIterator>
>        multimap(_InputIterator __first, _InputIterator __last,
>   const _Compare& __comp,
>   const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Pair_alloc_type(__a))
>        { _M_t._M_insert_equal(__first, __last); }
># 257 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      multimap&
>      operator=(const multimap& __x)
>      {
> _M_t = __x._M_t;
> return *this;
>      }
># 303 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      allocator_type
>      get_allocator() const
>      { return allocator_type(_M_t.get_allocator()); }
>
>
>
>
>
>
>
>      iterator
>      begin()
>      { return _M_t.begin(); }
>
>
>
>
>
>
>      const_iterator
>      begin() const
>      { return _M_t.begin(); }
>
>
>
>
>
>
>      iterator
>      end()
>      { return _M_t.end(); }
>
>
>
>
>
>
>      const_iterator
>      end() const
>      { return _M_t.end(); }
>
>
>
>
>
>
>      reverse_iterator
>      rbegin()
>      { return _M_t.rbegin(); }
>
>
>
>
>
>
>      const_reverse_iterator
>      rbegin() const
>      { return _M_t.rbegin(); }
>
>
>
>
>
>
>      reverse_iterator
>      rend()
>      { return _M_t.rend(); }
>
>
>
>
>
>
>      const_reverse_iterator
>      rend() const
>      { return _M_t.rend(); }
># 420 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      bool
>      empty() const
>      { return _M_t.empty(); }
>
>
>      size_type
>      size() const
>      { return _M_t.size(); }
>
>
>      size_type
>      max_size() const
>      { return _M_t.max_size(); }
># 500 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      iterator
>      insert(const value_type& __x)
>      { return _M_t._M_insert_equal(__x); }
># 533 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      iterator
>
>
>
>      insert(iterator __position, const value_type& __x)
>
>      { return _M_t._M_insert_equal_(__position, __x); }
># 560 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      template<typename _InputIterator>
>        void
>        insert(_InputIterator __first, _InputIterator __last)
>        { _M_t._M_insert_equal(__first, __last); }
># 613 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      void
>      erase(iterator __position)
>      { _M_t.erase(__position); }
># 629 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      size_type
>      erase(const key_type& __x)
>      { return _M_t.erase(__x); }
># 669 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      void
>      erase(iterator __first, iterator __last)
>      { _M_t.erase(__first, __last); }
># 685 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      void
>      swap(multimap& __x)
>      { _M_t.swap(__x._M_t); }
>
>
>
>
>
>
>
>      void
>      clear()
>      { _M_t.clear(); }
>
>
>
>
>
>
>      key_compare
>      key_comp() const
>      { return _M_t.key_comp(); }
>
>
>
>
>
>      value_compare
>      value_comp() const
>      { return value_compare(_M_t.key_comp()); }
># 728 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      iterator
>      find(const key_type& __x)
>      { return _M_t.find(__x); }
># 743 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      const_iterator
>      find(const key_type& __x) const
>      { return _M_t.find(__x); }
>
>
>
>
>
>
>      size_type
>      count(const key_type& __x) const
>      { return _M_t.count(__x); }
># 767 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      iterator
>      lower_bound(const key_type& __x)
>      { return _M_t.lower_bound(__x); }
># 782 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      const_iterator
>      lower_bound(const key_type& __x) const
>      { return _M_t.lower_bound(__x); }
>
>
>
>
>
>
>
>      iterator
>      upper_bound(const key_type& __x)
>      { return _M_t.upper_bound(__x); }
>
>
>
>
>
>
>
>      const_iterator
>      upper_bound(const key_type& __x) const
>      { return _M_t.upper_bound(__x); }
># 819 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      std::pair<iterator, iterator>
>      equal_range(const key_type& __x)
>      { return _M_t.equal_range(__x); }
># 836 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>      std::pair<const_iterator, const_iterator>
>      equal_range(const key_type& __x) const
>      { return _M_t.equal_range(__x); }
>
>      template<typename _K1, typename _T1, typename _C1, typename _A1>
>        friend bool
>        operator==(const multimap<_K1, _T1, _C1, _A1>&,
>     const multimap<_K1, _T1, _C1, _A1>&);
>
>      template<typename _K1, typename _T1, typename _C1, typename _A1>
>        friend bool
>        operator<(const multimap<_K1, _T1, _C1, _A1>&,
>    const multimap<_K1, _T1, _C1, _A1>&);
>  };
># 861 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
>               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return __x._M_t == __y._M_t; }
># 878 "/usr/include/c++/4.8.0/bits/stl_multimap.h" 3
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
>              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return __x._M_t < __y._M_t; }
>
>
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
>               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return !(__x == __y); }
>
>
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
>              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return __y < __x; }
>
>
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
>               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return !(__y < __x); }
>
>
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline bool
>    operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
>               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
>    { return !(__x < __y); }
>
>
>  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
>    inline void
>    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
>         multimap<_Key, _Tp, _Compare, _Alloc>& __y)
>    { __x.swap(__y); }
>
>
>}
># 63 "/usr/include/c++/4.8.0/map" 2 3
># 1 "/usr/include/c++/4.8.0/bits/range_access.h" 1 3
># 33 "/usr/include/c++/4.8.0/bits/range_access.h" 3
>       
># 34 "/usr/include/c++/4.8.0/bits/range_access.h" 3
># 64 "/usr/include/c++/4.8.0/map" 2 3
># 10 "../src/CoinPackedVector.hpp" 2
>
># 1 "../src/CoinPragma.hpp" 1
># 12 "../src/CoinPackedVector.hpp" 2
># 1 "../src/CoinPackedVectorBase.hpp" 1
># 9 "../src/CoinPackedVectorBase.hpp"
># 1 "/usr/include/c++/4.8.0/set" 1 3
># 58 "/usr/include/c++/4.8.0/set" 3
>       
># 59 "/usr/include/c++/4.8.0/set" 3
>
>
># 1 "/usr/include/c++/4.8.0/bits/stl_set.h" 1 3
># 64 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 88 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>  template<typename _Key, typename _Compare = std::less<_Key>,
>    typename _Alloc = std::allocator<_Key> >
>    class set
>    {
>
>      typedef typename _Alloc::value_type _Alloc_value_type;
>     
>     
>
>     
>
>    public:
>
>
>
>      typedef _Key key_type;
>      typedef _Key value_type;
>      typedef _Compare key_compare;
>      typedef _Compare value_compare;
>      typedef _Alloc allocator_type;
>
>
>    private:
>      typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;
>
>      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
>         key_compare, _Key_alloc_type> _Rep_type;
>      _Rep_type _M_t;
>
>    public:
>
>
>      typedef typename _Key_alloc_type::pointer pointer;
>      typedef typename _Key_alloc_type::const_pointer const_pointer;
>      typedef typename _Key_alloc_type::reference reference;
>      typedef typename _Key_alloc_type::const_reference const_reference;
>
>
>
>      typedef typename _Rep_type::const_iterator iterator;
>      typedef typename _Rep_type::const_iterator const_iterator;
>      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
>      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
>      typedef typename _Rep_type::size_type size_type;
>      typedef typename _Rep_type::difference_type difference_type;
>
>
>
>
>
>
>      set()
>      : _M_t() { }
>
>
>
>
>
>
>      explicit
>      set(const _Compare& __comp,
>   const allocator_type& __a = allocator_type())
>      : _M_t(__comp, _Key_alloc_type(__a)) { }
># 162 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      template<typename _InputIterator>
> set(_InputIterator __first, _InputIterator __last)
> : _M_t()
> { _M_t._M_insert_unique(__first, __last); }
># 179 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      template<typename _InputIterator>
> set(_InputIterator __first, _InputIterator __last,
>     const _Compare& __comp,
>     const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Key_alloc_type(__a))
>        { _M_t._M_insert_unique(__first, __last); }
># 193 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      set(const set& __x)
>      : _M_t(__x._M_t) { }
># 232 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      set&
>      operator=(const set& __x)
>      {
> _M_t = __x._M_t;
> return *this;
>      }
># 280 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      key_compare
>      key_comp() const
>      { return _M_t.key_comp(); }
>
>      value_compare
>      value_comp() const
>      { return _M_t.key_comp(); }
>
>      allocator_type
>      get_allocator() const
>      { return allocator_type(_M_t.get_allocator()); }
>
>
>
>
>
>
>      iterator
>      begin() const
>      { return _M_t.begin(); }
>
>
>
>
>
>
>      iterator
>      end() const
>      { return _M_t.end(); }
>
>
>
>
>
>
>      reverse_iterator
>      rbegin() const
>      { return _M_t.rbegin(); }
>
>
>
>
>
>
>      reverse_iterator
>      rend() const
>      { return _M_t.rend(); }
># 367 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      bool
>      empty() const
>      { return _M_t.empty(); }
>
>
>      size_type
>      size() const
>      { return _M_t.size(); }
>
>
>      size_type
>      max_size() const
>      { return _M_t.max_size(); }
># 392 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      void
>      swap(set& __x)
>      { _M_t.swap(__x._M_t); }
># 459 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      std::pair<iterator, bool>
>      insert(const value_type& __x)
>      {
> std::pair<typename _Rep_type::iterator, bool> __p =
>   _M_t._M_insert_unique(__x);
> return std::pair<iterator, bool>(__p.first, __p.second);
>      }
># 496 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      iterator
>      insert(const_iterator __position, const value_type& __x)
>      { return _M_t._M_insert_unique_(__position, __x); }
># 515 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      template<typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t._M_insert_unique(__first, __last); }
># 563 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      void
>      erase(iterator __position)
>      { _M_t.erase(__position); }
># 579 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      size_type
>      erase(const key_type& __x)
>      { return _M_t.erase(__x); }
># 616 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      void
>      erase(iterator __first, iterator __last)
>      { _M_t.erase(__first, __last); }
># 627 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      void
>      clear()
>      { _M_t.clear(); }
># 641 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      size_type
>      count(const key_type& __x) const
>      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
># 659 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      iterator
>      find(const key_type& __x)
>      { return _M_t.find(__x); }
>
>      const_iterator
>      find(const key_type& __x) const
>      { return _M_t.find(__x); }
># 680 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      iterator
>      lower_bound(const key_type& __x)
>      { return _M_t.lower_bound(__x); }
>
>      const_iterator
>      lower_bound(const key_type& __x) const
>      { return _M_t.lower_bound(__x); }
># 696 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      iterator
>      upper_bound(const key_type& __x)
>      { return _M_t.upper_bound(__x); }
>
>      const_iterator
>      upper_bound(const key_type& __x) const
>      { return _M_t.upper_bound(__x); }
># 721 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>      std::pair<iterator, iterator>
>      equal_range(const key_type& __x)
>      { return _M_t.equal_range(__x); }
>
>      std::pair<const_iterator, const_iterator>
>      equal_range(const key_type& __x) const
>      { return _M_t.equal_range(__x); }
>
>
>      template<typename _K1, typename _C1, typename _A1>
> friend bool
> operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
>
>      template<typename _K1, typename _C1, typename _A1>
> friend bool
> operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
>    };
># 750 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator==(const set<_Key, _Compare, _Alloc>& __x,
>        const set<_Key, _Compare, _Alloc>& __y)
>    { return __x._M_t == __y._M_t; }
># 767 "/usr/include/c++/4.8.0/bits/stl_set.h" 3
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator<(const set<_Key, _Compare, _Alloc>& __x,
>       const set<_Key, _Compare, _Alloc>& __y)
>    { return __x._M_t < __y._M_t; }
>
>
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator!=(const set<_Key, _Compare, _Alloc>& __x,
>        const set<_Key, _Compare, _Alloc>& __y)
>    { return !(__x == __y); }
>
>
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator>(const set<_Key, _Compare, _Alloc>& __x,
>       const set<_Key, _Compare, _Alloc>& __y)
>    { return __y < __x; }
>
>
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator<=(const set<_Key, _Compare, _Alloc>& __x,
>        const set<_Key, _Compare, _Alloc>& __y)
>    { return !(__y < __x); }
>
>
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator>=(const set<_Key, _Compare, _Alloc>& __x,
>        const set<_Key, _Compare, _Alloc>& __y)
>    { return !(__x < __y); }
>
>
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline void
>    swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
>    { __x.swap(__y); }
>
>
>}
># 62 "/usr/include/c++/4.8.0/set" 2 3
># 1 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 1 3
># 64 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 90 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>  template <typename _Key, typename _Compare = std::less<_Key>,
>     typename _Alloc = std::allocator<_Key> >
>    class multiset
>    {
>
>      typedef typename _Alloc::value_type _Alloc_value_type;
>     
>     
>
>     
>
>    public:
>
>      typedef _Key key_type;
>      typedef _Key value_type;
>      typedef _Compare key_compare;
>      typedef _Compare value_compare;
>      typedef _Alloc allocator_type;
>
>    private:
>
>      typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;
>
>      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
>         key_compare, _Key_alloc_type> _Rep_type;
>
>      _Rep_type _M_t;
>
>    public:
>      typedef typename _Key_alloc_type::pointer pointer;
>      typedef typename _Key_alloc_type::const_pointer const_pointer;
>      typedef typename _Key_alloc_type::reference reference;
>      typedef typename _Key_alloc_type::const_reference const_reference;
>
>
>
>      typedef typename _Rep_type::const_iterator iterator;
>      typedef typename _Rep_type::const_iterator const_iterator;
>      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
>      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
>      typedef typename _Rep_type::size_type size_type;
>      typedef typename _Rep_type::difference_type difference_type;
>
>
>
>
>
>      multiset()
>      : _M_t() { }
>
>
>
>
>
>
>      explicit
>      multiset(const _Compare& __comp,
>        const allocator_type& __a = allocator_type())
>      : _M_t(__comp, _Key_alloc_type(__a)) { }
># 159 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      template<typename _InputIterator>
>        multiset(_InputIterator __first, _InputIterator __last)
> : _M_t()
>        { _M_t._M_insert_equal(__first, __last); }
># 175 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      template<typename _InputIterator>
>        multiset(_InputIterator __first, _InputIterator __last,
>   const _Compare& __comp,
>   const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Key_alloc_type(__a))
>        { _M_t._M_insert_equal(__first, __last); }
># 189 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      multiset(const multiset& __x)
>      : _M_t(__x._M_t) { }
># 228 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      multiset&
>      operator=(const multiset& __x)
>      {
> _M_t = __x._M_t;
> return *this;
>      }
># 277 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      key_compare
>      key_comp() const
>      { return _M_t.key_comp(); }
>
>      value_compare
>      value_comp() const
>      { return _M_t.key_comp(); }
>
>      allocator_type
>      get_allocator() const
>      { return allocator_type(_M_t.get_allocator()); }
>
>
>
>
>
>
>      iterator
>      begin() const
>      { return _M_t.begin(); }
>
>
>
>
>
>
>      iterator
>      end() const
>      { return _M_t.end(); }
>
>
>
>
>
>
>      reverse_iterator
>      rbegin() const
>      { return _M_t.rbegin(); }
>
>
>
>
>
>
>      reverse_iterator
>      rend() const
>      { return _M_t.rend(); }
># 364 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      bool
>      empty() const
>      { return _M_t.empty(); }
>
>
>      size_type
>      size() const
>      { return _M_t.size(); }
>
>
>      size_type
>      max_size() const
>      { return _M_t.max_size(); }
># 389 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      void
>      swap(multiset& __x)
>      { _M_t.swap(__x._M_t); }
># 453 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      iterator
>      insert(const value_type& __x)
>      { return _M_t._M_insert_equal(__x); }
># 483 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      iterator
>      insert(const_iterator __position, const value_type& __x)
>      { return _M_t._M_insert_equal_(__position, __x); }
># 501 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      template<typename _InputIterator>
>        void
>        insert(_InputIterator __first, _InputIterator __last)
>        { _M_t._M_insert_equal(__first, __last); }
># 549 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      void
>      erase(iterator __position)
>      { _M_t.erase(__position); }
># 565 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      size_type
>      erase(const key_type& __x)
>      { return _M_t.erase(__x); }
># 602 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      void
>      erase(iterator __first, iterator __last)
>      { _M_t.erase(__first, __last); }
># 613 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      void
>      clear()
>      { _M_t.clear(); }
># 624 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      size_type
>      count(const key_type& __x) const
>      { return _M_t.count(__x); }
># 642 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      iterator
>      find(const key_type& __x)
>      { return _M_t.find(__x); }
>
>      const_iterator
>      find(const key_type& __x) const
>      { return _M_t.find(__x); }
># 663 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      iterator
>      lower_bound(const key_type& __x)
>      { return _M_t.lower_bound(__x); }
>
>      const_iterator
>      lower_bound(const key_type& __x) const
>      { return _M_t.lower_bound(__x); }
># 679 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      iterator
>      upper_bound(const key_type& __x)
>      { return _M_t.upper_bound(__x); }
>
>      const_iterator
>      upper_bound(const key_type& __x) const
>      { return _M_t.upper_bound(__x); }
># 704 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>      std::pair<iterator, iterator>
>      equal_range(const key_type& __x)
>      { return _M_t.equal_range(__x); }
>
>      std::pair<const_iterator, const_iterator>
>      equal_range(const key_type& __x) const
>      { return _M_t.equal_range(__x); }
>
>
>      template<typename _K1, typename _C1, typename _A1>
>        friend bool
>        operator==(const multiset<_K1, _C1, _A1>&,
>     const multiset<_K1, _C1, _A1>&);
>
>      template<typename _K1, typename _C1, typename _A1>
>        friend bool
>        operator< (const multiset<_K1, _C1, _A1>&,
>     const multiset<_K1, _C1, _A1>&);
>    };
># 735 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator==(const multiset<_Key, _Compare, _Alloc>& __x,
>        const multiset<_Key, _Compare, _Alloc>& __y)
>    { return __x._M_t == __y._M_t; }
># 752 "/usr/include/c++/4.8.0/bits/stl_multiset.h" 3
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator<(const multiset<_Key, _Compare, _Alloc>& __x,
>       const multiset<_Key, _Compare, _Alloc>& __y)
>    { return __x._M_t < __y._M_t; }
>
>
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
>        const multiset<_Key, _Compare, _Alloc>& __y)
>    { return !(__x == __y); }
>
>
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator>(const multiset<_Key,_Compare,_Alloc>& __x,
>       const multiset<_Key,_Compare,_Alloc>& __y)
>    { return __y < __x; }
>
>
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
>        const multiset<_Key, _Compare, _Alloc>& __y)
>    { return !(__y < __x); }
>
>
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline bool
>    operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
>        const multiset<_Key, _Compare, _Alloc>& __y)
>    { return !(__x < __y); }
>
>
>  template<typename _Key, typename _Compare, typename _Alloc>
>    inline void
>    swap(multiset<_Key, _Compare, _Alloc>& __x,
>  multiset<_Key, _Compare, _Alloc>& __y)
>    { __x.swap(__y); }
>
>
>}
># 63 "/usr/include/c++/4.8.0/set" 2 3
># 10 "../src/CoinPackedVectorBase.hpp" 2
>
>
># 1 "../src/CoinError.hpp" 1
># 9 "../src/CoinError.hpp"
># 1 "/usr/include/c++/4.8.0/string" 1 3
># 36 "/usr/include/c++/4.8.0/string" 3
>       
># 37 "/usr/include/c++/4.8.0/string" 3
>
>
># 1 "/usr/include/c++/4.8.0/bits/stringfwd.h" 1 3
># 37 "/usr/include/c++/4.8.0/bits/stringfwd.h" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/stringfwd.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _Alloc>
>    class allocator;
>
>
>
>
>
>
>
>  template<class _CharT>
>    struct char_traits;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT>,
>           typename _Alloc = allocator<_CharT> >
>    class basic_string;
>
>  template<> struct char_traits<char>;
>
>  typedef basic_string<char> string;
>
>
>  template<> struct char_traits<wchar_t>;
>
>  typedef basic_string<wchar_t> wstring;
># 83 "/usr/include/c++/4.8.0/bits/stringfwd.h" 3
>
>}
># 40 "/usr/include/c++/4.8.0/string" 2 3
># 1 "/usr/include/c++/4.8.0/bits/char_traits.h" 1 3
># 37 "/usr/include/c++/4.8.0/bits/char_traits.h" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/char_traits.h" 3
>
>
># 1 "/usr/include/c++/4.8.0/bits/postypes.h" 1 3
># 38 "/usr/include/c++/4.8.0/bits/postypes.h" 3
>       
># 39 "/usr/include/c++/4.8.0/bits/postypes.h" 3
>
># 1 "/usr/include/c++/4.8.0/cwchar" 1 3
># 39 "/usr/include/c++/4.8.0/cwchar" 3
>       
># 40 "/usr/include/c++/4.8.0/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 36 "/usr/include/wchar.h" 3 4
># 1 "/usr/include/stdio.h" 1 3 4
># 44 "/usr/include/stdio.h" 3 4
>struct _IO_FILE;
>
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 64 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 37 "/usr/include/wchar.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stdarg.h" 1 3 4
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 40 "/usr/include/wchar.h" 2 3 4
>
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 22 "/usr/include/bits/wchar.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/wchar.h" 2 3 4
># 42 "/usr/include/wchar.h" 2 3 4
># 51 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stddef.h" 1 3 4
># 353 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stddef.h" 3 4
>typedef unsigned int wint_t;
># 52 "/usr/include/wchar.h" 2 3 4
># 82 "/usr/include/wchar.h" 3 4
>typedef struct
>{
>  int __count;
>  union
>  {
>
>    unsigned int __wch;
>
>
>
>    char __wchb[4];
>  } __value;
>} __mbstate_t;
># 104 "/usr/include/wchar.h" 3 4
>
>
>typedef __mbstate_t mbstate_t;
>
>
>
>
>
>
># 132 "/usr/include/wchar.h" 3 4
>extern "C" {
>
>
>
>
>struct tm;
>
>
>
>
>
>
>
>
>
>extern wchar_t *wcscpy (wchar_t *__restrict __dest,
>   const wchar_t *__restrict __src) throw ();
>
>extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
>    const wchar_t *__restrict __src, size_t __n)
>     throw ();
>
>
>extern wchar_t *wcscat (wchar_t *__restrict __dest,
>   const wchar_t *__restrict __src) throw ();
>
>extern wchar_t *wcsncat (wchar_t *__restrict __dest,
>    const wchar_t *__restrict __src, size_t __n)
>     throw ();
>
>
>extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
>     throw () __attribute__ ((__pure__));
>
>extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
>     throw () __attribute__ ((__pure__));
>
>
>
>
>extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
>
>
>extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
>   size_t __n) throw ();
>
>
>
>
>
>extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
>    __locale_t __loc) throw ();
>
>extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
>     size_t __n, __locale_t __loc) throw ();
>
>
>
>
>
>extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
>
>
>
>extern size_t wcsxfrm (wchar_t *__restrict __s1,
>         const wchar_t *__restrict __s2, size_t __n) throw ();
>
>
>
>
>
>
>
>
>extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
>        __locale_t __loc) throw ();
>
>
>
>
>extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
>    size_t __n, __locale_t __loc) throw ();
>
>
>extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
>
>
>
>
>
>extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
>     throw () __asm ("wcschr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
>     throw () __asm ("wcschr") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
>     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
>     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
>
>
>
>
>
>
>
>
>
>extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
>     throw () __attribute__ ((__pure__));
>
>
>
>
>
>extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
>     throw () __attribute__ ((__pure__));
>
>
>extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
>     throw () __attribute__ ((__pure__));
>
>
>extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
>     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
>         const wchar_t *__accept)
>     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
>     throw () __asm ("wcsstr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
>        const wchar_t *__needle)
>     throw () __asm ("wcsstr") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern wchar_t *wcstok (wchar_t *__restrict __s,
>   const wchar_t *__restrict __delim,
>   wchar_t **__restrict __ptr) throw ();
>
>
>extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
>
>
>
>
>
>extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
>     throw () __asm ("wcswcs") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
>        const wchar_t *__needle)
>     throw () __asm ("wcswcs") __attribute__ ((__pure__));
># 306 "/usr/include/wchar.h" 3 4
>extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
>     throw () __attribute__ ((__pure__));
>
>
>
>
>
>
>extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
>     throw () __asm ("wmemchr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
>         size_t __n)
>     throw () __asm ("wmemchr") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
>     throw () __attribute__ ((__pure__));
>
>
>extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
>    const wchar_t *__restrict __s2, size_t __n) throw ();
>
>
>
>extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
>     throw ();
>
>
>extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
>
>
>
>
>
>extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
>     const wchar_t *__restrict __s2, size_t __n)
>     throw ();
>
>
>
>
>
>
>extern wint_t btowc (int __c) throw ();
>
>
>
>extern int wctob (wint_t __c) throw ();
>
>
>
>extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
>
>
>
>extern size_t mbrtowc (wchar_t *__restrict __pwc,
>         const char *__restrict __s, size_t __n,
>         mbstate_t *__restrict __p) throw ();
>
>
>extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
>         mbstate_t *__restrict __ps) throw ();
>
>
>extern size_t __mbrlen (const char *__restrict __s, size_t __n,
>   mbstate_t *__restrict __ps) throw ();
>extern size_t mbrlen (const char *__restrict __s, size_t __n,
>        mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>
>
>
>extern wint_t __btowc_alias (int __c) __asm ("btowc");
>extern __inline __attribute__ ((__gnu_inline__)) wint_t
>__attribute__ ((__leaf__)) btowc (int __c) throw ()
>{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
>   ? (wint_t) __c : __btowc_alias (__c)); }
>
>extern int __wctob_alias (wint_t __c) __asm ("wctob");
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) wctob (wint_t __wc) throw ()
>{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
>   ? (int) __wc : __wctob_alias (__wc)); }
>
>extern __inline __attribute__ ((__gnu_inline__)) size_t
>__attribute__ ((__leaf__)) mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()
>
>{ return (__ps != __null
>   ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }
>
>
>
>
>
>extern size_t mbsrtowcs (wchar_t *__restrict __dst,
>    const char **__restrict __src, size_t __len,
>    mbstate_t *__restrict __ps) throw ();
>
>
>
>extern size_t wcsrtombs (char *__restrict __dst,
>    const wchar_t **__restrict __src, size_t __len,
>    mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>
>extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
>     const char **__restrict __src, size_t __nmc,
>     size_t __len, mbstate_t *__restrict __ps) throw ();
>
>
>
>extern size_t wcsnrtombs (char *__restrict __dst,
>     const wchar_t **__restrict __src,
>     size_t __nwc, size_t __len,
>     mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>
>extern int wcwidth (wchar_t __c) throw ();
>
>
>
>extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
>
>
>
>
>
>
>extern double wcstod (const wchar_t *__restrict __nptr,
>        wchar_t **__restrict __endptr) throw ();
>
>
>
>
>
>extern float wcstof (const wchar_t *__restrict __nptr,
>       wchar_t **__restrict __endptr) throw ();
>extern long double wcstold (const wchar_t *__restrict __nptr,
>       wchar_t **__restrict __endptr) throw ();
>
>
>
>
>
>
>
>extern long int wcstol (const wchar_t *__restrict __nptr,
>   wchar_t **__restrict __endptr, int __base) throw ();
>
>
>
>extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
>      wchar_t **__restrict __endptr, int __base)
>     throw ();
>
>
>
>
>
>
>__extension__
>extern long long int wcstoll (const wchar_t *__restrict __nptr,
>         wchar_t **__restrict __endptr, int __base)
>     throw ();
>
>
>
>__extension__
>extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
>     wchar_t **__restrict __endptr,
>     int __base) throw ();
>
>
>
>
>
>
>__extension__
>extern long long int wcstoq (const wchar_t *__restrict __nptr,
>        wchar_t **__restrict __endptr, int __base)
>     throw ();
>
>
>
>__extension__
>extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
>           wchar_t **__restrict __endptr,
>           int __base) throw ();
># 530 "/usr/include/wchar.h" 3 4
>extern long int wcstol_l (const wchar_t *__restrict __nptr,
>     wchar_t **__restrict __endptr, int __base,
>     __locale_t __loc) throw ();
>
>extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
>        wchar_t **__restrict __endptr,
>        int __base, __locale_t __loc) throw ();
>
>__extension__
>extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
>    wchar_t **__restrict __endptr,
>    int __base, __locale_t __loc) throw ();
>
>__extension__
>extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
>       wchar_t **__restrict __endptr,
>       int __base, __locale_t __loc)
>     throw ();
>
>extern double wcstod_l (const wchar_t *__restrict __nptr,
>   wchar_t **__restrict __endptr, __locale_t __loc)
>     throw ();
>
>extern float wcstof_l (const wchar_t *__restrict __nptr,
>         wchar_t **__restrict __endptr, __locale_t __loc)
>     throw ();
>
>extern long double wcstold_l (const wchar_t *__restrict __nptr,
>         wchar_t **__restrict __endptr,
>         __locale_t __loc) throw ();
>
>
>
>
>
>
>extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
>   const wchar_t *__restrict __src) throw ();
>
>
>
>extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
>    const wchar_t *__restrict __src, size_t __n)
>     throw ();
>
>
>
>
>
>
>extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
>
>
>
>
>
>
>extern int fwide (__FILE *__fp, int __mode) throw ();
>
>
>
>
>
>
>extern int fwprintf (__FILE *__restrict __stream,
>       const wchar_t *__restrict __format, ...)
>                                                           ;
>
>
>
>
>extern int wprintf (const wchar_t *__restrict __format, ...)
>                                                           ;
>
>extern int swprintf (wchar_t *__restrict __s, size_t __n,
>       const wchar_t *__restrict __format, ...)
>     throw () ;
>
>
>
>
>
>extern int vfwprintf (__FILE *__restrict __s,
>        const wchar_t *__restrict __format,
>        __gnuc_va_list __arg)
>                                                           ;
>
>
>
>
>extern int vwprintf (const wchar_t *__restrict __format,
>       __gnuc_va_list __arg)
>                                                           ;
>
>
>extern int vswprintf (wchar_t *__restrict __s, size_t __n,
>        const wchar_t *__restrict __format,
>        __gnuc_va_list __arg)
>     throw () ;
>
>
>
>
>
>
>extern int fwscanf (__FILE *__restrict __stream,
>      const wchar_t *__restrict __format, ...)
>                                                          ;
>
>
>
>
>extern int wscanf (const wchar_t *__restrict __format, ...)
>                                                          ;
>
>extern int swscanf (const wchar_t *__restrict __s,
>      const wchar_t *__restrict __format, ...)
>     throw () ;
># 680 "/usr/include/wchar.h" 3 4
>
>
>
>
>
>
>
>
>
>extern int vfwscanf (__FILE *__restrict __s,
>       const wchar_t *__restrict __format,
>       __gnuc_va_list __arg)
>                                                          ;
>
>
>
>
>extern int vwscanf (const wchar_t *__restrict __format,
>      __gnuc_va_list __arg)
>                                                          ;
>
>extern int vswscanf (const wchar_t *__restrict __s,
>       const wchar_t *__restrict __format,
>       __gnuc_va_list __arg)
>     throw () ;
># 736 "/usr/include/wchar.h" 3 4
>
>
>
>
>
>
>
>
>
>extern wint_t fgetwc (__FILE *__stream);
>extern wint_t getwc (__FILE *__stream);
>
>
>
>
>
>extern wint_t getwchar (void);
>
>
>
>
>
>
>extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
>extern wint_t putwc (wchar_t __wc, __FILE *__stream);
>
>
>
>
>
>extern wint_t putwchar (wchar_t __wc);
>
>
>
>
>
>
>
>extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
>   __FILE *__restrict __stream);
>
>
>
>
>
>extern int fputws (const wchar_t *__restrict __ws,
>     __FILE *__restrict __stream);
>
>
>
>
>
>
>extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
>
># 801 "/usr/include/wchar.h" 3 4
>extern wint_t getwc_unlocked (__FILE *__stream);
>extern wint_t getwchar_unlocked (void);
>
>
>
>
>
>
>
>extern wint_t fgetwc_unlocked (__FILE *__stream);
>
>
>
>
>
>
>
>extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
># 827 "/usr/include/wchar.h" 3 4
>extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
>extern wint_t putwchar_unlocked (wchar_t __wc);
># 837 "/usr/include/wchar.h" 3 4
>extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
>     __FILE *__restrict __stream);
>
>
>
>
>
>
>
>extern int fputws_unlocked (const wchar_t *__restrict __ws,
>       __FILE *__restrict __stream);
>
>
>
>
>
>
>
>extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
>   const wchar_t *__restrict __format,
>   const struct tm *__restrict __tp) throw ();
>
>
>
>
>
>
>
>extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
>     const wchar_t *__restrict __format,
>     const struct tm *__restrict __tp,
>     __locale_t __loc) throw ();
># 884 "/usr/include/wchar.h" 3 4
># 1 "/usr/include/bits/wchar2.h" 1 3 4
># 24 "/usr/include/bits/wchar2.h" 3 4
>extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
>          const wchar_t *__restrict __s2, size_t __n,
>          size_t __ns1) throw ();
>extern wchar_t *__wmemcpy_alias (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmemcpy")
>
>
>            ;
>extern wchar_t *__wmemcpy_chk_warn (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemcpy_chk")
>
>
>
>     __attribute__((__warning__ ("wmemcpy called with length bigger than size of destination " "buffer")))
>            ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
>__attribute__ ((__leaf__)) wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw ()
>
>{
>  if (__builtin_object_size (__s1, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n))
> return __wmemcpy_chk (__s1, __s2, __n,
>         __builtin_object_size (__s1, 0) / sizeof (wchar_t));
>
>      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
> return __wmemcpy_chk_warn (__s1, __s2, __n,
>       __builtin_object_size (__s1, 0) / sizeof (wchar_t));
>    }
>  return __wmemcpy_alias (__s1, __s2, __n);
>}
>
>
>extern wchar_t *__wmemmove_chk (wchar_t *__s1, const wchar_t *__s2,
>    size_t __n, size_t __ns1) throw ();
>extern wchar_t *__wmemmove_alias (wchar_t *__s1, const wchar_t *__s2, size_t __n) throw () __asm__ ("" "wmemmove")
>
>                               ;
>extern wchar_t *__wmemmove_chk_warn (wchar_t *__s1, const wchar_t *__s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemmove_chk")
>
>
>     __attribute__((__warning__ ("wmemmove called with length bigger than size of destination " "buffer")))
>            ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
>__attribute__ ((__leaf__)) wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) throw ()
>{
>  if (__builtin_object_size (__s1, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n))
> return __wmemmove_chk (__s1, __s2, __n,
>          __builtin_object_size (__s1, 0) / sizeof (wchar_t));
>
>      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
> return __wmemmove_chk_warn (__s1, __s2, __n,
>        __builtin_object_size (__s1, 0) / sizeof (wchar_t));
>    }
>  return __wmemmove_alias (__s1, __s2, __n);
>}
>
>
>
>extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
>    const wchar_t *__restrict __s2, size_t __n,
>    size_t __ns1) throw ();
>extern wchar_t *__wmempcpy_alias (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmempcpy")
>
>
>                           ;
>extern wchar_t *__wmempcpy_chk_warn (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmempcpy_chk")
>
>
>
>     __attribute__((__warning__ ("wmempcpy called with length bigger than size of destination " "buffer")))
>            ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
>__attribute__ ((__leaf__)) wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw ()
>
>{
>  if (__builtin_object_size (__s1, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n))
> return __wmempcpy_chk (__s1, __s2, __n,
>          __builtin_object_size (__s1, 0) / sizeof (wchar_t));
>
>      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
> return __wmempcpy_chk_warn (__s1, __s2, __n,
>        __builtin_object_size (__s1, 0) / sizeof (wchar_t));
>    }
>  return __wmempcpy_alias (__s1, __s2, __n);
>}
>
>
>
>extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
>          size_t __ns) throw ();
>extern wchar_t *__wmemset_alias (wchar_t *__s, wchar_t __c, size_t __n) throw () __asm__ ("" "wmemset")
>                             ;
>extern wchar_t *__wmemset_chk_warn (wchar_t *__s, wchar_t __c, size_t __n, size_t __ns) throw () __asm__ ("" "__wmemset_chk")
>
>
>     __attribute__((__warning__ ("wmemset called with length bigger than size of destination " "buffer")))
>            ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
>__attribute__ ((__leaf__)) wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ()
>{
>  if (__builtin_object_size (__s, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n))
> return __wmemset_chk (__s, __c, __n, __builtin_object_size (__s, 0) / sizeof (wchar_t));
>
>      if (__n > __builtin_object_size (__s, 0) / sizeof (wchar_t))
> return __wmemset_chk_warn (__s, __c, __n,
>       __builtin_object_size (__s, 0) / sizeof (wchar_t));
>    }
>  return __wmemset_alias (__s, __c, __n);
>}
>
>
>extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
>         const wchar_t *__restrict __src,
>         size_t __n) throw ();
>extern wchar_t *__wcscpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __asm__ ("" "wcscpy")
>
>                                              ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
>__attribute__ ((__leaf__)) wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw ()
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
>    return __wcscpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
>  return __wcscpy_alias (__dest, __src);
>}
>
>
>extern wchar_t *__wcpcpy_chk (wchar_t *__restrict __dest,
>         const wchar_t *__restrict __src,
>         size_t __destlen) throw ();
>extern wchar_t *__wcpcpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __asm__ ("" "wcpcpy")
>
>                                              ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
>__attribute__ ((__leaf__)) wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw ()
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
>    return __wcpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
>  return __wcpcpy_alias (__dest, __src);
>}
>
>
>extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
>          const wchar_t *__restrict __src, size_t __n,
>          size_t __destlen) throw ();
>extern wchar_t *__wcsncpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncpy")
>
>
>                          ;
>extern wchar_t *__wcsncpy_chk_warn (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcsncpy_chk")
>
>
>
>     __attribute__((__warning__ ("wcsncpy called with length bigger than size of destination " "buffer")))
>            ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
>__attribute__ ((__leaf__)) wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw ()
>
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n))
> return __wcsncpy_chk (__dest, __src, __n,
>         __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
>      if (__n > __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t))
> return __wcsncpy_chk_warn (__dest, __src, __n,
>       __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
>    }
>  return __wcsncpy_alias (__dest, __src, __n);
>}
>
>
>extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
>          const wchar_t *__restrict __src, size_t __n,
>          size_t __destlen) throw ();
>extern wchar_t *__wcpncpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcpncpy")
>
>
>                          ;
>extern wchar_t *__wcpncpy_chk_warn (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcpncpy_chk")
>
>
>
>     __attribute__((__warning__ ("wcpncpy called with length bigger than size of destination " "buffer")))
>            ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
>__attribute__ ((__leaf__)) wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw ()
>
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n))
> return __wcpncpy_chk (__dest, __src, __n,
>         __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
>      if (__n > __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t))
> return __wcpncpy_chk_warn (__dest, __src, __n,
>       __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
>    }
>  return __wcpncpy_alias (__dest, __src, __n);
>}
>
>
>extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
>         const wchar_t *__restrict __src,
>         size_t __destlen) throw ();
>extern wchar_t *__wcscat_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __asm__ ("" "wcscat")
>
>                                              ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
>__attribute__ ((__leaf__)) wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw ()
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
>    return __wcscat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
>  return __wcscat_alias (__dest, __src);
>}
>
>
>extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
>          const wchar_t *__restrict __src,
>          size_t __n, size_t __destlen) throw ();
>extern wchar_t *__wcsncat_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncat")
>
>
>                          ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
>__attribute__ ((__leaf__)) wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw ()
>
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
>    return __wcsncat_chk (__dest, __src, __n,
>     __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
>  return __wcsncat_alias (__dest, __src, __n);
>}
>
>
>extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
>      int __flag, size_t __s_len,
>      const wchar_t *__restrict __format, ...)
>     throw () ;
>
>extern int __swprintf_alias (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, ...) throw () __asm__ ("" "swprintf")
>
>
>             ;
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__leaf__)) swprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, ...) throw ()
>
>{
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 || 2 > 1)
>    return __swprintf_chk (__s, __n, 2 - 1,
>      __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
>      __fmt, __builtin_va_arg_pack ());
>  return __swprintf_alias (__s, __n, __fmt, __builtin_va_arg_pack ());
>}
># 303 "/usr/include/bits/wchar2.h" 3 4
>extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
>       int __flag, size_t __s_len,
>       const wchar_t *__restrict __format,
>       __gnuc_va_list __arg)
>     throw () ;
>
>extern int __vswprintf_alias (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw () __asm__ ("" "vswprintf")
>
>
>                                     ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__leaf__)) vswprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw ()
>
>{
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 || 2 > 1)
>    return __vswprintf_chk (__s, __n, 2 - 1,
>       __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t), __fmt, __ap);
>  return __vswprintf_alias (__s, __n, __fmt, __ap);
>}
>
>
>
>
>extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
>      const wchar_t *__restrict __format, ...);
>extern int __wprintf_chk (int __flag, const wchar_t *__restrict __format,
>     ...);
>extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
>       const wchar_t *__restrict __format,
>       __gnuc_va_list __ap);
>extern int __vwprintf_chk (int __flag, const wchar_t *__restrict __format,
>      __gnuc_va_list __ap);
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
>wprintf (const wchar_t *__restrict __fmt, ...)
>{
>  return __wprintf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
>fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...)
>{
>  return __fwprintf_chk (__stream, 2 - 1, __fmt,
>    __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
>vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
>{
>  return __vwprintf_chk (2 - 1, __fmt, __ap);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
>vfwprintf (__FILE *__restrict __stream,
>    const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
>{
>  return __vfwprintf_chk (__stream, 2 - 1, __fmt, __ap);
>}
>
>
>
>extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
>         __FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern wchar_t *__fgetws_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws")
>
>                                              __attribute__ ((__warn_unused_result__));
>extern wchar_t *__fgetws_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws called with bigger size than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
>fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n) || __n <= 0)
> return __fgetws_chk (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
>        __n, __stream);
>
>      if ((size_t) __n > __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t))
> return __fgetws_chk_warn (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
>      __n, __stream);
>    }
>  return __fgetws_alias (__s, __n, __stream);
>}
>
>
>extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
>           int __n, __FILE *__restrict __stream)
>  __attribute__ ((__warn_unused_result__));
>extern wchar_t *__fgetws_unlocked_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws_unlocked")
>
>
>  __attribute__ ((__warn_unused_result__));
>extern wchar_t *__fgetws_unlocked_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_unlocked_chk")
>
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws_unlocked called with bigger size than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
>fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n) || __n <= 0)
> return __fgetws_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
>          __n, __stream);
>
>      if ((size_t) __n > __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t))
> return __fgetws_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
>        __n, __stream);
>    }
>  return __fgetws_unlocked_alias (__s, __n, __stream);
>}
>
>
>
>extern size_t __wcrtomb_chk (char *__restrict __s, wchar_t __wchar,
>        mbstate_t *__restrict __p,
>        size_t __buflen) throw () __attribute__ ((__warn_unused_result__));
>extern size_t __wcrtomb_alias (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcrtomb")
>
>                                                __attribute__ ((__warn_unused_result__));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
>__attribute__ ((__leaf__)) wcrtomb (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) throw ()
>
>{
>
>
>
>
>
>
>
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
>    return __wcrtomb_chk (__s, __wchar, __ps, __builtin_object_size (__s, 2 > 1));
>  return __wcrtomb_alias (__s, __wchar, __ps);
>}
>
>
>extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
>          const char **__restrict __src,
>          size_t __len, mbstate_t *__restrict __ps,
>          size_t __dstlen) throw ();
>extern size_t __mbsrtowcs_alias (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsrtowcs")
>
>
>
>                   ;
>extern size_t __mbsrtowcs_chk_warn (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsrtowcs_chk")
>
>
>
>
>     __attribute__((__warning__ ("mbsrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
>                        ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__leaf__)) mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __mbsrtowcs_chk (__dst, __src, __len, __ps,
>    __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>
>      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
> return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps,
>         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>    }
>  return __mbsrtowcs_alias (__dst, __src, __len, __ps);
>}
>
>
>extern size_t __wcsrtombs_chk (char *__restrict __dst,
>          const wchar_t **__restrict __src,
>          size_t __len, mbstate_t *__restrict __ps,
>          size_t __dstlen) throw ();
>extern size_t __wcsrtombs_alias (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsrtombs")
>
>
>
>                   ;
>extern size_t __wcsrtombs_chk_warn (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsrtombs_chk")
>
>
>
>
>    __attribute__((__warning__ ("wcsrtombs called with dst buffer smaller than len")));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__leaf__)) wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __wcsrtombs_chk (__dst, __src, __len, __ps, __builtin_object_size (__dst, 2 > 1));
>
>      if (__len > __builtin_object_size (__dst, 2 > 1))
> return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __builtin_object_size (__dst, 2 > 1));
>    }
>  return __wcsrtombs_alias (__dst, __src, __len, __ps);
>}
>
>
>
>extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
>    const char **__restrict __src, size_t __nmc,
>    size_t __len, mbstate_t *__restrict __ps,
>    size_t __dstlen) throw ();
>extern size_t __mbsnrtowcs_alias (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsnrtowcs")
>
>
>
>                    ;
>extern size_t __mbsnrtowcs_chk_warn (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsnrtowcs_chk")
>
>
>
>
>     __attribute__((__warning__ ("mbsnrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
>                        ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__leaf__)) mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw ()
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
>     __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>
>      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
> return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps,
>          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>    }
>  return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);
>}
>
>
>extern size_t __wcsnrtombs_chk (char *__restrict __dst,
>    const wchar_t **__restrict __src,
>    size_t __nwc, size_t __len,
>    mbstate_t *__restrict __ps, size_t __dstlen)
>     throw ();
>extern size_t __wcsnrtombs_alias (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsnrtombs")
>
>
>
>                                                  ;
>extern size_t __wcsnrtombs_chk_warn (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsnrtombs_chk")
>
>
>
>
>
>     __attribute__((__warning__ ("wcsnrtombs called with dst buffer smaller than len")));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__leaf__)) wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw ()
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps,
>     __builtin_object_size (__dst, 2 > 1));
>
>      if (__len > __builtin_object_size (__dst, 2 > 1))
> return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps,
>          __builtin_object_size (__dst, 2 > 1));
>    }
>  return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);
>}
># 885 "/usr/include/wchar.h" 2 3 4
>
>
>
>
>
>
>}
># 45 "/usr/include/c++/4.8.0/cwchar" 2 3
># 62 "/usr/include/c++/4.8.0/cwchar" 3
>namespace std
>{
>  using ::mbstate_t;
>}
># 135 "/usr/include/c++/4.8.0/cwchar" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  using ::wint_t;
>
>  using ::btowc;
>  using ::fgetwc;
>  using ::fgetws;
>  using ::fputwc;
>  using ::fputws;
>  using ::fwide;
>  using ::fwprintf;
>  using ::fwscanf;
>  using ::getwc;
>  using ::getwchar;
>  using ::mbrlen;
>  using ::mbrtowc;
>  using ::mbsinit;
>  using ::mbsrtowcs;
>  using ::putwc;
>  using ::putwchar;
>
>  using ::swprintf;
>
>  using ::swscanf;
>  using ::ungetwc;
>  using ::vfwprintf;
>
>  using ::vfwscanf;
>
>
>  using ::vswprintf;
>
>
>  using ::vswscanf;
>
>  using ::vwprintf;
>
>  using ::vwscanf;
>
>  using ::wcrtomb;
>  using ::wcscat;
>  using ::wcscmp;
>  using ::wcscoll;
>  using ::wcscpy;
>  using ::wcscspn;
>  using ::wcsftime;
>  using ::wcslen;
>  using ::wcsncat;
>  using ::wcsncmp;
>  using ::wcsncpy;
>  using ::wcsrtombs;
>  using ::wcsspn;
>  using ::wcstod;
>
>  using ::wcstof;
>
>  using ::wcstok;
>  using ::wcstol;
>  using ::wcstoul;
>  using ::wcsxfrm;
>  using ::wctob;
>  using ::wmemcmp;
>  using ::wmemcpy;
>  using ::wmemmove;
>  using ::wmemset;
>  using ::wprintf;
>  using ::wscanf;
>  using ::wcschr;
>  using ::wcspbrk;
>  using ::wcsrchr;
>  using ::wcsstr;
>  using ::wmemchr;
># 232 "/usr/include/c++/4.8.0/cwchar" 3
>
>}
>
>
>
>
>
>
>
>namespace __gnu_cxx
>{
>
>
>
>
>
>  using ::wcstold;
># 257 "/usr/include/c++/4.8.0/cwchar" 3
>  using ::wcstoll;
>  using ::wcstoull;
>
>}
>
>namespace std
>{
>  using ::__gnu_cxx::wcstold;
>  using ::__gnu_cxx::wcstoll;
>  using ::__gnu_cxx::wcstoull;
>}
># 41 "/usr/include/c++/4.8.0/bits/postypes.h" 2 3
># 68 "/usr/include/c++/4.8.0/bits/postypes.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 88 "/usr/include/c++/4.8.0/bits/postypes.h" 3
>  typedef long streamoff;
># 98 "/usr/include/c++/4.8.0/bits/postypes.h" 3
>  typedef ptrdiff_t streamsize;
># 111 "/usr/include/c++/4.8.0/bits/postypes.h" 3
>  template<typename _StateT>
>    class fpos
>    {
>    private:
>      streamoff _M_off;
>      _StateT _M_state;
>
>    public:
>
>
>
>
>      fpos()
>      : _M_off(0), _M_state() { }
># 133 "/usr/include/c++/4.8.0/bits/postypes.h" 3
>      fpos(streamoff __off)
>      : _M_off(__off), _M_state() { }
>
>
>      operator streamoff() const { return _M_off; }
>
>
>      void
>      state(_StateT __st)
>      { _M_state = __st; }
>
>
>      _StateT
>      state() const
>      { return _M_state; }
>
>
>
>
>
>      fpos&
>      operator+=(streamoff __off)
>      {
> _M_off += __off;
> return *this;
>      }
>
>
>
>
>
>      fpos&
>      operator-=(streamoff __off)
>      {
> _M_off -= __off;
> return *this;
>      }
>
>
>
>
>
>
>
>      fpos
>      operator+(streamoff __off) const
>      {
> fpos __pos(*this);
> __pos += __off;
> return __pos;
>      }
>
>
>
>
>
>
>
>      fpos
>      operator-(streamoff __off) const
>      {
> fpos __pos(*this);
> __pos -= __off;
> return __pos;
>      }
>
>
>
>
>
>
>      streamoff
>      operator-(const fpos& __other) const
>      { return _M_off - __other._M_off; }
>    };
>
>
>
>
>
>
>  template<typename _StateT>
>    inline bool
>    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
>    { return streamoff(__lhs) == streamoff(__rhs); }
>
>  template<typename _StateT>
>    inline bool
>    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
>    { return streamoff(__lhs) != streamoff(__rhs); }
>
>
>
>
>
>  typedef fpos<mbstate_t> streampos;
>
>  typedef fpos<mbstate_t> wstreampos;
># 239 "/usr/include/c++/4.8.0/bits/postypes.h" 3
>
>}
># 41 "/usr/include/c++/4.8.0/bits/char_traits.h" 2 3
># 1 "/usr/include/c++/4.8.0/cwchar" 1 3
># 39 "/usr/include/c++/4.8.0/cwchar" 3
>       
># 40 "/usr/include/c++/4.8.0/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 45 "/usr/include/c++/4.8.0/cwchar" 2 3
># 42 "/usr/include/c++/4.8.0/bits/char_traits.h" 2 3
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 57 "/usr/include/c++/4.8.0/bits/char_traits.h" 3
>  template<typename _CharT>
>    struct _Char_types
>    {
>      typedef unsigned long int_type;
>      typedef std::streampos pos_type;
>      typedef std::streamoff off_type;
>      typedef std::mbstate_t state_type;
>    };
># 82 "/usr/include/c++/4.8.0/bits/char_traits.h" 3
>  template<typename _CharT>
>    struct char_traits
>    {
>      typedef _CharT char_type;
>      typedef typename _Char_types<_CharT>::int_type int_type;
>      typedef typename _Char_types<_CharT>::pos_type pos_type;
>      typedef typename _Char_types<_CharT>::off_type off_type;
>      typedef typename _Char_types<_CharT>::state_type state_type;
>
>      static void
>      assign(char_type& __c1, const char_type& __c2)
>      { __c1 = __c2; }
>
>      static bool
>      eq(const char_type& __c1, const char_type& __c2)
>      { return __c1 == __c2; }
>
>      static bool
>      lt(const char_type& __c1, const char_type& __c2)
>      { return __c1 < __c2; }
>
>      static int
>      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
>
>      static std::size_t
>      length(const char_type* __s);
>
>      static const char_type*
>      find(const char_type* __s, std::size_t __n, const char_type& __a);
>
>      static char_type*
>      move(char_type* __s1, const char_type* __s2, std::size_t __n);
>
>      static char_type*
>      copy(char_type* __s1, const char_type* __s2, std::size_t __n);
>
>      static char_type*
>      assign(char_type* __s, std::size_t __n, char_type __a);
>
>      static char_type
>      to_char_type(const int_type& __c)
>      { return static_cast<char_type>(__c); }
>
>      static int_type
>      to_int_type(const char_type& __c)
>      { return static_cast<int_type>(__c); }
>
>      static bool
>      eq_int_type(const int_type& __c1, const int_type& __c2)
>      { return __c1 == __c2; }
>
>      static int_type
>      eof()
>      { return static_cast<int_type>(-1); }
>
>      static int_type
>      not_eof(const int_type& __c)
>      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
>    };
>
>  template<typename _CharT>
>    int
>    char_traits<_CharT>::
>    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
>    {
>      for (std::size_t __i = 0; __i < __n; ++__i)
> if (lt(__s1[__i], __s2[__i]))
>   return -1;
> else if (lt(__s2[__i], __s1[__i]))
>   return 1;
>      return 0;
>    }
>
>  template<typename _CharT>
>    std::size_t
>    char_traits<_CharT>::
>    length(const char_type* __p)
>    {
>      std::size_t __i = 0;
>      while (!eq(__p[__i], char_type()))
>        ++__i;
>      return __i;
>    }
>
>  template<typename _CharT>
>    const typename char_traits<_CharT>::char_type*
>    char_traits<_CharT>::
>    find(const char_type* __s, std::size_t __n, const char_type& __a)
>    {
>      for (std::size_t __i = 0; __i < __n; ++__i)
>        if (eq(__s[__i], __a))
>          return __s + __i;
>      return 0;
>    }
>
>  template<typename _CharT>
>    typename char_traits<_CharT>::char_type*
>    char_traits<_CharT>::
>    move(char_type* __s1, const char_type* __s2, std::size_t __n)
>    {
>      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
>          __n * sizeof(char_type)));
>    }
>
>  template<typename _CharT>
>    typename char_traits<_CharT>::char_type*
>    char_traits<_CharT>::
>    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
>    {
>
>      std::copy(__s2, __s2 + __n, __s1);
>      return __s1;
>    }
>
>  template<typename _CharT>
>    typename char_traits<_CharT>::char_type*
>    char_traits<_CharT>::
>    assign(char_type* __s, std::size_t __n, char_type __a)
>    {
>
>      std::fill_n(__s, __n, __a);
>      return __s;
>    }
>
>
>}
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 226 "/usr/include/c++/4.8.0/bits/char_traits.h" 3
>  template<class _CharT>
>    struct char_traits : public __gnu_cxx::char_traits<_CharT>
>    { };
>
>
>
>  template<>
>    struct char_traits<char>
>    {
>      typedef char char_type;
>      typedef int int_type;
>      typedef streampos pos_type;
>      typedef streamoff off_type;
>      typedef mbstate_t state_type;
>
>      static void
>      assign(char_type& __c1, const char_type& __c2)
>      { __c1 = __c2; }
>
>      static bool
>      eq(const char_type& __c1, const char_type& __c2)
>      { return __c1 == __c2; }
>
>      static bool
>      lt(const char_type& __c1, const char_type& __c2)
>      { return __c1 < __c2; }
>
>      static int
>      compare(const char_type* __s1, const char_type* __s2, size_t __n)
>      { return __builtin_memcmp(__s1, __s2, __n); }
>
>      static size_t
>      length(const char_type* __s)
>      { return __builtin_strlen(__s); }
>
>      static const char_type*
>      find(const char_type* __s, size_t __n, const char_type& __a)
>      { return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }
>
>      static char_type*
>      move(char_type* __s1, const char_type* __s2, size_t __n)
>      { return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
>
>      static char_type*
>      copy(char_type* __s1, const char_type* __s2, size_t __n)
>      { return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
>
>      static char_type*
>      assign(char_type* __s, size_t __n, char_type __a)
>      { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
>
>      static char_type
>      to_char_type(const int_type& __c)
>      { return static_cast<char_type>(__c); }
>
>
>
>      static int_type
>      to_int_type(const char_type& __c)
>      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
>
>      static bool
>      eq_int_type(const int_type& __c1, const int_type& __c2)
>      { return __c1 == __c2; }
>
>      static int_type
>      eof()
>      { return static_cast<int_type>(-1); }
>
>      static int_type
>      not_eof(const int_type& __c)
>      { return (__c == eof()) ? 0 : __c; }
>  };
>
>
>
>
>  template<>
>    struct char_traits<wchar_t>
>    {
>      typedef wchar_t char_type;
>      typedef wint_t int_type;
>      typedef streamoff off_type;
>      typedef wstreampos pos_type;
>      typedef mbstate_t state_type;
>
>      static void
>      assign(char_type& __c1, const char_type& __c2)
>      { __c1 = __c2; }
>
>      static bool
>      eq(const char_type& __c1, const char_type& __c2)
>      { return __c1 == __c2; }
>
>      static bool
>      lt(const char_type& __c1, const char_type& __c2)
>      { return __c1 < __c2; }
>
>      static int
>      compare(const char_type* __s1, const char_type* __s2, size_t __n)
>      { return wmemcmp(__s1, __s2, __n); }
>
>      static size_t
>      length(const char_type* __s)
>      { return wcslen(__s); }
>
>      static const char_type*
>      find(const char_type* __s, size_t __n, const char_type& __a)
>      { return wmemchr(__s, __a, __n); }
>
>      static char_type*
>      move(char_type* __s1, const char_type* __s2, size_t __n)
>      { return wmemmove(__s1, __s2, __n); }
>
>      static char_type*
>      copy(char_type* __s1, const char_type* __s2, size_t __n)
>      { return wmemcpy(__s1, __s2, __n); }
>
>      static char_type*
>      assign(char_type* __s, size_t __n, char_type __a)
>      { return wmemset(__s, __a, __n); }
>
>      static char_type
>      to_char_type(const int_type& __c)
>      { return char_type(__c); }
>
>      static int_type
>      to_int_type(const char_type& __c)
>      { return int_type(__c); }
>
>      static bool
>      eq_int_type(const int_type& __c1, const int_type& __c2)
>      { return __c1 == __c2; }
>
>      static int_type
>      eof()
>      { return static_cast<int_type>((0xffffffffu)); }
>
>      static int_type
>      not_eof(const int_type& __c)
>      { return eq_int_type(__c, eof()) ? 0 : __c; }
>  };
>
>
>
>}
># 41 "/usr/include/c++/4.8.0/string" 2 3
>
>
># 1 "/usr/include/c++/4.8.0/bits/localefwd.h" 1 3
># 37 "/usr/include/c++/4.8.0/bits/localefwd.h" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/localefwd.h" 3
>
>
># 1 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++locale.h" 1 3
># 39 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++locale.h" 3
>       
># 40 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++locale.h" 3
>
># 1 "/usr/include/c++/4.8.0/clocale" 1 3
># 39 "/usr/include/c++/4.8.0/clocale" 3
>       
># 40 "/usr/include/c++/4.8.0/clocale" 3
>
>
># 1 "/usr/include/locale.h" 1 3 4
># 29 "/usr/include/locale.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stddef.h" 1 3 4
># 30 "/usr/include/locale.h" 2 3 4
># 1 "/usr/include/bits/locale.h" 1 3 4
># 31 "/usr/include/locale.h" 2 3 4
>
>extern "C" {
># 51 "/usr/include/locale.h" 3 4
>
>
>
>struct lconv
>{
>
>
>  char *decimal_point;
>  char *thousands_sep;
>
>
>
>
>
>  char *grouping;
>
>
>
>
>
>  char *int_curr_symbol;
>  char *currency_symbol;
>  char *mon_decimal_point;
>  char *mon_thousands_sep;
>  char *mon_grouping;
>  char *positive_sign;
>  char *negative_sign;
>  char int_frac_digits;
>  char frac_digits;
>
>  char p_cs_precedes;
>
>  char p_sep_by_space;
>
>  char n_cs_precedes;
>
>  char n_sep_by_space;
>
>
>
>
>
>
>  char p_sign_posn;
>  char n_sign_posn;
>
>
>  char int_p_cs_precedes;
>
>  char int_p_sep_by_space;
>
>  char int_n_cs_precedes;
>
>  char int_n_sep_by_space;
>
>
>
>
>
>
>  char int_p_sign_posn;
>  char int_n_sign_posn;
># 121 "/usr/include/locale.h" 3 4
>};
>
>
>
>extern char *setlocale (int __category, const char *__locale) throw ();
>
>
>extern struct lconv *localeconv (void) throw ();
>
>
># 152 "/usr/include/locale.h" 3 4
>extern __locale_t newlocale (int __category_mask, const char *__locale,
>        __locale_t __base) throw ();
># 187 "/usr/include/locale.h" 3 4
>extern __locale_t duplocale (__locale_t __dataset) throw ();
>
>
>
>extern void freelocale (__locale_t __dataset) throw ();
>
>
>
>
>
>
>extern __locale_t uselocale (__locale_t __dataset) throw ();
>
>
>
>
>
>
>
>}
># 43 "/usr/include/c++/4.8.0/clocale" 2 3
># 51 "/usr/include/c++/4.8.0/clocale" 3
>namespace std
>{
>  using ::lconv;
>  using ::setlocale;
>  using ::localeconv;
>}
># 42 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++locale.h" 2 3
>
>
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>  extern "C" __typeof(uselocale) __uselocale;
>
>
>}
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  typedef __locale_t __c_locale;
>
>
>
>
>
>  inline int
>  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
>     char* __out,
>     const int __size __attribute__ ((__unused__)),
>     const char* __fmt, ...)
>  {
>
>    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
># 88 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/c++locale.h" 3
>    __builtin_va_list __args;
>    __builtin_va_start(__args, __fmt);
>
>
>    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
>
>
>
>
>    __builtin_va_end(__args);
>
>
>    __gnu_cxx::__uselocale(__old);
>
>
>
>
>
>
>
>    return __ret;
>  }
>
>
>}
># 41 "/usr/include/c++/4.8.0/bits/localefwd.h" 2 3
># 1 "/usr/include/c++/4.8.0/iosfwd" 1 3
># 36 "/usr/include/c++/4.8.0/iosfwd" 3
>       
># 37 "/usr/include/c++/4.8.0/iosfwd" 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 74 "/usr/include/c++/4.8.0/iosfwd" 3
>  class ios_base;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class basic_ios;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class basic_streambuf;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class basic_istream;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class basic_ostream;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class basic_iostream;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT>,
>     typename _Alloc = allocator<_CharT> >
>    class basic_stringbuf;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT>,
>    typename _Alloc = allocator<_CharT> >
>    class basic_istringstream;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT>,
>    typename _Alloc = allocator<_CharT> >
>    class basic_ostringstream;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT>,
>    typename _Alloc = allocator<_CharT> >
>    class basic_stringstream;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class basic_filebuf;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class basic_ifstream;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class basic_ofstream;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class basic_fstream;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class istreambuf_iterator;
>
>  template<typename _CharT, typename _Traits = char_traits<_CharT> >
>    class ostreambuf_iterator;
>
>
>
>  typedef basic_ios<char> ios;
>
>
>  typedef basic_streambuf<char> streambuf;
>
>
>  typedef basic_istream<char> istream;
>
>
>  typedef basic_ostream<char> ostream;
>
>
>  typedef basic_iostream<char> iostream;
>
>
>  typedef basic_stringbuf<char> stringbuf;
>
>
>  typedef basic_istringstream<char> istringstream;
>
>
>  typedef basic_ostringstream<char> ostringstream;
>
>
>  typedef basic_stringstream<char> stringstream;
>
>
>  typedef basic_filebuf<char> filebuf;
>
>
>  typedef basic_ifstream<char> ifstream;
>
>
>  typedef basic_ofstream<char> ofstream;
>
>
>  typedef basic_fstream<char> fstream;
>
>
>
>  typedef basic_ios<wchar_t> wios;
>
>
>  typedef basic_streambuf<wchar_t> wstreambuf;
>
>
>  typedef basic_istream<wchar_t> wistream;
>
>
>  typedef basic_ostream<wchar_t> wostream;
>
>
>  typedef basic_iostream<wchar_t> wiostream;
>
>
>  typedef basic_stringbuf<wchar_t> wstringbuf;
>
>
>  typedef basic_istringstream<wchar_t> wistringstream;
>
>
>  typedef basic_ostringstream<wchar_t> wostringstream;
>
>
>  typedef basic_stringstream<wchar_t> wstringstream;
>
>
>  typedef basic_filebuf<wchar_t> wfilebuf;
>
>
>  typedef basic_ifstream<wchar_t> wifstream;
>
>
>  typedef basic_ofstream<wchar_t> wofstream;
>
>
>  typedef basic_fstream<wchar_t> wfstream;
>
>
>
>
>}
># 42 "/usr/include/c++/4.8.0/bits/localefwd.h" 2 3
># 1 "/usr/include/c++/4.8.0/cctype" 1 3
># 39 "/usr/include/c++/4.8.0/cctype" 3
>       
># 40 "/usr/include/c++/4.8.0/cctype" 3
>
>
># 1 "/usr/include/ctype.h" 1 3 4
># 29 "/usr/include/ctype.h" 3 4
>extern "C" {
># 47 "/usr/include/ctype.h" 3 4
>enum
>{
>  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
>  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
>  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
>  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
>  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
>  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
>  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
>  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
>  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
>  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
>  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
>  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
>};
># 80 "/usr/include/ctype.h" 3 4
>extern const unsigned short int **__ctype_b_loc (void)
>     throw () __attribute__ ((__const__));
>extern const __int32_t **__ctype_tolower_loc (void)
>     throw () __attribute__ ((__const__));
>extern const __int32_t **__ctype_toupper_loc (void)
>     throw () __attribute__ ((__const__));
># 105 "/usr/include/ctype.h" 3 4
>
>
>
>
>
>
>extern int isalnum (int) throw ();
>extern int isalpha (int) throw ();
>extern int iscntrl (int) throw ();
>extern int isdigit (int) throw ();
>extern int islower (int) throw ();
>extern int isgraph (int) throw ();
>extern int isprint (int) throw ();
>extern int ispunct (int) throw ();
>extern int isspace (int) throw ();
>extern int isupper (int) throw ();
>extern int isxdigit (int) throw ();
>
>
>
>extern int tolower (int __c) throw ();
>
>
>extern int toupper (int __c) throw ();
>
>
>
>
>
>
>
>
>extern int isblank (int) throw ();
>
>
>
>
>
>
>extern int isctype (int __c, int __mask) throw ();
>
>
>
>
>
>
>extern int isascii (int __c) throw ();
>
>
>
>extern int toascii (int __c) throw ();
>
>
>
>extern int _toupper (int) throw ();
>extern int _tolower (int) throw ();
># 272 "/usr/include/ctype.h" 3 4
>extern int isalnum_l (int, __locale_t) throw ();
>extern int isalpha_l (int, __locale_t) throw ();
>extern int iscntrl_l (int, __locale_t) throw ();
>extern int isdigit_l (int, __locale_t) throw ();
>extern int islower_l (int, __locale_t) throw ();
>extern int isgraph_l (int, __locale_t) throw ();
>extern int isprint_l (int, __locale_t) throw ();
>extern int ispunct_l (int, __locale_t) throw ();
>extern int isspace_l (int, __locale_t) throw ();
>extern int isupper_l (int, __locale_t) throw ();
>extern int isxdigit_l (int, __locale_t) throw ();
>
>extern int isblank_l (int, __locale_t) throw ();
>
>
>
>extern int __tolower_l (int __c, __locale_t __l) throw ();
>extern int tolower_l (int __c, __locale_t __l) throw ();
>
>
>extern int __toupper_l (int __c, __locale_t __l) throw ();
>extern int toupper_l (int __c, __locale_t __l) throw ();
># 348 "/usr/include/ctype.h" 3 4
>}
># 43 "/usr/include/c++/4.8.0/cctype" 2 3
># 62 "/usr/include/c++/4.8.0/cctype" 3
>namespace std
>{
>  using ::isalnum;
>  using ::isalpha;
>  using ::iscntrl;
>  using ::isdigit;
>  using ::isgraph;
>  using ::islower;
>  using ::isprint;
>  using ::ispunct;
>  using ::isspace;
>  using ::isupper;
>  using ::isxdigit;
>  using ::tolower;
>  using ::toupper;
>}
># 43 "/usr/include/c++/4.8.0/bits/localefwd.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 55 "/usr/include/c++/4.8.0/bits/localefwd.h" 3
>  class locale;
>
>  template<typename _Facet>
>    bool
>    has_facet(const locale&) throw();
>
>  template<typename _Facet>
>    const _Facet&
>    use_facet(const locale&);
>
>
>  template<typename _CharT>
>    bool
>    isspace(_CharT, const locale&);
>
>  template<typename _CharT>
>    bool
>    isprint(_CharT, const locale&);
>
>  template<typename _CharT>
>    bool
>    iscntrl(_CharT, const locale&);
>
>  template<typename _CharT>
>    bool
>    isupper(_CharT, const locale&);
>
>  template<typename _CharT>
>    bool
>    islower(_CharT, const locale&);
>
>  template<typename _CharT>
>    bool
>    isalpha(_CharT, const locale&);
>
>  template<typename _CharT>
>    bool
>    isdigit(_CharT, const locale&);
>
>  template<typename _CharT>
>    bool
>    ispunct(_CharT, const locale&);
>
>  template<typename _CharT>
>    bool
>    isxdigit(_CharT, const locale&);
>
>  template<typename _CharT>
>    bool
>    isalnum(_CharT, const locale&);
>
>  template<typename _CharT>
>    bool
>    isgraph(_CharT, const locale&);
>
>  template<typename _CharT>
>    _CharT
>    toupper(_CharT, const locale&);
>
>  template<typename _CharT>
>    _CharT
>    tolower(_CharT, const locale&);
>
>
>  class ctype_base;
>  template<typename _CharT>
>    class ctype;
>  template<> class ctype<char>;
>
>  template<> class ctype<wchar_t>;
>
>  template<typename _CharT>
>    class ctype_byname;
>
>
>  class codecvt_base;
>  template<typename _InternT, typename _ExternT, typename _StateT>
>    class codecvt;
>  template<> class codecvt<char, char, mbstate_t>;
>
>  template<> class codecvt<wchar_t, char, mbstate_t>;
>
>  template<typename _InternT, typename _ExternT, typename _StateT>
>    class codecvt_byname;
>
>
>
>  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
>    class num_get;
>  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
>    class num_put;
>
>  template<typename _CharT> class numpunct;
>  template<typename _CharT> class numpunct_byname;
>
>
>  template<typename _CharT>
>    class collate;
>  template<typename _CharT> class
>    collate_byname;
>
>
>  class time_base;
>  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
>    class time_get;
>  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
>    class time_get_byname;
>  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
>    class time_put;
>  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
>    class time_put_byname;
>
>
>  class money_base;
>
>  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
>    class money_get;
>  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
>    class money_put;
>
>  template<typename _CharT, bool _Intl = false>
>    class moneypunct;
>  template<typename _CharT, bool _Intl = false>
>    class moneypunct_byname;
>
>
>  class messages_base;
>  template<typename _CharT>
>    class messages;
>  template<typename _CharT>
>    class messages_byname;
>
>
>}
># 44 "/usr/include/c++/4.8.0/string" 2 3
># 1 "/usr/include/c++/4.8.0/bits/ostream_insert.h" 1 3
># 33 "/usr/include/c++/4.8.0/bits/ostream_insert.h" 3
>       
># 34 "/usr/include/c++/4.8.0/bits/ostream_insert.h" 3
>
>
># 1 "/usr/include/c++/4.8.0/bits/cxxabi_forced.h" 1 3
># 34 "/usr/include/c++/4.8.0/bits/cxxabi_forced.h" 3
>       
># 35 "/usr/include/c++/4.8.0/bits/cxxabi_forced.h" 3
>
>#pragma GCC visibility push(default)
>
>
>namespace __cxxabiv1
>{
>
>
>
>
>
>
>
>  class __forced_unwind
>  {
>    virtual ~__forced_unwind() throw();
>
>
>    virtual void __pure_dummy() = 0;
>  };
>}
>
>
>#pragma GCC visibility pop
># 37 "/usr/include/c++/4.8.0/bits/ostream_insert.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _CharT, typename _Traits>
>    inline void
>    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
>      const _CharT* __s, streamsize __n)
>    {
>      typedef basic_ostream<_CharT, _Traits> __ostream_type;
>      typedef typename __ostream_type::ios_base __ios_base;
>
>      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
>      if (__put != __n)
> __out.setstate(__ios_base::badbit);
>    }
>
>  template<typename _CharT, typename _Traits>
>    inline void
>    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
>    {
>      typedef basic_ostream<_CharT, _Traits> __ostream_type;
>      typedef typename __ostream_type::ios_base __ios_base;
>
>      const _CharT __c = __out.fill();
>      for (; __n > 0; --__n)
> {
>   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
>   if (_Traits::eq_int_type(__put, _Traits::eof()))
>     {
>       __out.setstate(__ios_base::badbit);
>       break;
>     }
> }
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>&
>    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
>       const _CharT* __s, streamsize __n)
>    {
>      typedef basic_ostream<_CharT, _Traits> __ostream_type;
>      typedef typename __ostream_type::ios_base __ios_base;
>
>      typename __ostream_type::sentry __cerb(__out);
>      if (__cerb)
> {
>   try
>     {
>       const streamsize __w = __out.width();
>       if (__w > __n)
>  {
>    const bool __left = ((__out.flags()
>     & __ios_base::adjustfield)
>           == __ios_base::left);
>    if (!__left)
>      __ostream_fill(__out, __w - __n);
>    if (__out.good())
>      __ostream_write(__out, __s, __n);
>    if (__left && __out.good())
>      __ostream_fill(__out, __w - __n);
>  }
>       else
>  __ostream_write(__out, __s, __n);
>       __out.width(0);
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       __out._M_setstate(__ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { __out._M_setstate(__ios_base::badbit); }
> }
>      return __out;
>    }
>
>
>
>
>  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
>
>
>  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
>          streamsize);
>
>
>
>
>}
># 45 "/usr/include/c++/4.8.0/string" 2 3
>
>
>
>
>
>
>
># 1 "/usr/include/c++/4.8.0/bits/basic_string.h" 1 3
># 37 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>
># 1 "/usr/include/c++/4.8.0/ext/atomicity.h" 1 3
># 33 "/usr/include/c++/4.8.0/ext/atomicity.h" 3
># 1 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr.h" 1 3
># 30 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr.h" 3
>#pragma GCC visibility push(default)
># 148 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr.h" 3
># 1 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr-default.h" 1 3
># 35 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr-default.h" 3
># 1 "/usr/include/pthread.h" 1 3 4
># 23 "/usr/include/pthread.h" 3 4
># 1 "/usr/include/sched.h" 1 3 4
># 29 "/usr/include/sched.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stddef.h" 1 3 4
># 30 "/usr/include/sched.h" 2 3 4
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 34 "/usr/include/sched.h" 2 3 4
># 42 "/usr/include/sched.h" 3 4
># 1 "/usr/include/bits/sched.h" 1 3 4
># 73 "/usr/include/bits/sched.h" 3 4
>struct sched_param
>  {
>    int __sched_priority;
>  };
>
>extern "C" {
>
>
>
>extern int clone (int (*__fn) (void *__arg), void *__child_stack,
>    int __flags, void *__arg, ...) throw ();
>
>
>extern int unshare (int __flags) throw ();
>
>
>extern int sched_getcpu (void) throw ();
>
>
>extern int setns (int __fd, int __nstype) throw ();
>
>
>
>}
>
>
>
>
>
>
>
>struct __sched_param
>  {
>    int __sched_priority;
>  };
># 119 "/usr/include/bits/sched.h" 3 4
>typedef unsigned long int __cpu_mask;
>
>
>
>
>
>
>typedef struct
>{
>  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
>} cpu_set_t;
># 202 "/usr/include/bits/sched.h" 3 4
>extern "C" {
>
>extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
>  throw ();
>extern cpu_set_t *__sched_cpualloc (size_t __count) throw () __attribute__ ((__warn_unused_result__));
>extern void __sched_cpufree (cpu_set_t *__set) throw ();
>
>}
># 43 "/usr/include/sched.h" 2 3 4
>
>
>
>
>extern "C" {
>
>
>extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
>     throw ();
>
>
>extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
>
>
>extern int sched_setscheduler (__pid_t __pid, int __policy,
>          const struct sched_param *__param) throw ();
>
>
>extern int sched_getscheduler (__pid_t __pid) throw ();
>
>
>extern int sched_yield (void) throw ();
>
>
>extern int sched_get_priority_max (int __algorithm) throw ();
>
>
>extern int sched_get_priority_min (int __algorithm) throw ();
>
>
>extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
># 117 "/usr/include/sched.h" 3 4
>extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
>         const cpu_set_t *__cpuset) throw ();
>
>
>extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
>         cpu_set_t *__cpuset) throw ();
>
>
>}
># 24 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/time.h" 1 3 4
># 29 "/usr/include/time.h" 3 4
>extern "C" {
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stddef.h" 1 3 4
># 38 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 86 "/usr/include/bits/time.h" 3 4
># 1 "/usr/include/bits/timex.h" 1 3 4
># 25 "/usr/include/bits/timex.h" 3 4
>struct timex
>{
>  unsigned int modes;
>  __syscall_slong_t offset;
>  __syscall_slong_t freq;
>  __syscall_slong_t maxerror;
>  __syscall_slong_t esterror;
>  int status;
>  __syscall_slong_t constant;
>  __syscall_slong_t precision;
>  __syscall_slong_t tolerance;
>  struct timeval time;
>  __syscall_slong_t tick;
>  __syscall_slong_t ppsfreq;
>  __syscall_slong_t jitter;
>  int shift;
>  __syscall_slong_t stabil;
>  __syscall_slong_t jitcnt;
>  __syscall_slong_t calcnt;
>  __syscall_slong_t errcnt;
>  __syscall_slong_t stbcnt;
>
>  int tai;
>
>
>  int :32; int :32; int :32; int :32;
>  int :32; int :32; int :32; int :32;
>  int :32; int :32; int :32;
>};
># 87 "/usr/include/bits/time.h" 2 3 4
>
>extern "C" {
>
>
>extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
>
>}
># 42 "/usr/include/time.h" 2 3 4
># 131 "/usr/include/time.h" 3 4
>
>
>struct tm
>{
>  int tm_sec;
>  int tm_min;
>  int tm_hour;
>  int tm_mday;
>  int tm_mon;
>  int tm_year;
>  int tm_wday;
>  int tm_yday;
>  int tm_isdst;
>
>
>  long int tm_gmtoff;
>  const char *tm_zone;
>
>
>
>
>};
>
>
>
>
>
>
>
>
>struct itimerspec
>  {
>    struct timespec it_interval;
>    struct timespec it_value;
>  };
>
>
>struct sigevent;
># 186 "/usr/include/time.h" 3 4
>
>
>
>extern clock_t clock (void) throw ();
>
>
>extern time_t time (time_t *__timer) throw ();
>
>
>extern double difftime (time_t __time1, time_t __time0)
>     throw () __attribute__ ((__const__));
>
>
>extern time_t mktime (struct tm *__tp) throw ();
>
>
>
>
>
>extern size_t strftime (char *__restrict __s, size_t __maxsize,
>   const char *__restrict __format,
>   const struct tm *__restrict __tp) throw ();
>
>
>
>
>
>extern char *strptime (const char *__restrict __s,
>         const char *__restrict __fmt, struct tm *__tp)
>     throw ();
>
>
>
>
>
>
>
>extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
>     const char *__restrict __format,
>     const struct tm *__restrict __tp,
>     __locale_t __loc) throw ();
>
>
>
>extern char *strptime_l (const char *__restrict __s,
>    const char *__restrict __fmt, struct tm *__tp,
>    __locale_t __loc) throw ();
>
>
>
>
>
>
>extern struct tm *gmtime (const time_t *__timer) throw ();
>
>
>
>extern struct tm *localtime (const time_t *__timer) throw ();
>
>
>
>
>
>extern struct tm *gmtime_r (const time_t *__restrict __timer,
>       struct tm *__restrict __tp) throw ();
>
>
>
>extern struct tm *localtime_r (const time_t *__restrict __timer,
>          struct tm *__restrict __tp) throw ();
>
>
>
>
>
>extern char *asctime (const struct tm *__tp) throw ();
>
>
>extern char *ctime (const time_t *__timer) throw ();
>
>
>
>
>
>
>
>extern char *asctime_r (const struct tm *__restrict __tp,
>   char *__restrict __buf) throw ();
>
>
>extern char *ctime_r (const time_t *__restrict __timer,
>        char *__restrict __buf) throw ();
>
>
>
>
>extern char *__tzname[2];
>extern int __daylight;
>extern long int __timezone;
>
>
>
>
>extern char *tzname[2];
>
>
>
>extern void tzset (void) throw ();
>
>
>
>extern int daylight;
>extern long int timezone;
>
>
>
>
>
>extern int stime (const time_t *__when) throw ();
># 319 "/usr/include/time.h" 3 4
>extern time_t timegm (struct tm *__tp) throw ();
>
>
>extern time_t timelocal (struct tm *__tp) throw ();
>
>
>extern int dysize (int __year) throw () __attribute__ ((__const__));
># 334 "/usr/include/time.h" 3 4
>extern int nanosleep (const struct timespec *__requested_time,
>        struct timespec *__remaining);
>
>
>
>extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
>
>
>extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
>
>
>extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
>     throw ();
>
>
>
>
>
>
>extern int clock_nanosleep (clockid_t __clock_id, int __flags,
>       const struct timespec *__req,
>       struct timespec *__rem);
>
>
>extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
>
>
>
>
>extern int timer_create (clockid_t __clock_id,
>    struct sigevent *__restrict __evp,
>    timer_t *__restrict __timerid) throw ();
>
>
>extern int timer_delete (timer_t __timerid) throw ();
>
>
>extern int timer_settime (timer_t __timerid, int __flags,
>     const struct itimerspec *__restrict __value,
>     struct itimerspec *__restrict __ovalue) throw ();
>
>
>extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
>     throw ();
>
>
>extern int timer_getoverrun (timer_t __timerid) throw ();
>
>
>
>
>
>extern int timespec_get (struct timespec *__ts, int __base)
>     throw () __attribute__ ((__nonnull__ (1)));
># 403 "/usr/include/time.h" 3 4
>extern int getdate_err;
># 412 "/usr/include/time.h" 3 4
>extern struct tm *getdate (const char *__string);
># 426 "/usr/include/time.h" 3 4
>extern int getdate_r (const char *__restrict __string,
>        struct tm *__restrict __resbufp);
>
>
>}
># 25 "/usr/include/pthread.h" 2 3 4
>
>
># 1 "/usr/include/bits/setjmp.h" 1 3 4
># 26 "/usr/include/bits/setjmp.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 27 "/usr/include/bits/setjmp.h" 2 3 4
>
>
>
>
>typedef long int __jmp_buf[8];
># 28 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/pthread.h" 2 3 4
>
>
>
>enum
>{
>  PTHREAD_CREATE_JOINABLE,
>
>  PTHREAD_CREATE_DETACHED
>
>};
>
>
>
>enum
>{
>  PTHREAD_MUTEX_TIMED_NP,
>  PTHREAD_MUTEX_RECURSIVE_NP,
>  PTHREAD_MUTEX_ERRORCHECK_NP,
>  PTHREAD_MUTEX_ADAPTIVE_NP
>
>  ,
>  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
>  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
>  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
>  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
>
>
>
>  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
>
>};
>
>
>
>
>enum
>{
>  PTHREAD_MUTEX_STALLED,
>  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
>  PTHREAD_MUTEX_ROBUST,
>  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
>};
>
>
>
>
>
>enum
>{
>  PTHREAD_PRIO_NONE,
>  PTHREAD_PRIO_INHERIT,
>  PTHREAD_PRIO_PROTECT
>};
># 113 "/usr/include/pthread.h" 3 4
>enum
>{
>  PTHREAD_RWLOCK_PREFER_READER_NP,
>  PTHREAD_RWLOCK_PREFER_WRITER_NP,
>  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
>  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
>};
># 154 "/usr/include/pthread.h" 3 4
>enum
>{
>  PTHREAD_INHERIT_SCHED,
>
>  PTHREAD_EXPLICIT_SCHED
>
>};
>
>
>
>enum
>{
>  PTHREAD_SCOPE_SYSTEM,
>
>  PTHREAD_SCOPE_PROCESS
>
>};
>
>
>
>enum
>{
>  PTHREAD_PROCESS_PRIVATE,
>
>  PTHREAD_PROCESS_SHARED
>
>};
># 189 "/usr/include/pthread.h" 3 4
>struct _pthread_cleanup_buffer
>{
>  void (*__routine) (void *);
>  void *__arg;
>  int __canceltype;
>  struct _pthread_cleanup_buffer *__prev;
>};
>
>
>enum
>{
>  PTHREAD_CANCEL_ENABLE,
>
>  PTHREAD_CANCEL_DISABLE
>
>};
>enum
>{
>  PTHREAD_CANCEL_DEFERRED,
>
>  PTHREAD_CANCEL_ASYNCHRONOUS
>
>};
># 227 "/usr/include/pthread.h" 3 4
>extern "C" {
>
>
>
>
>extern int pthread_create (pthread_t *__restrict __newthread,
>      const pthread_attr_t *__restrict __attr,
>      void *(*__start_routine) (void *),
>      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern int pthread_join (pthread_t __th, void **__thread_return);
>
>
>
>
>extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
>
>
>
>
>
>
>
>extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
>     const struct timespec *__abstime);
>
>
>
>
>
>
>extern int pthread_detach (pthread_t __th) throw ();
>
>
>
>extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
>
>
>extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
>  throw () __attribute__ ((__const__));
>
>
>
>
>
>
>
>extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_destroy (pthread_attr_t *__attr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
>     int *__detachstate)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
>     int __detachstate)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
>          size_t *__guardsize)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
>          size_t __guardsize)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
>           struct sched_param *__restrict __param)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
>           const struct sched_param *__restrict
>           __param) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
>     __attr, int *__restrict __policy)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
>      __attr, int *__restrict __inherit)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
>      int __inherit)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
>      int *__restrict __scope)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
>          __attr, void **__restrict __stackaddr)
>     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
>
>
>
>
>
>extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
>          void *__stackaddr)
>     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
>
>
>extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
>          __attr, size_t *__restrict __stacksize)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
>          size_t __stacksize)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
>      void **__restrict __stackaddr,
>      size_t *__restrict __stacksize)
>     throw () __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
>      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
>     size_t __cpusetsize,
>     const cpu_set_t *__cpuset)
>     throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
>     size_t __cpusetsize,
>     cpu_set_t *__cpuset)
>     throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
>     throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>
>extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
>      const struct sched_param *__param)
>     throw () __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getschedparam (pthread_t __target_thread,
>      int *__restrict __policy,
>      struct sched_param *__restrict __param)
>     throw () __attribute__ ((__nonnull__ (2, 3)));
>
>
>extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
>     throw ();
>
>
>
>
>extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
>          size_t __buflen)
>     throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
>     throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int pthread_getconcurrency (void) throw ();
>
>
>extern int pthread_setconcurrency (int __level) throw ();
>
>
>
>
>
>
>
>extern int pthread_yield (void) throw ();
>
>
>
>
>extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
>       const cpu_set_t *__cpuset)
>     throw () __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
>       cpu_set_t *__cpuset)
>     throw () __attribute__ ((__nonnull__ (3)));
># 485 "/usr/include/pthread.h" 3 4
>extern int pthread_once (pthread_once_t *__once_control,
>    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
># 497 "/usr/include/pthread.h" 3 4
>extern int pthread_setcancelstate (int __state, int *__oldstate);
>
>
>
>extern int pthread_setcanceltype (int __type, int *__oldtype);
>
>
>extern int pthread_cancel (pthread_t __th);
>
>
>
>
>extern void pthread_testcancel (void);
>
>
>
>
>typedef struct
>{
>  struct
>  {
>    __jmp_buf __cancel_jmp_buf;
>    int __mask_was_saved;
>  } __cancel_jmp_buf[1];
>  void *__pad[4];
>} __pthread_unwind_buf_t __attribute__ ((__aligned__));
># 531 "/usr/include/pthread.h" 3 4
>struct __pthread_cleanup_frame
>{
>  void (*__cancel_routine) (void *);
>  void *__cancel_arg;
>  int __do_it;
>  int __cancel_type;
>};
>
>
>
>
>class __pthread_cleanup_class
>{
>  void (*__cancel_routine) (void *);
>  void *__cancel_arg;
>  int __do_it;
>  int __cancel_type;
>
> public:
>  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
>    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
>  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
>  void __setdoit (int __newval) { __do_it = __newval; }
>  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
>        &__cancel_type); }
>  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
>};
># 733 "/usr/include/pthread.h" 3 4
>struct __jmp_buf_tag;
>extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
>
>
>
>
>
>extern int pthread_mutex_init (pthread_mutex_t *__mutex,
>          const pthread_mutexattr_t *__mutexattr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
>        const struct timespec *__restrict
>        __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
>      __restrict __mutex,
>      int *__restrict __prioceiling)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
>      int __prioceiling,
>      int *__restrict __old_ceiling)
>     throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
>     throw () __attribute__ ((__nonnull__ (1)));
># 797 "/usr/include/pthread.h" 3 4
>extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
>      __restrict __attr,
>      int *__restrict __pshared)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
>      int __pshared)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
>          __attr, int *__restrict __kind)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
>       __restrict __attr,
>       int *__restrict __protocol)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
>       int __protocol)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
>          __restrict __attr,
>          int *__restrict __prioceiling)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
>          int __prioceiling)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
>     int *__robustness)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
>        int *__robustness)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
>     int __robustness)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
>        int __robustness)
>     throw () __attribute__ ((__nonnull__ (1)));
># 879 "/usr/include/pthread.h" 3 4
>extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
>    const pthread_rwlockattr_t *__restrict
>    __attr) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
>  throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
>           const struct timespec *__restrict
>           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
>           const struct timespec *__restrict
>           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
>       __restrict __attr,
>       int *__restrict __pshared)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
>       int __pshared)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
>       __restrict __attr,
>       int *__restrict __pref)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
>       int __pref) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
>         const pthread_condattr_t *__restrict __cond_attr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_destroy (pthread_cond_t *__cond)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_signal (pthread_cond_t *__cond)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_broadcast (pthread_cond_t *__cond)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
>         pthread_mutex_t *__restrict __mutex)
>     __attribute__ ((__nonnull__ (1, 2)));
># 991 "/usr/include/pthread.h" 3 4
>extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
>       pthread_mutex_t *__restrict __mutex,
>       const struct timespec *__restrict __abstime)
>     __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern int pthread_condattr_init (pthread_condattr_t *__attr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_getpshared (const pthread_condattr_t *
>     __restrict __attr,
>     int *__restrict __pshared)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
>     int __pshared) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_condattr_getclock (const pthread_condattr_t *
>          __restrict __attr,
>          __clockid_t *__restrict __clock_id)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
>          __clockid_t __clock_id)
>     throw () __attribute__ ((__nonnull__ (1)));
># 1035 "/usr/include/pthread.h" 3 4
>extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_lock (pthread_spinlock_t *__lock)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
>     const pthread_barrierattr_t *__restrict
>     __attr, unsigned int __count)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
>        __restrict __attr,
>        int *__restrict __pshared)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
>        int __pshared)
>     throw () __attribute__ ((__nonnull__ (1)));
># 1102 "/usr/include/pthread.h" 3 4
>extern int pthread_key_create (pthread_key_t *__key,
>          void (*__destr_function) (void *))
>     throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_key_delete (pthread_key_t __key) throw ();
>
>
>extern void *pthread_getspecific (pthread_key_t __key) throw ();
>
>
>extern int pthread_setspecific (pthread_key_t __key,
>    const void *__pointer) throw () ;
>
>
>
>
>extern int pthread_getcpuclockid (pthread_t __thread_id,
>      __clockid_t *__clock_id)
>     throw () __attribute__ ((__nonnull__ (2)));
># 1136 "/usr/include/pthread.h" 3 4
>extern int pthread_atfork (void (*__prepare) (void),
>      void (*__parent) (void),
>      void (*__child) (void)) throw ();
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ()
>{
>  return __thread1 == __thread2;
>}
>
>
>}
># 36 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr-default.h" 2 3
># 47 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr-default.h" 3
>typedef pthread_t __gthread_t;
>typedef pthread_key_t __gthread_key_t;
>typedef pthread_once_t __gthread_once_t;
>typedef pthread_mutex_t __gthread_mutex_t;
>typedef pthread_mutex_t __gthread_recursive_mutex_t;
>typedef pthread_cond_t __gthread_cond_t;
>typedef struct timespec __gthread_time_t;
># 101 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr-default.h" 3
>static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
>static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
>static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
>
>static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
>static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
>static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
>static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
>static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
>
>static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
>
>static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
>
>static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
>static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
>
>static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
>
>static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
>static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
>static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
>
>static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
>static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
>static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
>static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
>static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
>static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
>
>static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
>static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
>static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
>static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
>static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
># 236 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr-default.h" 3
>static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
># 246 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_active_p (void)
>{
>  static void *const __gthread_active_ptr
>    = __extension__ (void *) &__gthrw___pthread_key_create;
>  return __gthread_active_ptr != 0;
>}
># 658 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
>    void *__args)
>{
>  return __gthrw_pthread_create (__threadid, __null, __func, __args);
>}
>
>static inline int
>__gthread_join (__gthread_t __threadid, void **__value_ptr)
>{
>  return __gthrw_pthread_join (__threadid, __value_ptr);
>}
>
>static inline int
>__gthread_detach (__gthread_t __threadid)
>{
>  return __gthrw_pthread_detach (__threadid);
>}
>
>static inline int
>__gthread_equal (__gthread_t __t1, __gthread_t __t2)
>{
>  return __gthrw_pthread_equal (__t1, __t2);
>}
>
>static inline __gthread_t
>__gthread_self (void)
>{
>  return __gthrw_pthread_self ();
>}
>
>static inline int
>__gthread_yield (void)
>{
>  return __gthrw_sched_yield ();
>}
>
>static inline int
>__gthread_once (__gthread_once_t *__once, void (*__func) (void))
>{
>  if (__gthread_active_p ())
>    return __gthrw_pthread_once (__once, __func);
>  else
>    return -1;
>}
>
>static inline int
>__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
>{
>  return __gthrw_pthread_key_create (__key, __dtor);
>}
>
>static inline int
>__gthread_key_delete (__gthread_key_t __key)
>{
>  return __gthrw_pthread_key_delete (__key);
>}
>
>static inline void *
>__gthread_getspecific (__gthread_key_t __key)
>{
>  return __gthrw_pthread_getspecific (__key);
>}
>
>static inline int
>__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
>{
>  return __gthrw_pthread_setspecific (__key, __ptr);
>}
>
>static inline void
>__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
>{
>  if (__gthread_active_p ())
>    __gthrw_pthread_mutex_init (__mutex, __null);
>}
>
>static inline int
>__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
>{
>  if (__gthread_active_p ())
>    return __gthrw_pthread_mutex_destroy (__mutex);
>  else
>    return 0;
>}
>
>static inline int
>__gthread_mutex_lock (__gthread_mutex_t *__mutex)
>{
>  if (__gthread_active_p ())
>    return __gthrw_pthread_mutex_lock (__mutex);
>  else
>    return 0;
>}
>
>static inline int
>__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
>{
>  if (__gthread_active_p ())
>    return __gthrw_pthread_mutex_trylock (__mutex);
>  else
>    return 0;
>}
>
>
>static inline int
>__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
>      const __gthread_time_t *__abs_timeout)
>{
>  if (__gthread_active_p ())
>    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
>  else
>    return 0;
>}
>
>
>static inline int
>__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
>{
>  if (__gthread_active_p ())
>    return __gthrw_pthread_mutex_unlock (__mutex);
>  else
>    return 0;
>}
># 807 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
>{
>  return __gthread_mutex_lock (__mutex);
>}
>
>static inline int
>__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
>{
>  return __gthread_mutex_trylock (__mutex);
>}
>
>
>static inline int
>__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
>         const __gthread_time_t *__abs_timeout)
>{
>  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
>}
>
>
>static inline int
>__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
>{
>  return __gthread_mutex_unlock (__mutex);
>}
>
>static inline int
>__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
>{
>  return __gthread_mutex_destroy (__mutex);
>}
># 849 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_cond_broadcast (__gthread_cond_t *__cond)
>{
>  return __gthrw_pthread_cond_broadcast (__cond);
>}
>
>static inline int
>__gthread_cond_signal (__gthread_cond_t *__cond)
>{
>  return __gthrw_pthread_cond_signal (__cond);
>}
>
>static inline int
>__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
>{
>  return __gthrw_pthread_cond_wait (__cond, __mutex);
>}
>
>static inline int
>__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
>     const __gthread_time_t *__abs_timeout)
>{
>  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
>}
>
>static inline int
>__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
>          __gthread_recursive_mutex_t *__mutex)
>{
>  return __gthread_cond_wait (__cond, __mutex);
>}
>
>static inline int
>__gthread_cond_destroy (__gthread_cond_t* __cond)
>{
>  return __gthrw_pthread_cond_destroy (__cond);
>}
># 149 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/gthr.h" 2 3
>
>
>#pragma GCC visibility pop
># 34 "/usr/include/c++/4.8.0/ext/atomicity.h" 2 3
># 1 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/atomic_word.h" 1 3
># 32 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/atomic_word.h" 3
>typedef int _Atomic_word;
># 35 "/usr/include/c++/4.8.0/ext/atomicity.h" 2 3
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>  static inline _Atomic_word
>  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
>  { return __atomic_fetch_add(__mem, __val, 4); }
>
>  static inline void
>  __atomic_add(volatile _Atomic_word* __mem, int __val)
>  { __atomic_fetch_add(__mem, __val, 4); }
># 62 "/usr/include/c++/4.8.0/ext/atomicity.h" 3
>  static inline _Atomic_word
>  __exchange_and_add_single(_Atomic_word* __mem, int __val)
>  {
>    _Atomic_word __result = *__mem;
>    *__mem += __val;
>    return __result;
>  }
>
>  static inline void
>  __atomic_add_single(_Atomic_word* __mem, int __val)
>  { *__mem += __val; }
>
>  static inline _Atomic_word
>  __attribute__ ((__unused__))
>  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
>  {
>
>    if (__gthread_active_p())
>      return __exchange_and_add(__mem, __val);
>    else
>      return __exchange_and_add_single(__mem, __val);
>
>
>
>  }
>
>  static inline void
>  __attribute__ ((__unused__))
>  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
>  {
>
>    if (__gthread_active_p())
>      __atomic_add(__mem, __val);
>    else
>      __atomic_add_single(__mem, __val);
>
>
>
>  }
>
>
>}
># 40 "/usr/include/c++/4.8.0/bits/basic_string.h" 2 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 111 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    class basic_string
>    {
>      typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
>
>
>    public:
>      typedef _Traits traits_type;
>      typedef typename _Traits::char_type value_type;
>      typedef _Alloc allocator_type;
>      typedef typename _CharT_alloc_type::size_type size_type;
>      typedef typename _CharT_alloc_type::difference_type difference_type;
>      typedef typename _CharT_alloc_type::reference reference;
>      typedef typename _CharT_alloc_type::const_reference const_reference;
>      typedef typename _CharT_alloc_type::pointer pointer;
>      typedef typename _CharT_alloc_type::const_pointer const_pointer;
>      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
>      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
>                                                            const_iterator;
>      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
>      typedef std::reverse_iterator<iterator> reverse_iterator;
>
>    private:
># 148 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      struct _Rep_base
>      {
> size_type _M_length;
> size_type _M_capacity;
> _Atomic_word _M_refcount;
>      };
>
>      struct _Rep : _Rep_base
>      {
>
> typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
># 173 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
> static const size_type _S_max_size;
> static const _CharT _S_terminal;
>
>
>
>        static size_type _S_empty_rep_storage[];
>
>        static _Rep&
>        _S_empty_rep()
>        {
>
>
>
>   void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
>   return *reinterpret_cast<_Rep*>(__p);
> }
>
>        bool
> _M_is_leaked() const
>        { return this->_M_refcount < 0; }
>
>        bool
> _M_is_shared() const
>        { return this->_M_refcount > 0; }
>
>        void
> _M_set_leaked()
>        { this->_M_refcount = -1; }
>
>        void
> _M_set_sharable()
>        { this->_M_refcount = 0; }
>
> void
> _M_set_length_and_sharable(size_type __n)
> {
>
>   if (__builtin_expect(this != &_S_empty_rep(), false))
>
>     {
>       this->_M_set_sharable();
>       this->_M_length = __n;
>       traits_type::assign(this->_M_refdata()[__n], _S_terminal);
>
>
>     }
> }
>
> _CharT*
> _M_refdata() throw()
> { return reinterpret_cast<_CharT*>(this + 1); }
>
> _CharT*
> _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
> {
>   return (!_M_is_leaked() && __alloc1 == __alloc2)
>           ? _M_refcopy() : _M_clone(__alloc1);
> }
>
>
> static _Rep*
> _S_create(size_type, size_type, const _Alloc&);
>
> void
> _M_dispose(const _Alloc& __a)
> {
>
>   if (__builtin_expect(this != &_S_empty_rep(), false))
>
>     {
>
>       ;
>       if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
>        -1) <= 0)
>  {
>    ;
>    _M_destroy(__a);
>  }
>     }
> }
>
> void
> _M_destroy(const _Alloc&) throw();
>
> _CharT*
> _M_refcopy() throw()
> {
>
>   if (__builtin_expect(this != &_S_empty_rep(), false))
>
>            __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
>   return _M_refdata();
> }
>
> _CharT*
> _M_clone(const _Alloc&, size_type __res = 0);
>      };
>
>
>      struct _Alloc_hider : _Alloc
>      {
> _Alloc_hider(_CharT* __dat, const _Alloc& __a)
> : _Alloc(__a), _M_p(__dat) { }
>
> _CharT* _M_p;
>      };
>
>    public:
>
>
>
>
>      static const size_type npos = static_cast<size_type>(-1);
>
>    private:
>
>      mutable _Alloc_hider _M_dataplus;
>
>      _CharT*
>      _M_data() const
>      { return _M_dataplus._M_p; }
>
>      _CharT*
>      _M_data(_CharT* __p)
>      { return (_M_dataplus._M_p = __p); }
>
>      _Rep*
>      _M_rep() const
>      { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
>
>
>
>      iterator
>      _M_ibegin() const
>      { return iterator(_M_data()); }
>
>      iterator
>      _M_iend() const
>      { return iterator(_M_data() + this->size()); }
>
>      void
>      _M_leak()
>      {
> if (!_M_rep()->_M_is_leaked())
>   _M_leak_hard();
>      }
>
>      size_type
>      _M_check(size_type __pos, const char* __s) const
>      {
> if (__pos > this->size())
>   __throw_out_of_range((__s));
> return __pos;
>      }
>
>      void
>      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
>      {
> if (this->max_size() - (this->size() - __n1) < __n2)
>   __throw_length_error((__s));
>      }
>
>
>      size_type
>      _M_limit(size_type __pos, size_type __off) const
>      {
> const bool __testoff = __off < this->size() - __pos;
> return __testoff ? __off : this->size() - __pos;
>      }
>
>
>      bool
>      _M_disjunct(const _CharT* __s) const
>      {
> return (less<const _CharT*>()(__s, _M_data())
>  || less<const _CharT*>()(_M_data() + this->size(), __s));
>      }
>
>
>
>      static void
>      _M_copy(_CharT* __d, const _CharT* __s, size_type __n)
>      {
> if (__n == 1)
>   traits_type::assign(*__d, *__s);
> else
>   traits_type::copy(__d, __s, __n);
>      }
>
>      static void
>      _M_move(_CharT* __d, const _CharT* __s, size_type __n)
>      {
> if (__n == 1)
>   traits_type::assign(*__d, *__s);
> else
>   traits_type::move(__d, __s, __n);
>      }
>
>      static void
>      _M_assign(_CharT* __d, size_type __n, _CharT __c)
>      {
> if (__n == 1)
>   traits_type::assign(*__d, __c);
> else
>   traits_type::assign(__d, __n, __c);
>      }
>
>
>
>      template<class _Iterator>
>        static void
>        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
>        {
>   for (; __k1 != __k2; ++__k1, ++__p)
>     traits_type::assign(*__p, *__k1);
> }
>
>      static void
>      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
>      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
>
>      static void
>      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
>      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
>
>      static void
>      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
>      { _M_copy(__p, __k1, __k2 - __k1); }
>
>      static void
>      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
>      { _M_copy(__p, __k1, __k2 - __k1); }
>
>      static int
>      _S_compare(size_type __n1, size_type __n2)
>      {
> const difference_type __d = difference_type(__n1 - __n2);
>
> if (__d > __gnu_cxx::__numeric_traits<int>::__max)
>   return __gnu_cxx::__numeric_traits<int>::__max;
> else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
>   return __gnu_cxx::__numeric_traits<int>::__min;
> else
>   return int(__d);
>      }
>
>      void
>      _M_mutate(size_type __pos, size_type __len1, size_type __len2);
>
>      void
>      _M_leak_hard();
>
>      static _Rep&
>      _S_empty_rep()
>      { return _Rep::_S_empty_rep(); }
>
>    public:
>
>
>
>
>
>
>
>      basic_string()
>
>      : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
>
>
>
>
>
>
>
>      explicit
>      basic_string(const _Alloc& __a);
>
>
>
>
>
>
>      basic_string(const basic_string& __str);
>
>
>
>
>
>
>      basic_string(const basic_string& __str, size_type __pos,
>     size_type __n = npos);
>
>
>
>
>
>
>
>      basic_string(const basic_string& __str, size_type __pos,
>     size_type __n, const _Alloc& __a);
># 483 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string(const _CharT* __s, size_type __n,
>     const _Alloc& __a = _Alloc());
>
>
>
>
>
>      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
>
>
>
>
>
>
>      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
># 531 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      template<class _InputIterator>
>        basic_string(_InputIterator __beg, _InputIterator __end,
>       const _Alloc& __a = _Alloc());
>
>
>
>
>      ~basic_string()
>      { _M_rep()->_M_dispose(this->get_allocator()); }
>
>
>
>
>
>      basic_string&
>      operator=(const basic_string& __str)
>      { return this->assign(__str); }
>
>
>
>
>
>      basic_string&
>      operator=(const _CharT* __s)
>      { return this->assign(__s); }
># 564 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      operator=(_CharT __c)
>      {
> this->assign(1, __c);
> return *this;
>      }
># 604 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      iterator
>      begin()
>      {
> _M_leak();
> return iterator(_M_data());
>      }
>
>
>
>
>
>      const_iterator
>      begin() const
>      { return const_iterator(_M_data()); }
>
>
>
>
>
>      iterator
>      end()
>      {
> _M_leak();
> return iterator(_M_data() + this->size());
>      }
>
>
>
>
>
>      const_iterator
>      end() const
>      { return const_iterator(_M_data() + this->size()); }
>
>
>
>
>
>
>      reverse_iterator
>      rbegin()
>      { return reverse_iterator(this->end()); }
>
>
>
>
>
>
>      const_reverse_iterator
>      rbegin() const
>      { return const_reverse_iterator(this->end()); }
>
>
>
>
>
>
>      reverse_iterator
>      rend()
>      { return reverse_iterator(this->begin()); }
>
>
>
>
>
>
>      const_reverse_iterator
>      rend() const
>      { return const_reverse_iterator(this->begin()); }
># 710 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>    public:
>
>
>
>      size_type
>      size() const
>      { return _M_rep()->_M_length; }
>
>
>
>      size_type
>      length() const
>      { return _M_rep()->_M_length; }
>
>
>      size_type
>      max_size() const
>      { return _Rep::_S_max_size; }
># 739 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      void
>      resize(size_type __n, _CharT __c);
># 752 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      void
>      resize(size_type __n)
>      { this->resize(__n, _CharT()); }
># 775 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      capacity() const
>      { return _M_rep()->_M_capacity; }
># 796 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      void
>      reserve(size_type __res_arg = 0);
>
>
>
>
>      void
>      clear()
>      { _M_mutate(0, this->size(), 0); }
>
>
>
>
>
>      bool
>      empty() const
>      { return this->size() == 0; }
># 825 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      const_reference
>      operator[] (size_type __pos) const
>      {
> ;
> return _M_data()[__pos];
>      }
># 842 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      reference
>      operator[](size_type __pos)
>      {
>
> ;
>
> ;
> _M_leak();
> return _M_data()[__pos];
>      }
># 863 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      const_reference
>      at(size_type __n) const
>      {
> if (__n >= this->size())
>   __throw_out_of_range(("basic_string::at"));
> return _M_data()[__n];
>      }
># 882 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      reference
>      at(size_type __n)
>      {
> if (__n >= size())
>   __throw_out_of_range(("basic_string::at"));
> _M_leak();
> return _M_data()[__n];
>      }
># 931 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      operator+=(const basic_string& __str)
>      { return this->append(__str); }
>
>
>
>
>
>
>      basic_string&
>      operator+=(const _CharT* __s)
>      { return this->append(__s); }
>
>
>
>
>
>
>      basic_string&
>      operator+=(_CharT __c)
>      {
> this->push_back(__c);
> return *this;
>      }
># 972 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      append(const basic_string& __str);
># 988 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      append(const basic_string& __str, size_type __pos, size_type __n);
>
>
>
>
>
>
>
>      basic_string&
>      append(const _CharT* __s, size_type __n);
>
>
>
>
>
>
>      basic_string&
>      append(const _CharT* __s)
>      {
> ;
> return this->append(__s, traits_type::length(__s));
>      }
># 1020 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      append(size_type __n, _CharT __c);
># 1042 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      template<class _InputIterator>
>        basic_string&
>        append(_InputIterator __first, _InputIterator __last)
>        { return this->replace(_M_iend(), _M_iend(), __first, __last); }
>
>
>
>
>
>      void
>      push_back(_CharT __c)
>      {
> const size_type __len = 1 + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
>   this->reserve(__len);
> traits_type::assign(_M_data()[this->size()], __c);
> _M_rep()->_M_set_length_and_sharable(__len);
>      }
>
>
>
>
>
>
>      basic_string&
>      assign(const basic_string& __str);
># 1099 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      assign(const basic_string& __str, size_type __pos, size_type __n)
>      { return this->assign(__str._M_data()
>       + __str._M_check(__pos, "basic_string::assign"),
>       __str._M_limit(__pos, __n)); }
># 1115 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      assign(const _CharT* __s, size_type __n);
># 1127 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      assign(const _CharT* __s)
>      {
> ;
> return this->assign(__s, traits_type::length(__s));
>      }
># 1143 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      assign(size_type __n, _CharT __c)
>      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
># 1155 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      template<class _InputIterator>
>        basic_string&
>        assign(_InputIterator __first, _InputIterator __last)
>        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
># 1184 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      void
>      insert(iterator __p, size_type __n, _CharT __c)
>      { this->replace(__p, __p, __n, __c); }
># 1200 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      template<class _InputIterator>
>        void
>        insert(iterator __p, _InputIterator __beg, _InputIterator __end)
>        { this->replace(__p, __p, __beg, __end); }
># 1232 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      insert(size_type __pos1, const basic_string& __str)
>      { return this->insert(__pos1, __str, size_type(0), __str.size()); }
># 1254 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      insert(size_type __pos1, const basic_string& __str,
>      size_type __pos2, size_type __n)
>      { return this->insert(__pos1, __str._M_data()
>       + __str._M_check(__pos2, "basic_string::insert"),
>       __str._M_limit(__pos2, __n)); }
># 1277 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      insert(size_type __pos, const _CharT* __s, size_type __n);
># 1295 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      insert(size_type __pos, const _CharT* __s)
>      {
> ;
> return this->insert(__pos, __s, traits_type::length(__s));
>      }
># 1318 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      insert(size_type __pos, size_type __n, _CharT __c)
>      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
>         size_type(0), __n, __c); }
># 1336 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      iterator
>      insert(iterator __p, _CharT __c)
>      {
> ;
> const size_type __pos = __p - _M_ibegin();
> _M_replace_aux(__pos, size_type(0), size_type(1), __c);
> _M_rep()->_M_set_leaked();
> return iterator(_M_data() + __pos);
>      }
># 1361 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      erase(size_type __pos = 0, size_type __n = npos)
>      {
> _M_mutate(_M_check(__pos, "basic_string::erase"),
>    _M_limit(__pos, __n), size_type(0));
> return *this;
>      }
># 1377 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      iterator
>      erase(iterator __position)
>      {
>
>                               ;
> const size_type __pos = __position - _M_ibegin();
> _M_mutate(__pos, size_type(1), size_type(0));
> _M_rep()->_M_set_leaked();
> return iterator(_M_data() + __pos);
>      }
># 1397 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      iterator
>      erase(iterator __first, iterator __last);
># 1428 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      replace(size_type __pos, size_type __n, const basic_string& __str)
>      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
># 1450 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      replace(size_type __pos1, size_type __n1, const basic_string& __str,
>       size_type __pos2, size_type __n2)
>      { return this->replace(__pos1, __n1, __str._M_data()
>        + __str._M_check(__pos2, "basic_string::replace"),
>        __str._M_limit(__pos2, __n2)); }
># 1475 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      replace(size_type __pos, size_type __n1, const _CharT* __s,
>       size_type __n2);
># 1495 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      replace(size_type __pos, size_type __n1, const _CharT* __s)
>      {
> ;
> return this->replace(__pos, __n1, __s, traits_type::length(__s));
>      }
># 1519 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
>      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
>         _M_limit(__pos, __n1), __n2, __c); }
># 1537 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      replace(iterator __i1, iterator __i2, const basic_string& __str)
>      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
># 1556 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
>      {
>
>                          ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
>      }
># 1577 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      replace(iterator __i1, iterator __i2, const _CharT* __s)
>      {
> ;
> return this->replace(__i1, __i2, __s, traits_type::length(__s));
>      }
># 1598 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string&
>      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
>      {
>
>                          ;
> return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
>      }
># 1621 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      template<class _InputIterator>
>        basic_string&
>        replace(iterator __i1, iterator __i2,
>  _InputIterator __k1, _InputIterator __k2)
>        {
>  
>                            ;
>   ;
>   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
>   return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
> }
>
>
>
>      basic_string&
>      replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
>      {
>
>                          ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
>        __k1, __k2 - __k1);
>      }
>
>      basic_string&
>      replace(iterator __i1, iterator __i2,
>       const _CharT* __k1, const _CharT* __k2)
>      {
>
>                          ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
>        __k1, __k2 - __k1);
>      }
>
>      basic_string&
>      replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
>      {
>
>                          ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
>        __k1.base(), __k2 - __k1);
>      }
>
>      basic_string&
>      replace(iterator __i1, iterator __i2,
>       const_iterator __k1, const_iterator __k2)
>      {
>
>                          ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
>        __k1.base(), __k2 - __k1);
>      }
># 1697 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>    private:
>      template<class _Integer>
> basic_string&
> _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
>       _Integer __val, __true_type)
>        { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
>
>      template<class _InputIterator>
> basic_string&
> _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
>       _InputIterator __k2, __false_type);
>
>      basic_string&
>      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
>       _CharT __c);
>
>      basic_string&
>      _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
>        size_type __n2);
>
>
>
>      template<class _InIterator>
>        static _CharT*
>        _S_construct_aux(_InIterator __beg, _InIterator __end,
>    const _Alloc& __a, __false_type)
> {
>          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
>          return _S_construct(__beg, __end, __a, _Tag());
> }
>
>
>
>      template<class _Integer>
>        static _CharT*
>        _S_construct_aux(_Integer __beg, _Integer __end,
>    const _Alloc& __a, __true_type)
>        { return _S_construct_aux_2(static_cast<size_type>(__beg),
>        __end, __a); }
>
>      static _CharT*
>      _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
>      { return _S_construct(__req, __c, __a); }
>
>      template<class _InIterator>
>        static _CharT*
>        _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
> {
>   typedef typename std::__is_integer<_InIterator>::__type _Integral;
>   return _S_construct_aux(__beg, __end, __a, _Integral());
>        }
>
>
>      template<class _InIterator>
>        static _CharT*
>         _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
>        input_iterator_tag);
>
>
>
>      template<class _FwdIterator>
>        static _CharT*
>        _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
>       forward_iterator_tag);
>
>      static _CharT*
>      _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
>
>    public:
># 1779 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
># 1789 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      void
>      swap(basic_string& __s);
># 1799 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      const _CharT*
>      c_str() const
>      { return _M_data(); }
>
>
>
>
>
>
>
>      const _CharT*
>      data() const
>      { return _M_data(); }
>
>
>
>
>      allocator_type
>      get_allocator() const
>      { return _M_dataplus; }
># 1832 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find(const _CharT* __s, size_type __pos, size_type __n) const;
># 1845 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find(const basic_string& __str, size_type __pos = 0) const
>
>      { return this->find(__str.data(), __pos, __str.size()); }
># 1860 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find(const _CharT* __s, size_type __pos = 0) const
>      {
> ;
> return this->find(__s, __pos, traits_type::length(__s));
>      }
># 1877 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find(_CharT __c, size_type __pos = 0) const ;
># 1890 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      rfind(const basic_string& __str, size_type __pos = npos) const
>
>      { return this->rfind(__str.data(), __pos, __str.size()); }
># 1907 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
># 1920 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      rfind(const _CharT* __s, size_type __pos = npos) const
>      {
> ;
> return this->rfind(__s, __pos, traits_type::length(__s));
>      }
># 1937 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      rfind(_CharT __c, size_type __pos = npos) const ;
># 1951 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_first_of(const basic_string& __str, size_type __pos = 0) const
>
>      { return this->find_first_of(__str.data(), __pos, __str.size()); }
># 1968 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
># 1981 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_first_of(const _CharT* __s, size_type __pos = 0) const
>      {
> ;
> return this->find_first_of(__s, __pos, traits_type::length(__s));
>      }
># 2000 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_first_of(_CharT __c, size_type __pos = 0) const
>      { return this->find(__c, __pos); }
># 2015 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_last_of(const basic_string& __str, size_type __pos = npos) const
>
>      { return this->find_last_of(__str.data(), __pos, __str.size()); }
># 2032 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
># 2045 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_last_of(const _CharT* __s, size_type __pos = npos) const
>      {
> ;
> return this->find_last_of(__s, __pos, traits_type::length(__s));
>      }
># 2064 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_last_of(_CharT __c, size_type __pos = npos) const
>      { return this->rfind(__c, __pos); }
># 2078 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
>
>      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
># 2095 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_first_not_of(const _CharT* __s, size_type __pos,
>   size_type __n) const;
># 2109 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
>      {
> ;
> return this->find_first_not_of(__s, __pos, traits_type::length(__s));
>      }
># 2126 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_first_not_of(_CharT __c, size_type __pos = 0) const
> ;
># 2141 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
>
>      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
># 2158 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_last_not_of(const _CharT* __s, size_type __pos,
>         size_type __n) const;
># 2172 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
>      {
> ;
> return this->find_last_not_of(__s, __pos, traits_type::length(__s));
>      }
># 2189 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      size_type
>      find_last_not_of(_CharT __c, size_type __pos = npos) const
> ;
># 2205 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      basic_string
>      substr(size_type __pos = 0, size_type __n = npos) const
>      { return basic_string(*this,
>       _M_check(__pos, "basic_string::substr"), __n); }
># 2224 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      int
>      compare(const basic_string& __str) const
>      {
> const size_type __size = this->size();
> const size_type __osize = __str.size();
> const size_type __len = std::min(__size, __osize);
>
> int __r = traits_type::compare(_M_data(), __str.data(), __len);
> if (!__r)
>   __r = _S_compare(__size, __osize);
> return __r;
>      }
># 2256 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      int
>      compare(size_type __pos, size_type __n, const basic_string& __str) const;
># 2282 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      int
>      compare(size_type __pos1, size_type __n1, const basic_string& __str,
>       size_type __pos2, size_type __n2) const;
># 2300 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      int
>      compare(const _CharT* __s) const;
># 2324 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      int
>      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
># 2351 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>      int
>      compare(size_type __pos, size_type __n1, const _CharT* __s,
>       size_type __n2) const;
>  };
># 2363 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>
>    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    {
>      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
>      __str.append(__rhs);
>      return __str;
>    }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT,_Traits,_Alloc>
>    operator+(const _CharT* __lhs,
>       const basic_string<_CharT,_Traits,_Alloc>& __rhs);
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT,_Traits,_Alloc>
>    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline basic_string<_CharT, _Traits, _Alloc>
>    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>      const _CharT* __rhs)
>    {
>      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
>      __str.append(__rhs);
>      return __str;
>    }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline basic_string<_CharT, _Traits, _Alloc>
>    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
>    {
>      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
>      typedef typename __string_type::size_type __size_type;
>      __string_type __str(__lhs);
>      __str.append(__size_type(1), __rhs);
>      return __str;
>    }
># 2484 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return __lhs.compare(__rhs) == 0; }
>
>  template<typename _CharT>
>    inline
>    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
>    operator==(const basic_string<_CharT>& __lhs,
>        const basic_string<_CharT>& __rhs)
>    { return (__lhs.size() == __rhs.size()
>       && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
>          __lhs.size())); }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator==(const _CharT* __lhs,
>        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return __rhs.compare(__lhs) == 0; }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>        const _CharT* __rhs)
>    { return __lhs.compare(__rhs) == 0; }
># 2530 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return !(__lhs == __rhs); }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator!=(const _CharT* __lhs,
>        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return !(__lhs == __rhs); }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>        const _CharT* __rhs)
>    { return !(__lhs == __rhs); }
># 2567 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return __lhs.compare(__rhs) < 0; }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>       const _CharT* __rhs)
>    { return __lhs.compare(__rhs) < 0; }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator<(const _CharT* __lhs,
>       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return __rhs.compare(__lhs) > 0; }
># 2604 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return __lhs.compare(__rhs) > 0; }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>       const _CharT* __rhs)
>    { return __lhs.compare(__rhs) > 0; }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator>(const _CharT* __lhs,
>       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return __rhs.compare(__lhs) < 0; }
># 2641 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return __lhs.compare(__rhs) <= 0; }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>        const _CharT* __rhs)
>    { return __lhs.compare(__rhs) <= 0; }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator<=(const _CharT* __lhs,
>        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return __rhs.compare(__lhs) >= 0; }
># 2678 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return __lhs.compare(__rhs) >= 0; }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
>        const _CharT* __rhs)
>    { return __lhs.compare(__rhs) >= 0; }
>
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline bool
>    operator>=(const _CharT* __lhs,
>      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { return __rhs.compare(__lhs) <= 0; }
># 2715 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline void
>    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
>  basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    { __lhs.swap(__rhs); }
># 2733 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_istream<_CharT, _Traits>&
>    operator>>(basic_istream<_CharT, _Traits>& __is,
>        basic_string<_CharT, _Traits, _Alloc>& __str);
>
>  template<>
>    basic_istream<char>&
>    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
># 2751 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline basic_ostream<_CharT, _Traits>&
>    operator<<(basic_ostream<_CharT, _Traits>& __os,
>        const basic_string<_CharT, _Traits, _Alloc>& __str)
>    {
>
>
>      return __ostream_insert(__os, __str.data(), __str.size());
>    }
># 2775 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_istream<_CharT, _Traits>&
>    getline(basic_istream<_CharT, _Traits>& __is,
>     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
># 2793 "/usr/include/c++/4.8.0/bits/basic_string.h" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    inline basic_istream<_CharT, _Traits>&
>    getline(basic_istream<_CharT, _Traits>& __is,
>     basic_string<_CharT, _Traits, _Alloc>& __str)
>    { return getline(__is, __str, __is.widen('\n')); }
>
>  template<>
>    basic_istream<char>&
>    getline(basic_istream<char>& __in, basic_string<char>& __str,
>     char __delim);
>
>
>  template<>
>    basic_istream<wchar_t>&
>    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
>     wchar_t __delim);
>
>
>
>}
># 53 "/usr/include/c++/4.8.0/string" 2 3
># 1 "/usr/include/c++/4.8.0/bits/basic_string.tcc" 1 3
># 40 "/usr/include/c++/4.8.0/bits/basic_string.tcc" 3
>       
># 41 "/usr/include/c++/4.8.0/bits/basic_string.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    const _CharT
>    basic_string<_CharT, _Traits, _Alloc>::
>    _Rep::_S_terminal = _CharT();
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::npos;
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
>    (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
>      sizeof(size_type)];
>
>
>
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    template<typename _InIterator>
>      _CharT*
>      basic_string<_CharT, _Traits, _Alloc>::
>      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
>     input_iterator_tag)
>      {
>
> if (__beg == __end && __a == _Alloc())
>   return _S_empty_rep()._M_refdata();
>
>
> _CharT __buf[128];
> size_type __len = 0;
> while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
>   {
>     __buf[__len++] = *__beg;
>     ++__beg;
>   }
> _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
> _M_copy(__r->_M_refdata(), __buf, __len);
> try
>   {
>     while (__beg != __end)
>       {
>  if (__len == __r->_M_capacity)
>    {
>
>      _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
>      _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
>      __r->_M_destroy(__a);
>      __r = __another;
>    }
>  __r->_M_refdata()[__len++] = *__beg;
>  ++__beg;
>       }
>   }
> catch(...)
>   {
>     __r->_M_destroy(__a);
>     throw;
>   }
> __r->_M_set_length_and_sharable(__len);
> return __r->_M_refdata();
>      }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    template <typename _InIterator>
>      _CharT*
>      basic_string<_CharT, _Traits, _Alloc>::
>      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
>     forward_iterator_tag)
>      {
>
> if (__beg == __end && __a == _Alloc())
>   return _S_empty_rep()._M_refdata();
>
>
> if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
>   __throw_logic_error(("basic_string::_S_construct null not valid"));
>
> const size_type __dnew = static_cast<size_type>(std::distance(__beg,
>              __end));
>
> _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
> try
>   { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
> catch(...)
>   {
>     __r->_M_destroy(__a);
>     throw;
>   }
> __r->_M_set_length_and_sharable(__dnew);
> return __r->_M_refdata();
>      }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    _CharT*
>    basic_string<_CharT, _Traits, _Alloc>::
>    _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
>    {
>
>      if (__n == 0 && __a == _Alloc())
> return _S_empty_rep()._M_refdata();
>
>
>      _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
>      if (__n)
> _M_assign(__r->_M_refdata(), __n, __c);
>
>      __r->_M_set_length_and_sharable(__n);
>      return __r->_M_refdata();
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>::
>    basic_string(const basic_string& __str)
>    : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
>       __str.get_allocator()),
>    __str.get_allocator())
>    { }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>::
>    basic_string(const _Alloc& __a)
>    : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
>    { }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>::
>    basic_string(const basic_string& __str, size_type __pos, size_type __n)
>    : _M_dataplus(_S_construct(__str._M_data()
>          + __str._M_check(__pos,
>      "basic_string::basic_string"),
>          __str._M_data() + __str._M_limit(__pos, __n)
>          + __pos, _Alloc()), _Alloc())
>    { }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>::
>    basic_string(const basic_string& __str, size_type __pos,
>   size_type __n, const _Alloc& __a)
>    : _M_dataplus(_S_construct(__str._M_data()
>          + __str._M_check(__pos,
>      "basic_string::basic_string"),
>          __str._M_data() + __str._M_limit(__pos, __n)
>          + __pos, __a), __a)
>    { }
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>::
>    basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
>    : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
>    { }
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>::
>    basic_string(const _CharT* __s, const _Alloc& __a)
>    : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
>          __s + npos, __a), __a)
>    { }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>::
>    basic_string(size_type __n, _CharT __c, const _Alloc& __a)
>    : _M_dataplus(_S_construct(__n, __c, __a), __a)
>    { }
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    template<typename _InputIterator>
>    basic_string<_CharT, _Traits, _Alloc>::
>    basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
>    : _M_dataplus(_S_construct(__beg, __end, __a), __a)
>    { }
># 240 "/usr/include/c++/4.8.0/bits/basic_string.tcc" 3
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>&
>    basic_string<_CharT, _Traits, _Alloc>::
>    assign(const basic_string& __str)
>    {
>      if (_M_rep() != __str._M_rep())
> {
>
>   const allocator_type __a = this->get_allocator();
>   _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
>   _M_rep()->_M_dispose(__a);
>   _M_data(__tmp);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>&
>    basic_string<_CharT, _Traits, _Alloc>::
>    assign(const _CharT* __s, size_type __n)
>    {
>      ;
>      _M_check_length(this->size(), __n, "basic_string::assign");
>      if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
> return _M_replace_safe(size_type(0), this->size(), __s, __n);
>      else
> {
>
>   const size_type __pos = __s - _M_data();
>   if (__pos >= __n)
>     _M_copy(_M_data(), __s, __n);
>   else if (__pos)
>     _M_move(_M_data(), __s, __n);
>   _M_rep()->_M_set_length_and_sharable(__n);
>   return *this;
> }
>     }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>&
>    basic_string<_CharT, _Traits, _Alloc>::
>    append(size_type __n, _CharT __c)
>    {
>      if (__n)
> {
>   _M_check_length(size_type(0), __n, "basic_string::append");
>   const size_type __len = __n + this->size();
>   if (__len > this->capacity() || _M_rep()->_M_is_shared())
>     this->reserve(__len);
>   _M_assign(_M_data() + this->size(), __n, __c);
>   _M_rep()->_M_set_length_and_sharable(__len);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>&
>    basic_string<_CharT, _Traits, _Alloc>::
>    append(const _CharT* __s, size_type __n)
>    {
>      ;
>      if (__n)
> {
>   _M_check_length(size_type(0), __n, "basic_string::append");
>   const size_type __len = __n + this->size();
>   if (__len > this->capacity() || _M_rep()->_M_is_shared())
>     {
>       if (_M_disjunct(__s))
>  this->reserve(__len);
>       else
>  {
>    const size_type __off = __s - _M_data();
>    this->reserve(__len);
>    __s = _M_data() + __off;
>  }
>     }
>   _M_copy(_M_data() + this->size(), __s, __n);
>   _M_rep()->_M_set_length_and_sharable(__len);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>&
>    basic_string<_CharT, _Traits, _Alloc>::
>    append(const basic_string& __str)
>    {
>      const size_type __size = __str.size();
>      if (__size)
> {
>   const size_type __len = __size + this->size();
>   if (__len > this->capacity() || _M_rep()->_M_is_shared())
>     this->reserve(__len);
>   _M_copy(_M_data() + this->size(), __str._M_data(), __size);
>   _M_rep()->_M_set_length_and_sharable(__len);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>&
>    basic_string<_CharT, _Traits, _Alloc>::
>    append(const basic_string& __str, size_type __pos, size_type __n)
>    {
>      __str._M_check(__pos, "basic_string::append");
>      __n = __str._M_limit(__pos, __n);
>      if (__n)
> {
>   const size_type __len = __n + this->size();
>   if (__len > this->capacity() || _M_rep()->_M_is_shared())
>     this->reserve(__len);
>   _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
>   _M_rep()->_M_set_length_and_sharable(__len);
> }
>      return *this;
>    }
>
>   template<typename _CharT, typename _Traits, typename _Alloc>
>     basic_string<_CharT, _Traits, _Alloc>&
>     basic_string<_CharT, _Traits, _Alloc>::
>     insert(size_type __pos, const _CharT* __s, size_type __n)
>     {
>       ;
>       _M_check(__pos, "basic_string::insert");
>       _M_check_length(size_type(0), __n, "basic_string::insert");
>       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
>         return _M_replace_safe(__pos, size_type(0), __s, __n);
>       else
>         {
>
>           const size_type __off = __s - _M_data();
>           _M_mutate(__pos, 0, __n);
>           __s = _M_data() + __off;
>           _CharT* __p = _M_data() + __pos;
>           if (__s + __n <= __p)
>             _M_copy(__p, __s, __n);
>           else if (__s >= __p)
>             _M_copy(__p, __s + __n, __n);
>           else
>             {
>        const size_type __nleft = __p - __s;
>               _M_copy(__p, __s, __nleft);
>               _M_copy(__p + __nleft, __p + __n, __n - __nleft);
>             }
>           return *this;
>         }
>     }
>
>   template<typename _CharT, typename _Traits, typename _Alloc>
>     typename basic_string<_CharT, _Traits, _Alloc>::iterator
>     basic_string<_CharT, _Traits, _Alloc>::
>     erase(iterator __first, iterator __last)
>     {
>      
>                           ;
>
>
>
>
>       const size_type __size = __last - __first;
>       if (__size)
>  {
>    const size_type __pos = __first - _M_ibegin();
>    _M_mutate(__pos, __size, size_type(0));
>    _M_rep()->_M_set_leaked();
>    return iterator(_M_data() + __pos);
>  }
>       else
>  return __first;
>     }
>
>   template<typename _CharT, typename _Traits, typename _Alloc>
>     basic_string<_CharT, _Traits, _Alloc>&
>     basic_string<_CharT, _Traits, _Alloc>::
>     replace(size_type __pos, size_type __n1, const _CharT* __s,
>      size_type __n2)
>     {
>       ;
>       _M_check(__pos, "basic_string::replace");
>       __n1 = _M_limit(__pos, __n1);
>       _M_check_length(__n1, __n2, "basic_string::replace");
>       bool __left;
>       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
>         return _M_replace_safe(__pos, __n1, __s, __n2);
>       else if ((__left = __s + __n2 <= _M_data() + __pos)
>  || _M_data() + __pos + __n1 <= __s)
>  {
>
>    size_type __off = __s - _M_data();
>    __left ? __off : (__off += __n2 - __n1);
>    _M_mutate(__pos, __n1, __n2);
>    _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
>    return *this;
>  }
>       else
>  {
>
>    const basic_string __tmp(__s, __n2);
>    return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
>  }
>     }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    void
>    basic_string<_CharT, _Traits, _Alloc>::_Rep::
>    _M_destroy(const _Alloc& __a) throw ()
>    {
>      const size_type __size = sizeof(_Rep_base) +
>                        (this->_M_capacity + 1) * sizeof(_CharT);
>      _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    void
>    basic_string<_CharT, _Traits, _Alloc>::
>    _M_leak_hard()
>    {
>
>      if (_M_rep() == &_S_empty_rep())
> return;
>
>      if (_M_rep()->_M_is_shared())
> _M_mutate(0, 0, 0);
>      _M_rep()->_M_set_leaked();
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    void
>    basic_string<_CharT, _Traits, _Alloc>::
>    _M_mutate(size_type __pos, size_type __len1, size_type __len2)
>    {
>      const size_type __old_size = this->size();
>      const size_type __new_size = __old_size + __len2 - __len1;
>      const size_type __how_much = __old_size - __pos - __len1;
>
>      if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
> {
>
>   const allocator_type __a = get_allocator();
>   _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
>
>   if (__pos)
>     _M_copy(__r->_M_refdata(), _M_data(), __pos);
>   if (__how_much)
>     _M_copy(__r->_M_refdata() + __pos + __len2,
>      _M_data() + __pos + __len1, __how_much);
>
>   _M_rep()->_M_dispose(__a);
>   _M_data(__r->_M_refdata());
> }
>      else if (__how_much && __len1 != __len2)
> {
>
>   _M_move(_M_data() + __pos + __len2,
>    _M_data() + __pos + __len1, __how_much);
> }
>      _M_rep()->_M_set_length_and_sharable(__new_size);
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    void
>    basic_string<_CharT, _Traits, _Alloc>::
>    reserve(size_type __res)
>    {
>      if (__res != this->capacity() || _M_rep()->_M_is_shared())
>        {
>
>   if (__res < this->size())
>     __res = this->size();
>   const allocator_type __a = get_allocator();
>   _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
>   _M_rep()->_M_dispose(__a);
>   _M_data(__tmp);
>        }
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    void
>    basic_string<_CharT, _Traits, _Alloc>::
>    swap(basic_string& __s)
>    {
>      if (_M_rep()->_M_is_leaked())
> _M_rep()->_M_set_sharable();
>      if (__s._M_rep()->_M_is_leaked())
> __s._M_rep()->_M_set_sharable();
>      if (this->get_allocator() == __s.get_allocator())
> {
>   _CharT* __tmp = _M_data();
>   _M_data(__s._M_data());
>   __s._M_data(__tmp);
> }
>
>      else
> {
>   const basic_string __tmp1(_M_ibegin(), _M_iend(),
>        __s.get_allocator());
>   const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
>        this->get_allocator());
>   *this = __tmp2;
>   __s = __tmp1;
> }
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
>    basic_string<_CharT, _Traits, _Alloc>::_Rep::
>    _S_create(size_type __capacity, size_type __old_capacity,
>       const _Alloc& __alloc)
>    {
>
>
>      if (__capacity > _S_max_size)
> __throw_length_error(("basic_string::_S_create"));
># 577 "/usr/include/c++/4.8.0/bits/basic_string.tcc" 3
>      const size_type __pagesize = 4096;
>      const size_type __malloc_header_size = 4 * sizeof(void*);
>
>
>
>
>
>
>
>      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
> __capacity = 2 * __old_capacity;
>
>
>
>
>      size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
>
>      const size_type __adj_size = __size + __malloc_header_size;
>      if (__adj_size > __pagesize && __capacity > __old_capacity)
> {
>   const size_type __extra = __pagesize - __adj_size % __pagesize;
>   __capacity += __extra / sizeof(_CharT);
>
>   if (__capacity > _S_max_size)
>     __capacity = _S_max_size;
>   __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
> }
>
>
>
>      void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
>      _Rep *__p = new (__place) _Rep;
>      __p->_M_capacity = __capacity;
>
>
>
>
>
>
>
>      __p->_M_set_sharable();
>      return __p;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    _CharT*
>    basic_string<_CharT, _Traits, _Alloc>::_Rep::
>    _M_clone(const _Alloc& __alloc, size_type __res)
>    {
>
>      const size_type __requested_cap = this->_M_length + __res;
>      _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
>      __alloc);
>      if (this->_M_length)
> _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
>
>      __r->_M_set_length_and_sharable(this->_M_length);
>      return __r->_M_refdata();
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    void
>    basic_string<_CharT, _Traits, _Alloc>::
>    resize(size_type __n, _CharT __c)
>    {
>      const size_type __size = this->size();
>      _M_check_length(__size, __n, "basic_string::resize");
>      if (__size < __n)
> this->append(__n - __size, __c);
>      else if (__n < __size)
> this->erase(__n);
>
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    template<typename _InputIterator>
>      basic_string<_CharT, _Traits, _Alloc>&
>      basic_string<_CharT, _Traits, _Alloc>::
>      _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
>     _InputIterator __k2, __false_type)
>      {
> const basic_string __s(__k1, __k2);
> const size_type __n1 = __i2 - __i1;
> _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
> return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
>          __s.size());
>      }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>&
>    basic_string<_CharT, _Traits, _Alloc>::
>    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
>     _CharT __c)
>    {
>      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
>      _M_mutate(__pos1, __n1, __n2);
>      if (__n2)
> _M_assign(_M_data() + __pos1, __n2, __c);
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>&
>    basic_string<_CharT, _Traits, _Alloc>::
>    _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
>      size_type __n2)
>    {
>      _M_mutate(__pos1, __n1, __n2);
>      if (__n2)
> _M_copy(_M_data() + __pos1, __s, __n2);
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>
>    operator+(const _CharT* __lhs,
>       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    {
>      ;
>      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
>      typedef typename __string_type::size_type __size_type;
>      const __size_type __len = _Traits::length(__lhs);
>      __string_type __str;
>      __str.reserve(__len + __rhs.size());
>      __str.append(__lhs, __len);
>      __str.append(__rhs);
>      return __str;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_string<_CharT, _Traits, _Alloc>
>    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
>    {
>      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
>      typedef typename __string_type::size_type __size_type;
>      __string_type __str;
>      const __size_type __len = __rhs.size();
>      __str.reserve(__len + 1);
>      __str.append(__size_type(1), __lhs);
>      __str.append(__rhs);
>      return __str;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    copy(_CharT* __s, size_type __n, size_type __pos) const
>    {
>      _M_check(__pos, "basic_string::copy");
>      __n = _M_limit(__pos, __n);
>      ;
>      if (__n)
> _M_copy(__s, _M_data() + __pos, __n);
>
>      return __n;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    find(const _CharT* __s, size_type __pos, size_type __n) const
>    {
>      ;
>      const size_type __size = this->size();
>      const _CharT* __data = _M_data();
>
>      if (__n == 0)
> return __pos <= __size ? __pos : npos;
>
>      if (__n <= __size)
> {
>   for (; __pos <= __size - __n; ++__pos)
>     if (traits_type::eq(__data[__pos], __s[0])
>  && traits_type::compare(__data + __pos + 1,
>     __s + 1, __n - 1) == 0)
>       return __pos;
> }
>      return npos;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    find(_CharT __c, size_type __pos) const
>    {
>      size_type __ret = npos;
>      const size_type __size = this->size();
>      if (__pos < __size)
> {
>   const _CharT* __data = _M_data();
>   const size_type __n = __size - __pos;
>   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
>   if (__p)
>     __ret = __p - __data;
> }
>      return __ret;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    rfind(const _CharT* __s, size_type __pos, size_type __n) const
>    {
>      ;
>      const size_type __size = this->size();
>      if (__n <= __size)
> {
>   __pos = std::min(size_type(__size - __n), __pos);
>   const _CharT* __data = _M_data();
>   do
>     {
>       if (traits_type::compare(__data + __pos, __s, __n) == 0)
>  return __pos;
>     }
>   while (__pos-- > 0);
> }
>      return npos;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    rfind(_CharT __c, size_type __pos) const
>    {
>      size_type __size = this->size();
>      if (__size)
> {
>   if (--__size > __pos)
>     __size = __pos;
>   for (++__size; __size-- > 0; )
>     if (traits_type::eq(_M_data()[__size], __c))
>       return __size;
> }
>      return npos;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
>    {
>      ;
>      for (; __n && __pos < this->size(); ++__pos)
> {
>   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
>   if (__p)
>     return __pos;
> }
>      return npos;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
>    {
>      ;
>      size_type __size = this->size();
>      if (__size && __n)
> {
>   if (--__size > __pos)
>     __size = __pos;
>   do
>     {
>       if (traits_type::find(__s, __n, _M_data()[__size]))
>  return __size;
>     }
>   while (__size-- != 0);
> }
>      return npos;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
>    {
>      ;
>      for (; __pos < this->size(); ++__pos)
> if (!traits_type::find(__s, __n, _M_data()[__pos]))
>   return __pos;
>      return npos;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    find_first_not_of(_CharT __c, size_type __pos) const
>    {
>      for (; __pos < this->size(); ++__pos)
> if (!traits_type::eq(_M_data()[__pos], __c))
>   return __pos;
>      return npos;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
>    {
>      ;
>      size_type __size = this->size();
>      if (__size)
> {
>   if (--__size > __pos)
>     __size = __pos;
>   do
>     {
>       if (!traits_type::find(__s, __n, _M_data()[__size]))
>  return __size;
>     }
>   while (__size--);
> }
>      return npos;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    typename basic_string<_CharT, _Traits, _Alloc>::size_type
>    basic_string<_CharT, _Traits, _Alloc>::
>    find_last_not_of(_CharT __c, size_type __pos) const
>    {
>      size_type __size = this->size();
>      if (__size)
> {
>   if (--__size > __pos)
>     __size = __pos;
>   do
>     {
>       if (!traits_type::eq(_M_data()[__size], __c))
>  return __size;
>     }
>   while (__size--);
> }
>      return npos;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    int
>    basic_string<_CharT, _Traits, _Alloc>::
>    compare(size_type __pos, size_type __n, const basic_string& __str) const
>    {
>      _M_check(__pos, "basic_string::compare");
>      __n = _M_limit(__pos, __n);
>      const size_type __osize = __str.size();
>      const size_type __len = std::min(__n, __osize);
>      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
>      if (!__r)
> __r = _S_compare(__n, __osize);
>      return __r;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    int
>    basic_string<_CharT, _Traits, _Alloc>::
>    compare(size_type __pos1, size_type __n1, const basic_string& __str,
>     size_type __pos2, size_type __n2) const
>    {
>      _M_check(__pos1, "basic_string::compare");
>      __str._M_check(__pos2, "basic_string::compare");
>      __n1 = _M_limit(__pos1, __n1);
>      __n2 = __str._M_limit(__pos2, __n2);
>      const size_type __len = std::min(__n1, __n2);
>      int __r = traits_type::compare(_M_data() + __pos1,
>         __str.data() + __pos2, __len);
>      if (!__r)
> __r = _S_compare(__n1, __n2);
>      return __r;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    int
>    basic_string<_CharT, _Traits, _Alloc>::
>    compare(const _CharT* __s) const
>    {
>      ;
>      const size_type __size = this->size();
>      const size_type __osize = traits_type::length(__s);
>      const size_type __len = std::min(__size, __osize);
>      int __r = traits_type::compare(_M_data(), __s, __len);
>      if (!__r)
> __r = _S_compare(__size, __osize);
>      return __r;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    int
>    basic_string <_CharT, _Traits, _Alloc>::
>    compare(size_type __pos, size_type __n1, const _CharT* __s) const
>    {
>      ;
>      _M_check(__pos, "basic_string::compare");
>      __n1 = _M_limit(__pos, __n1);
>      const size_type __osize = traits_type::length(__s);
>      const size_type __len = std::min(__n1, __osize);
>      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
>      if (!__r)
> __r = _S_compare(__n1, __osize);
>      return __r;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    int
>    basic_string <_CharT, _Traits, _Alloc>::
>    compare(size_type __pos, size_type __n1, const _CharT* __s,
>     size_type __n2) const
>    {
>      ;
>      _M_check(__pos, "basic_string::compare");
>      __n1 = _M_limit(__pos, __n1);
>      const size_type __len = std::min(__n1, __n2);
>      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
>      if (!__r)
> __r = _S_compare(__n1, __n2);
>      return __r;
>    }
>
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_istream<_CharT, _Traits>&
>    operator>>(basic_istream<_CharT, _Traits>& __in,
>        basic_string<_CharT, _Traits, _Alloc>& __str)
>    {
>      typedef basic_istream<_CharT, _Traits> __istream_type;
>      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
>      typedef typename __istream_type::ios_base __ios_base;
>      typedef typename __istream_type::int_type __int_type;
>      typedef typename __string_type::size_type __size_type;
>      typedef ctype<_CharT> __ctype_type;
>      typedef typename __ctype_type::ctype_base __ctype_base;
>
>      __size_type __extracted = 0;
>      typename __ios_base::iostate __err = __ios_base::goodbit;
>      typename __istream_type::sentry __cerb(__in, false);
>      if (__cerb)
> {
>   try
>     {
>
>       __str.erase();
>       _CharT __buf[128];
>       __size_type __len = 0;
>       const streamsize __w = __in.width();
>       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
>                                : __str.max_size();
>       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
>       const __int_type __eof = _Traits::eof();
>       __int_type __c = __in.rdbuf()->sgetc();
>
>       while (__extracted < __n
>       && !_Traits::eq_int_type(__c, __eof)
>       && !__ct.is(__ctype_base::space,
>     _Traits::to_char_type(__c)))
>  {
>    if (__len == sizeof(__buf) / sizeof(_CharT))
>      {
>        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
>        __len = 0;
>      }
>    __buf[__len++] = _Traits::to_char_type(__c);
>    ++__extracted;
>    __c = __in.rdbuf()->snextc();
>  }
>       __str.append(__buf, __len);
>
>       if (_Traits::eq_int_type(__c, __eof))
>  __err |= __ios_base::eofbit;
>       __in.width(0);
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       __in._M_setstate(__ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     {
>
>
>
>       __in._M_setstate(__ios_base::badbit);
>     }
> }
>
>      if (!__extracted)
> __err |= __ios_base::failbit;
>      if (__err)
> __in.setstate(__err);
>      return __in;
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    basic_istream<_CharT, _Traits>&
>    getline(basic_istream<_CharT, _Traits>& __in,
>     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
>    {
>      typedef basic_istream<_CharT, _Traits> __istream_type;
>      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
>      typedef typename __istream_type::ios_base __ios_base;
>      typedef typename __istream_type::int_type __int_type;
>      typedef typename __string_type::size_type __size_type;
>
>      __size_type __extracted = 0;
>      const __size_type __n = __str.max_size();
>      typename __ios_base::iostate __err = __ios_base::goodbit;
>      typename __istream_type::sentry __cerb(__in, true);
>      if (__cerb)
> {
>   try
>     {
>       __str.erase();
>       const __int_type __idelim = _Traits::to_int_type(__delim);
>       const __int_type __eof = _Traits::eof();
>       __int_type __c = __in.rdbuf()->sgetc();
>
>       while (__extracted < __n
>       && !_Traits::eq_int_type(__c, __eof)
>       && !_Traits::eq_int_type(__c, __idelim))
>  {
>    __str += _Traits::to_char_type(__c);
>    ++__extracted;
>    __c = __in.rdbuf()->snextc();
>  }
>
>       if (_Traits::eq_int_type(__c, __eof))
>  __err |= __ios_base::eofbit;
>       else if (_Traits::eq_int_type(__c, __idelim))
>  {
>    ++__extracted;
>    __in.rdbuf()->sbumpc();
>  }
>       else
>  __err |= __ios_base::failbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       __in._M_setstate(__ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     {
>
>
>
>       __in._M_setstate(__ios_base::badbit);
>     }
> }
>      if (!__extracted)
> __err |= __ios_base::failbit;
>      if (__err)
> __in.setstate(__err);
>      return __in;
>    }
>
>
>
>
>  extern template class basic_string<char>;
>  extern template
>    basic_istream<char>&
>    operator>>(basic_istream<char>&, string&);
>  extern template
>    basic_ostream<char>&
>    operator<<(basic_ostream<char>&, const string&);
>  extern template
>    basic_istream<char>&
>    getline(basic_istream<char>&, string&, char);
>  extern template
>    basic_istream<char>&
>    getline(basic_istream<char>&, string&);
>
>
>  extern template class basic_string<wchar_t>;
>  extern template
>    basic_istream<wchar_t>&
>    operator>>(basic_istream<wchar_t>&, wstring&);
>  extern template
>    basic_ostream<wchar_t>&
>    operator<<(basic_ostream<wchar_t>&, const wstring&);
>  extern template
>    basic_istream<wchar_t>&
>    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
>  extern template
>    basic_istream<wchar_t>&
>    getline(basic_istream<wchar_t>&, wstring&);
>
>
>
>
>}
># 54 "/usr/include/c++/4.8.0/string" 2 3
># 10 "../src/CoinError.hpp" 2
># 1 "/usr/include/c++/4.8.0/iostream" 1 3
># 36 "/usr/include/c++/4.8.0/iostream" 3
>       
># 37 "/usr/include/c++/4.8.0/iostream" 3
>
>
># 1 "/usr/include/c++/4.8.0/ostream" 1 3
># 36 "/usr/include/c++/4.8.0/ostream" 3
>       
># 37 "/usr/include/c++/4.8.0/ostream" 3
>
># 1 "/usr/include/c++/4.8.0/ios" 1 3
># 36 "/usr/include/c++/4.8.0/ios" 3
>       
># 37 "/usr/include/c++/4.8.0/ios" 3
>
>
>
>
>
># 1 "/usr/include/c++/4.8.0/bits/ios_base.h" 1 3
># 37 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>
>
>
># 1 "/usr/include/c++/4.8.0/bits/locale_classes.h" 1 3
># 37 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 62 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>  class locale
>  {
>  public:
>
>
>    typedef int category;
>
>
>    class facet;
>    class id;
>    class _Impl;
>
>    friend class facet;
>    friend class _Impl;
>
>    template<typename _Facet>
>      friend bool
>      has_facet(const locale&) throw();
>
>    template<typename _Facet>
>      friend const _Facet&
>      use_facet(const locale&);
>
>    template<typename _Cache>
>      friend struct __use_cache;
># 98 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    static const category none = 0;
>    static const category ctype = 1L << 0;
>    static const category numeric = 1L << 1;
>    static const category collate = 1L << 2;
>    static const category time = 1L << 3;
>    static const category monetary = 1L << 4;
>    static const category messages = 1L << 5;
>    static const category all = (ctype | numeric | collate |
>        time | monetary | messages);
># 117 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    locale() throw();
># 126 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    locale(const locale& __other) throw();
># 136 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    explicit
>    locale(const char* __s);
># 151 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    locale(const locale& __base, const char* __s, category __cat);
># 164 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    locale(const locale& __base, const locale& __add, category __cat);
># 177 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    template<typename _Facet>
>      locale(const locale& __other, _Facet* __f);
>
>
>    ~locale() throw();
># 191 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    const locale&
>    operator=(const locale& __other) throw();
># 206 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    template<typename _Facet>
>      locale
>      combine(const locale& __other) const;
>
>
>
>
>
>
>    string
>    name() const;
># 225 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    bool
>    operator==(const locale& __other) const throw();
>
>
>
>
>
>
>
>    bool
>    operator!=(const locale& __other) const throw()
>    { return !(this->operator==(__other)); }
># 253 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    template<typename _Char, typename _Traits, typename _Alloc>
>      bool
>      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
>   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
># 269 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    static locale
>    global(const locale& __loc);
>
>
>
>
>    static const locale&
>    classic();
>
>  private:
>
>    _Impl* _M_impl;
>
>
>    static _Impl* _S_classic;
>
>
>    static _Impl* _S_global;
>
>
>
>
>
>    static const char* const* const _S_categories;
># 304 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    enum { _S_categories_size = 6 + 6 };
>
>
>    static __gthread_once_t _S_once;
>
>
>    explicit
>    locale(_Impl*) throw();
>
>    static void
>    _S_initialize();
>
>    static void
>    _S_initialize_once() throw();
>
>    static category
>    _S_normalize_category(category);
>
>    void
>    _M_coalesce(const locale& __base, const locale& __add, category __cat);
>  };
># 338 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>  class locale::facet
>  {
>  private:
>    friend class locale;
>    friend class locale::_Impl;
>
>    mutable _Atomic_word _M_refcount;
>
>
>    static __c_locale _S_c_locale;
>
>
>    static const char _S_c_name[2];
>
>
>    static __gthread_once_t _S_once;
>
>
>    static void
>    _S_initialize_once();
>
>  protected:
># 369 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>    explicit
>    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
>    { }
>
>
>    virtual
>    ~facet();
>
>    static void
>    _S_create_c_locale(__c_locale& __cloc, const char* __s,
>         __c_locale __old = 0);
>
>    static __c_locale
>    _S_clone_c_locale(__c_locale& __cloc) throw();
>
>    static void
>    _S_destroy_c_locale(__c_locale& __cloc);
>
>    static __c_locale
>    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
>
>
>
>    static __c_locale
>    _S_get_c_locale();
>
>    __attribute__ ((__const__)) static const char*
>    _S_get_c_name() throw();
>
>  private:
>    void
>    _M_add_reference() const throw()
>    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
>
>    void
>    _M_remove_reference() const throw()
>    {
>
>      ;
>      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
> {
>          ;
>   try
>     { delete this; }
>   catch(...)
>     { }
> }
>    }
>
>    facet(const facet&);
>
>    facet&
>    operator=(const facet&);
>  };
># 436 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>  class locale::id
>  {
>  private:
>    friend class locale;
>    friend class locale::_Impl;
>
>    template<typename _Facet>
>      friend const _Facet&
>      use_facet(const locale&);
>
>    template<typename _Facet>
>      friend bool
>      has_facet(const locale&) throw();
>
>
>
>
>    mutable size_t _M_index;
>
>
>    static _Atomic_word _S_refcount;
>
>    void
>    operator=(const id&);
>
>    id(const id&);
>
>  public:
>
>
>
>    id() { }
>
>    size_t
>    _M_id() const throw();
>  };
>
>
>
>  class locale::_Impl
>  {
>  public:
>
>    friend class locale;
>    friend class locale::facet;
>
>    template<typename _Facet>
>      friend bool
>      has_facet(const locale&) throw();
>
>    template<typename _Facet>
>      friend const _Facet&
>      use_facet(const locale&);
>
>    template<typename _Cache>
>      friend struct __use_cache;
>
>  private:
>
>    _Atomic_word _M_refcount;
>    const facet** _M_facets;
>    size_t _M_facets_size;
>    const facet** _M_caches;
>    char** _M_names;
>    static const locale::id* const _S_id_ctype[];
>    static const locale::id* const _S_id_numeric[];
>    static const locale::id* const _S_id_collate[];
>    static const locale::id* const _S_id_time[];
>    static const locale::id* const _S_id_monetary[];
>    static const locale::id* const _S_id_messages[];
>    static const locale::id* const* const _S_facet_categories[];
>
>    void
>    _M_add_reference() throw()
>    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
>
>    void
>    _M_remove_reference() throw()
>    {
>
>      ;
>      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
> {
>          ;
>   try
>     { delete this; }
>   catch(...)
>     { }
> }
>    }
>
>    _Impl(const _Impl&, size_t);
>    _Impl(const char*, size_t);
>    _Impl(size_t) throw();
>
>   ~_Impl() throw();
>
>    _Impl(const _Impl&);
>
>    void
>    operator=(const _Impl&);
>
>    bool
>    _M_check_same_name()
>    {
>      bool __ret = true;
>      if (_M_names[1])
>
> for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
>   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
>      return __ret;
>    }
>
>    void
>    _M_replace_categories(const _Impl*, category);
>
>    void
>    _M_replace_category(const _Impl*, const locale::id* const*);
>
>    void
>    _M_replace_facet(const _Impl*, const locale::id*);
>
>    void
>    _M_install_facet(const locale::id*, const facet*);
>
>    template<typename _Facet>
>      void
>      _M_init_facet(_Facet* __facet)
>      { _M_install_facet(&_Facet::id, __facet); }
>
>    void
>    _M_install_cache(const facet*, size_t);
>  };
># 583 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>  template<typename _CharT>
>    class collate : public locale::facet
>    {
>    public:
>
>
>
>      typedef _CharT char_type;
>      typedef basic_string<_CharT> string_type;
>
>
>    protected:
>
>
>      __c_locale _M_c_locale_collate;
>
>    public:
>
>      static locale::id id;
># 610 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>      explicit
>      collate(size_t __refs = 0)
>      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
>      { }
># 624 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>      explicit
>      collate(__c_locale __cloc, size_t __refs = 0)
>      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
>      { }
># 641 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>      int
>      compare(const _CharT* __lo1, const _CharT* __hi1,
>       const _CharT* __lo2, const _CharT* __hi2) const
>      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
># 660 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>      string_type
>      transform(const _CharT* __lo, const _CharT* __hi) const
>      { return this->do_transform(__lo, __hi); }
># 674 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>      long
>      hash(const _CharT* __lo, const _CharT* __hi) const
>      { return this->do_hash(__lo, __hi); }
>
>
>      int
>      _M_compare(const _CharT*, const _CharT*) const throw();
>
>      size_t
>      _M_transform(_CharT*, const _CharT*, size_t) const throw();
>
>  protected:
>
>      virtual
>      ~collate()
>      { _S_destroy_c_locale(_M_c_locale_collate); }
># 703 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>      virtual int
>      do_compare(const _CharT* __lo1, const _CharT* __hi1,
>   const _CharT* __lo2, const _CharT* __hi2) const;
># 717 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>      virtual string_type
>      do_transform(const _CharT* __lo, const _CharT* __hi) const;
># 730 "/usr/include/c++/4.8.0/bits/locale_classes.h" 3
>      virtual long
>      do_hash(const _CharT* __lo, const _CharT* __hi) const;
>    };
>
>  template<typename _CharT>
>    locale::id collate<_CharT>::id;
>
>
>  template<>
>    int
>    collate<char>::_M_compare(const char*, const char*) const throw();
>
>  template<>
>    size_t
>    collate<char>::_M_transform(char*, const char*, size_t) const throw();
>
>
>  template<>
>    int
>    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
>
>  template<>
>    size_t
>    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
>
>
>
>  template<typename _CharT>
>    class collate_byname : public collate<_CharT>
>    {
>    public:
>
>
>      typedef _CharT char_type;
>      typedef basic_string<_CharT> string_type;
>
>
>      explicit
>      collate_byname(const char* __s, size_t __refs = 0)
>      : collate<_CharT>(__refs)
>      {
> if (__builtin_strcmp(__s, "C") != 0
>     && __builtin_strcmp(__s, "POSIX") != 0)
>   {
>     this->_S_destroy_c_locale(this->_M_c_locale_collate);
>     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
>   }
>      }
>
>    protected:
>      virtual
>      ~collate_byname() { }
>    };
>
>
>}
>
># 1 "/usr/include/c++/4.8.0/bits/locale_classes.tcc" 1 3
># 37 "/usr/include/c++/4.8.0/bits/locale_classes.tcc" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/locale_classes.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _Facet>
>    locale::
>    locale(const locale& __other, _Facet* __f)
>    {
>      _M_impl = new _Impl(*__other._M_impl, 1);
>
>      try
> { _M_impl->_M_install_facet(&_Facet::id, __f); }
>      catch(...)
> {
>   _M_impl->_M_remove_reference();
>   throw;
> }
>      delete [] _M_impl->_M_names[0];
>      _M_impl->_M_names[0] = 0;
>    }
>
>  template<typename _Facet>
>    locale
>    locale::
>    combine(const locale& __other) const
>    {
>      _Impl* __tmp = new _Impl(*_M_impl, 1);
>      try
> {
>   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
> }
>      catch(...)
> {
>   __tmp->_M_remove_reference();
>   throw;
> }
>      return locale(__tmp);
>    }
>
>  template<typename _CharT, typename _Traits, typename _Alloc>
>    bool
>    locale::
>    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
>        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
>    {
>      typedef std::collate<_CharT> __collate_type;
>      const __collate_type& __collate = use_facet<__collate_type>(*this);
>      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
>    __s2.data(), __s2.data() + __s2.length()) < 0);
>    }
># 102 "/usr/include/c++/4.8.0/bits/locale_classes.tcc" 3
>  template<typename _Facet>
>    bool
>    has_facet(const locale& __loc) throw()
>    {
>      const size_t __i = _Facet::id._M_id();
>      const locale::facet** __facets = __loc._M_impl->_M_facets;
>      return (__i < __loc._M_impl->_M_facets_size
>
>       && dynamic_cast<const _Facet*>(__facets[__i]));
>
>
>
>    }
># 130 "/usr/include/c++/4.8.0/bits/locale_classes.tcc" 3
>  template<typename _Facet>
>    const _Facet&
>    use_facet(const locale& __loc)
>    {
>      const size_t __i = _Facet::id._M_id();
>      const locale::facet** __facets = __loc._M_impl->_M_facets;
>      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
>        __throw_bad_cast();
>
>      return dynamic_cast<const _Facet&>(*__facets[__i]);
>
>
>
>    }
>
>
>
>  template<typename _CharT>
>    int
>    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
>    { return 0; }
>
>
>  template<typename _CharT>
>    size_t
>    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
>    { return 0; }
>
>  template<typename _CharT>
>    int
>    collate<_CharT>::
>    do_compare(const _CharT* __lo1, const _CharT* __hi1,
>        const _CharT* __lo2, const _CharT* __hi2) const
>    {
>
>
>      const string_type __one(__lo1, __hi1);
>      const string_type __two(__lo2, __hi2);
>
>      const _CharT* __p = __one.c_str();
>      const _CharT* __pend = __one.data() + __one.length();
>      const _CharT* __q = __two.c_str();
>      const _CharT* __qend = __two.data() + __two.length();
>
>
>
>
>      for (;;)
> {
>   const int __res = _M_compare(__p, __q);
>   if (__res)
>     return __res;
>
>   __p += char_traits<_CharT>::length(__p);
>   __q += char_traits<_CharT>::length(__q);
>   if (__p == __pend && __q == __qend)
>     return 0;
>   else if (__p == __pend)
>     return -1;
>   else if (__q == __qend)
>     return 1;
>
>   __p++;
>   __q++;
> }
>    }
>
>  template<typename _CharT>
>    typename collate<_CharT>::string_type
>    collate<_CharT>::
>    do_transform(const _CharT* __lo, const _CharT* __hi) const
>    {
>      string_type __ret;
>
>
>      const string_type __str(__lo, __hi);
>
>      const _CharT* __p = __str.c_str();
>      const _CharT* __pend = __str.data() + __str.length();
>
>      size_t __len = (__hi - __lo) * 2;
>
>      _CharT* __c = new _CharT[__len];
>
>      try
> {
>
>
>
>   for (;;)
>     {
>
>       size_t __res = _M_transform(__c, __p, __len);
>
>
>       if (__res >= __len)
>  {
>    __len = __res + 1;
>    delete [] __c, __c = 0;
>    __c = new _CharT[__len];
>    __res = _M_transform(__c, __p, __len);
>  }
>
>       __ret.append(__c, __res);
>       __p += char_traits<_CharT>::length(__p);
>       if (__p == __pend)
>  break;
>
>       __p++;
>       __ret.push_back(_CharT());
>     }
> }
>      catch(...)
> {
>   delete [] __c;
>   throw;
> }
>
>      delete [] __c;
>
>      return __ret;
>    }
>
>  template<typename _CharT>
>    long
>    collate<_CharT>::
>    do_hash(const _CharT* __lo, const _CharT* __hi) const
>    {
>      unsigned long __val = 0;
>      for (; __lo < __hi; ++__lo)
> __val =
>   *__lo + ((__val << 7)
>     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
>    __digits - 7)));
>      return static_cast<long>(__val);
>    }
>
>
>
>
>  extern template class collate<char>;
>  extern template class collate_byname<char>;
>
>  extern template
>    const collate<char>&
>    use_facet<collate<char> >(const locale&);
>
>  extern template
>    bool
>    has_facet<collate<char> >(const locale&);
>
>
>  extern template class collate<wchar_t>;
>  extern template class collate_byname<wchar_t>;
>
>  extern template
>    const collate<wchar_t>&
>    use_facet<collate<wchar_t> >(const locale&);
>
>  extern template
>    bool
>    has_facet<collate<wchar_t> >(const locale&);
>
>
>
>
>}
># 788 "/usr/include/c++/4.8.0/bits/locale_classes.h" 2 3
># 42 "/usr/include/c++/4.8.0/bits/ios_base.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>  enum _Ios_Fmtflags
>    {
>      _S_boolalpha = 1L << 0,
>      _S_dec = 1L << 1,
>      _S_fixed = 1L << 2,
>      _S_hex = 1L << 3,
>      _S_internal = 1L << 4,
>      _S_left = 1L << 5,
>      _S_oct = 1L << 6,
>      _S_right = 1L << 7,
>      _S_scientific = 1L << 8,
>      _S_showbase = 1L << 9,
>      _S_showpoint = 1L << 10,
>      _S_showpos = 1L << 11,
>      _S_skipws = 1L << 12,
>      _S_unitbuf = 1L << 13,
>      _S_uppercase = 1L << 14,
>      _S_adjustfield = _S_left | _S_right | _S_internal,
>      _S_basefield = _S_dec | _S_oct | _S_hex,
>      _S_floatfield = _S_scientific | _S_fixed,
>      _S_ios_fmtflags_end = 1L << 16
>    };
>
>  inline _Ios_Fmtflags
>  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
>  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
>
>  inline _Ios_Fmtflags
>  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
>  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
>
>  inline _Ios_Fmtflags
>  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
>  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
>  inline _Ios_Fmtflags
>  operator~(_Ios_Fmtflags __a)
>  { return _Ios_Fmtflags(~static_cast<int>(__a)); }
>
>  inline const _Ios_Fmtflags&
>  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
>  { return __a = __a | __b; }
>
>  inline const _Ios_Fmtflags&
>  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
>  { return __a = __a & __b; }
>
>  inline const _Ios_Fmtflags&
>  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
>  { return __a = __a ^ __b; }
>
>
>  enum _Ios_Openmode
>    {
>      _S_app = 1L << 0,
>      _S_ate = 1L << 1,
>      _S_bin = 1L << 2,
>      _S_in = 1L << 3,
>      _S_out = 1L << 4,
>      _S_trunc = 1L << 5,
>      _S_ios_openmode_end = 1L << 16
>    };
>
>  inline _Ios_Openmode
>  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
>  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
>
>  inline _Ios_Openmode
>  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
>  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
>
>  inline _Ios_Openmode
>  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
>  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
>  inline _Ios_Openmode
>  operator~(_Ios_Openmode __a)
>  { return _Ios_Openmode(~static_cast<int>(__a)); }
>
>  inline const _Ios_Openmode&
>  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
>  { return __a = __a | __b; }
>
>  inline const _Ios_Openmode&
>  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
>  { return __a = __a & __b; }
>
>  inline const _Ios_Openmode&
>  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
>  { return __a = __a ^ __b; }
>
>
>  enum _Ios_Iostate
>    {
>      _S_goodbit = 0,
>      _S_badbit = 1L << 0,
>      _S_eofbit = 1L << 1,
>      _S_failbit = 1L << 2,
>      _S_ios_iostate_end = 1L << 16
>    };
>
>  inline _Ios_Iostate
>  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
>  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
>
>  inline _Ios_Iostate
>  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
>  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
>
>  inline _Ios_Iostate
>  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
>  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
>  inline _Ios_Iostate
>  operator~(_Ios_Iostate __a)
>  { return _Ios_Iostate(~static_cast<int>(__a)); }
>
>  inline const _Ios_Iostate&
>  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
>  { return __a = __a | __b; }
>
>  inline const _Ios_Iostate&
>  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
>  { return __a = __a & __b; }
>
>  inline const _Ios_Iostate&
>  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
>  { return __a = __a ^ __b; }
>
>
>  enum _Ios_Seekdir
>    {
>      _S_beg = 0,
>      _S_cur = 1,
>      _S_end = 2,
>      _S_ios_seekdir_end = 1L << 16
>    };
># 199 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>  class ios_base
>  {
>  public:
>
>
>
>
>
>
>
>    class failure : public exception
>    {
>    public:
>
>
>      explicit
>      failure(const string& __str) throw();
>
>
>
>      virtual
>      ~failure() throw();
>
>      virtual const char*
>      what() const throw();
>
>    private:
>      string _M_msg;
>    };
># 255 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    typedef _Ios_Fmtflags fmtflags;
>
>
>    static const fmtflags boolalpha = _S_boolalpha;
>
>
>    static const fmtflags dec = _S_dec;
>
>
>    static const fmtflags fixed = _S_fixed;
>
>
>    static const fmtflags hex = _S_hex;
>
>
>
>
>    static const fmtflags internal = _S_internal;
>
>
>
>    static const fmtflags left = _S_left;
>
>
>    static const fmtflags oct = _S_oct;
>
>
>
>    static const fmtflags right = _S_right;
>
>
>    static const fmtflags scientific = _S_scientific;
>
>
>
>    static const fmtflags showbase = _S_showbase;
>
>
>
>    static const fmtflags showpoint = _S_showpoint;
>
>
>    static const fmtflags showpos = _S_showpos;
>
>
>    static const fmtflags skipws = _S_skipws;
>
>
>    static const fmtflags unitbuf = _S_unitbuf;
>
>
>
>    static const fmtflags uppercase = _S_uppercase;
>
>
>    static const fmtflags adjustfield = _S_adjustfield;
>
>
>    static const fmtflags basefield = _S_basefield;
>
>
>    static const fmtflags floatfield = _S_floatfield;
># 330 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    typedef _Ios_Iostate iostate;
>
>
>
>    static const iostate badbit = _S_badbit;
>
>
>    static const iostate eofbit = _S_eofbit;
>
>
>
>
>    static const iostate failbit = _S_failbit;
>
>
>    static const iostate goodbit = _S_goodbit;
># 361 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    typedef _Ios_Openmode openmode;
>
>
>    static const openmode app = _S_app;
>
>
>    static const openmode ate = _S_ate;
>
>
>
>
>    static const openmode binary = _S_bin;
>
>
>    static const openmode in = _S_in;
>
>
>    static const openmode out = _S_out;
>
>
>    static const openmode trunc = _S_trunc;
># 393 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    typedef _Ios_Seekdir seekdir;
>
>
>    static const seekdir beg = _S_beg;
>
>
>    static const seekdir cur = _S_cur;
>
>
>    static const seekdir end = _S_end;
>
>
>    typedef int io_state;
>    typedef int open_mode;
>    typedef int seek_dir;
>
>    typedef std::streampos streampos;
>    typedef std::streamoff streamoff;
># 419 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    enum event
>    {
>      erase_event,
>      imbue_event,
>      copyfmt_event
>    };
># 436 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
># 448 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    void
>    register_callback(event_callback __fn, int __index);
>
>  protected:
>    streamsize _M_precision;
>    streamsize _M_width;
>    fmtflags _M_flags;
>    iostate _M_exception;
>    iostate _M_streambuf_state;
>
>
>
>    struct _Callback_list
>    {
>
>      _Callback_list* _M_next;
>      ios_base::event_callback _M_fn;
>      int _M_index;
>      _Atomic_word _M_refcount;
>
>      _Callback_list(ios_base::event_callback __fn, int __index,
>       _Callback_list* __cb)
>      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
>
>      void
>      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
>
>
>      int
>      _M_remove_reference()
>      {
>
>        ;
>        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
>        if (__res == 0)
>          {
>            ;
>          }
>        return __res;
>      }
>    };
>
>     _Callback_list* _M_callbacks;
>
>    void
>    _M_call_callbacks(event __ev) throw();
>
>    void
>    _M_dispose_callbacks(void) throw();
>
>
>    struct _Words
>    {
>      void* _M_pword;
>      long _M_iword;
>      _Words() : _M_pword(0), _M_iword(0) { }
>    };
>
>
>    _Words _M_word_zero;
>
>
>
>    enum { _S_local_word_size = 8 };
>    _Words _M_local_word[_S_local_word_size];
>
>
>    int _M_word_size;
>    _Words* _M_word;
>
>    _Words&
>    _M_grow_words(int __index, bool __iword);
>
>
>    locale _M_ios_locale;
>
>    void
>    _M_init() throw();
>
>  public:
>
>
>
>
>
>    class Init
>    {
>      friend class ios_base;
>    public:
>      Init();
>      ~Init();
>
>    private:
>      static _Atomic_word _S_refcount;
>      static bool _S_synced_with_stdio;
>    };
>
>
>
>
>
>
>    fmtflags
>    flags() const
>    { return _M_flags; }
># 561 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    fmtflags
>    flags(fmtflags __fmtfl)
>    {
>      fmtflags __old = _M_flags;
>      _M_flags = __fmtfl;
>      return __old;
>    }
># 577 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    fmtflags
>    setf(fmtflags __fmtfl)
>    {
>      fmtflags __old = _M_flags;
>      _M_flags |= __fmtfl;
>      return __old;
>    }
># 594 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    fmtflags
>    setf(fmtflags __fmtfl, fmtflags __mask)
>    {
>      fmtflags __old = _M_flags;
>      _M_flags &= ~__mask;
>      _M_flags |= (__fmtfl & __mask);
>      return __old;
>    }
>
>
>
>
>
>
>
>    void
>    unsetf(fmtflags __mask)
>    { _M_flags &= ~__mask; }
># 620 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    streamsize
>    precision() const
>    { return _M_precision; }
>
>
>
>
>
>
>    streamsize
>    precision(streamsize __prec)
>    {
>      streamsize __old = _M_precision;
>      _M_precision = __prec;
>      return __old;
>    }
>
>
>
>
>
>
>
>    streamsize
>    width() const
>    { return _M_width; }
>
>
>
>
>
>
>    streamsize
>    width(streamsize __wide)
>    {
>      streamsize __old = _M_width;
>      _M_width = __wide;
>      return __old;
>    }
># 671 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    static bool
>    sync_with_stdio(bool __sync = true);
># 683 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    locale
>    imbue(const locale& __loc) throw();
># 694 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    locale
>    getloc() const
>    { return _M_ios_locale; }
># 705 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    const locale&
>    _M_getloc() const
>    { return _M_ios_locale; }
># 724 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    static int
>    xalloc() throw();
># 740 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    long&
>    iword(int __ix)
>    {
>      _Words& __word = (__ix < _M_word_size)
>   ? _M_word[__ix] : _M_grow_words(__ix, true);
>      return __word._M_iword;
>    }
># 761 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    void*&
>    pword(int __ix)
>    {
>      _Words& __word = (__ix < _M_word_size)
>   ? _M_word[__ix] : _M_grow_words(__ix, false);
>      return __word._M_pword;
>    }
># 778 "/usr/include/c++/4.8.0/bits/ios_base.h" 3
>    virtual ~ios_base();
>
>  protected:
>    ios_base() throw ();
>
>
>
>  private:
>    ios_base(const ios_base&);
>
>    ios_base&
>    operator=(const ios_base&);
>  };
>
>
>
>  inline ios_base&
>  boolalpha(ios_base& __base)
>  {
>    __base.setf(ios_base::boolalpha);
>    return __base;
>  }
>
>
>  inline ios_base&
>  noboolalpha(ios_base& __base)
>  {
>    __base.unsetf(ios_base::boolalpha);
>    return __base;
>  }
>
>
>  inline ios_base&
>  showbase(ios_base& __base)
>  {
>    __base.setf(ios_base::showbase);
>    return __base;
>  }
>
>
>  inline ios_base&
>  noshowbase(ios_base& __base)
>  {
>    __base.unsetf(ios_base::showbase);
>    return __base;
>  }
>
>
>  inline ios_base&
>  showpoint(ios_base& __base)
>  {
>    __base.setf(ios_base::showpoint);
>    return __base;
>  }
>
>
>  inline ios_base&
>  noshowpoint(ios_base& __base)
>  {
>    __base.unsetf(ios_base::showpoint);
>    return __base;
>  }
>
>
>  inline ios_base&
>  showpos(ios_base& __base)
>  {
>    __base.setf(ios_base::showpos);
>    return __base;
>  }
>
>
>  inline ios_base&
>  noshowpos(ios_base& __base)
>  {
>    __base.unsetf(ios_base::showpos);
>    return __base;
>  }
>
>
>  inline ios_base&
>  skipws(ios_base& __base)
>  {
>    __base.setf(ios_base::skipws);
>    return __base;
>  }
>
>
>  inline ios_base&
>  noskipws(ios_base& __base)
>  {
>    __base.unsetf(ios_base::skipws);
>    return __base;
>  }
>
>
>  inline ios_base&
>  uppercase(ios_base& __base)
>  {
>    __base.setf(ios_base::uppercase);
>    return __base;
>  }
>
>
>  inline ios_base&
>  nouppercase(ios_base& __base)
>  {
>    __base.unsetf(ios_base::uppercase);
>    return __base;
>  }
>
>
>  inline ios_base&
>  unitbuf(ios_base& __base)
>  {
>     __base.setf(ios_base::unitbuf);
>     return __base;
>  }
>
>
>  inline ios_base&
>  nounitbuf(ios_base& __base)
>  {
>     __base.unsetf(ios_base::unitbuf);
>     return __base;
>  }
>
>
>
>  inline ios_base&
>  internal(ios_base& __base)
>  {
>     __base.setf(ios_base::internal, ios_base::adjustfield);
>     return __base;
>  }
>
>
>  inline ios_base&
>  left(ios_base& __base)
>  {
>    __base.setf(ios_base::left, ios_base::adjustfield);
>    return __base;
>  }
>
>
>  inline ios_base&
>  right(ios_base& __base)
>  {
>    __base.setf(ios_base::right, ios_base::adjustfield);
>    return __base;
>  }
>
>
>
>  inline ios_base&
>  dec(ios_base& __base)
>  {
>    __base.setf(ios_base::dec, ios_base::basefield);
>    return __base;
>  }
>
>
>  inline ios_base&
>  hex(ios_base& __base)
>  {
>    __base.setf(ios_base::hex, ios_base::basefield);
>    return __base;
>  }
>
>
>  inline ios_base&
>  oct(ios_base& __base)
>  {
>    __base.setf(ios_base::oct, ios_base::basefield);
>    return __base;
>  }
>
>
>
>  inline ios_base&
>  fixed(ios_base& __base)
>  {
>    __base.setf(ios_base::fixed, ios_base::floatfield);
>    return __base;
>  }
>
>
>  inline ios_base&
>  scientific(ios_base& __base)
>  {
>    __base.setf(ios_base::scientific, ios_base::floatfield);
>    return __base;
>  }
>
>
>}
># 43 "/usr/include/c++/4.8.0/ios" 2 3
># 1 "/usr/include/c++/4.8.0/streambuf" 1 3
># 36 "/usr/include/c++/4.8.0/streambuf" 3
>       
># 37 "/usr/include/c++/4.8.0/streambuf" 3
># 45 "/usr/include/c++/4.8.0/streambuf" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _CharT, typename _Traits>
>    streamsize
>    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
>     basic_streambuf<_CharT, _Traits>*, bool&);
># 119 "/usr/include/c++/4.8.0/streambuf" 3
>  template<typename _CharT, typename _Traits>
>    class basic_streambuf
>    {
>    public:
>
>
>
>
>
>
>      typedef _CharT char_type;
>      typedef _Traits traits_type;
>      typedef typename traits_type::int_type int_type;
>      typedef typename traits_type::pos_type pos_type;
>      typedef typename traits_type::off_type off_type;
>
>
>
>
>      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
>
>
>      friend class basic_ios<char_type, traits_type>;
>      friend class basic_istream<char_type, traits_type>;
>      friend class basic_ostream<char_type, traits_type>;
>      friend class istreambuf_iterator<char_type, traits_type>;
>      friend class ostreambuf_iterator<char_type, traits_type>;
>
>      friend streamsize
>      __copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&);
>
>      template<bool _IsMove, typename _CharT2>
>        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
>            _CharT2*>::__type
>        __copy_move_a2(istreambuf_iterator<_CharT2>,
>         istreambuf_iterator<_CharT2>, _CharT2*);
>
>      template<typename _CharT2>
>        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
>      istreambuf_iterator<_CharT2> >::__type
>        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
>      const _CharT2&);
>
>      template<typename _CharT2, typename _Traits2>
>        friend basic_istream<_CharT2, _Traits2>&
>        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
>
>      template<typename _CharT2, typename _Traits2, typename _Alloc>
>        friend basic_istream<_CharT2, _Traits2>&
>        operator>>(basic_istream<_CharT2, _Traits2>&,
>     basic_string<_CharT2, _Traits2, _Alloc>&);
>
>      template<typename _CharT2, typename _Traits2, typename _Alloc>
>        friend basic_istream<_CharT2, _Traits2>&
>        getline(basic_istream<_CharT2, _Traits2>&,
>  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
>
>    protected:
># 185 "/usr/include/c++/4.8.0/streambuf" 3
>      char_type* _M_in_beg;
>      char_type* _M_in_cur;
>      char_type* _M_in_end;
>      char_type* _M_out_beg;
>      char_type* _M_out_cur;
>      char_type* _M_out_end;
>
>
>      locale _M_buf_locale;
>
>  public:
>
>      virtual
>      ~basic_streambuf()
>      { }
># 209 "/usr/include/c++/4.8.0/streambuf" 3
>      locale
>      pubimbue(const locale& __loc)
>      {
> locale __tmp(this->getloc());
> this->imbue(__loc);
> _M_buf_locale = __loc;
> return __tmp;
>      }
># 226 "/usr/include/c++/4.8.0/streambuf" 3
>      locale
>      getloc() const
>      { return _M_buf_locale; }
># 239 "/usr/include/c++/4.8.0/streambuf" 3
>      __streambuf_type*
>      pubsetbuf(char_type* __s, streamsize __n)
>      { return this->setbuf(__s, __n); }
># 251 "/usr/include/c++/4.8.0/streambuf" 3
>      pos_type
>      pubseekoff(off_type __off, ios_base::seekdir __way,
>   ios_base::openmode __mode = ios_base::in | ios_base::out)
>      { return this->seekoff(__off, __way, __mode); }
># 263 "/usr/include/c++/4.8.0/streambuf" 3
>      pos_type
>      pubseekpos(pos_type __sp,
>   ios_base::openmode __mode = ios_base::in | ios_base::out)
>      { return this->seekpos(__sp, __mode); }
>
>
>
>
>      int
>      pubsync() { return this->sync(); }
># 284 "/usr/include/c++/4.8.0/streambuf" 3
>      streamsize
>      in_avail()
>      {
> const streamsize __ret = this->egptr() - this->gptr();
> return __ret ? __ret : this->showmanyc();
>      }
># 298 "/usr/include/c++/4.8.0/streambuf" 3
>      int_type
>      snextc()
>      {
> int_type __ret = traits_type::eof();
> if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
>             __ret), true))
>   __ret = this->sgetc();
> return __ret;
>      }
># 316 "/usr/include/c++/4.8.0/streambuf" 3
>      int_type
>      sbumpc()
>      {
> int_type __ret;
> if (__builtin_expect(this->gptr() < this->egptr(), true))
>   {
>     __ret = traits_type::to_int_type(*this->gptr());
>     this->gbump(1);
>   }
> else
>   __ret = this->uflow();
> return __ret;
>      }
># 338 "/usr/include/c++/4.8.0/streambuf" 3
>      int_type
>      sgetc()
>      {
> int_type __ret;
> if (__builtin_expect(this->gptr() < this->egptr(), true))
>   __ret = traits_type::to_int_type(*this->gptr());
> else
>   __ret = this->underflow();
> return __ret;
>      }
># 357 "/usr/include/c++/4.8.0/streambuf" 3
>      streamsize
>      sgetn(char_type* __s, streamsize __n)
>      { return this->xsgetn(__s, __n); }
># 372 "/usr/include/c++/4.8.0/streambuf" 3
>      int_type
>      sputbackc(char_type __c)
>      {
> int_type __ret;
> const bool __testpos = this->eback() < this->gptr();
> if (__builtin_expect(!__testpos ||
>        !traits_type::eq(__c, this->gptr()[-1]), false))
>   __ret = this->pbackfail(traits_type::to_int_type(__c));
> else
>   {
>     this->gbump(-1);
>     __ret = traits_type::to_int_type(*this->gptr());
>   }
> return __ret;
>      }
># 397 "/usr/include/c++/4.8.0/streambuf" 3
>      int_type
>      sungetc()
>      {
> int_type __ret;
> if (__builtin_expect(this->eback() < this->gptr(), true))
>   {
>     this->gbump(-1);
>     __ret = traits_type::to_int_type(*this->gptr());
>   }
> else
>   __ret = this->pbackfail();
> return __ret;
>      }
># 424 "/usr/include/c++/4.8.0/streambuf" 3
>      int_type
>      sputc(char_type __c)
>      {
> int_type __ret;
> if (__builtin_expect(this->pptr() < this->epptr(), true))
>   {
>     *this->pptr() = __c;
>     this->pbump(1);
>     __ret = traits_type::to_int_type(__c);
>   }
> else
>   __ret = this->overflow(traits_type::to_int_type(__c));
> return __ret;
>      }
># 450 "/usr/include/c++/4.8.0/streambuf" 3
>      streamsize
>      sputn(const char_type* __s, streamsize __n)
>      { return this->xsputn(__s, __n); }
>
>    protected:
># 464 "/usr/include/c++/4.8.0/streambuf" 3
>      basic_streambuf()
>      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
>      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
>      _M_buf_locale(locale())
>      { }
># 482 "/usr/include/c++/4.8.0/streambuf" 3
>      char_type*
>      eback() const { return _M_in_beg; }
>
>      char_type*
>      gptr() const { return _M_in_cur; }
>
>      char_type*
>      egptr() const { return _M_in_end; }
># 498 "/usr/include/c++/4.8.0/streambuf" 3
>      void
>      gbump(int __n) { _M_in_cur += __n; }
># 509 "/usr/include/c++/4.8.0/streambuf" 3
>      void
>      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
>      {
> _M_in_beg = __gbeg;
> _M_in_cur = __gnext;
> _M_in_end = __gend;
>      }
># 529 "/usr/include/c++/4.8.0/streambuf" 3
>      char_type*
>      pbase() const { return _M_out_beg; }
>
>      char_type*
>      pptr() const { return _M_out_cur; }
>
>      char_type*
>      epptr() const { return _M_out_end; }
># 545 "/usr/include/c++/4.8.0/streambuf" 3
>      void
>      pbump(int __n) { _M_out_cur += __n; }
># 555 "/usr/include/c++/4.8.0/streambuf" 3
>      void
>      setp(char_type* __pbeg, char_type* __pend)
>      {
> _M_out_beg = _M_out_cur = __pbeg;
> _M_out_end = __pend;
>      }
># 576 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual void
>      imbue(const locale& __loc)
>      { }
># 591 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual basic_streambuf<char_type,_Traits>*
>      setbuf(char_type*, streamsize)
>      { return this; }
># 602 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual pos_type
>      seekoff(off_type, ios_base::seekdir,
>       ios_base::openmode = ios_base::in | ios_base::out)
>      { return pos_type(off_type(-1)); }
># 614 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual pos_type
>      seekpos(pos_type,
>       ios_base::openmode = ios_base::in | ios_base::out)
>      { return pos_type(off_type(-1)); }
># 627 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual int
>      sync() { return 0; }
># 649 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual streamsize
>      showmanyc() { return 0; }
># 665 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual streamsize
>      xsgetn(char_type* __s, streamsize __n);
># 687 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual int_type
>      underflow()
>      { return traits_type::eof(); }
># 700 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual int_type
>      uflow()
>      {
> int_type __ret = traits_type::eof();
> const bool __testeof = traits_type::eq_int_type(this->underflow(),
>       __ret);
> if (!__testeof)
>   {
>     __ret = traits_type::to_int_type(*this->gptr());
>     this->gbump(1);
>   }
> return __ret;
>      }
># 724 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual int_type
>      pbackfail(int_type __c = traits_type::eof())
>      { return traits_type::eof(); }
># 742 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual streamsize
>      xsputn(const char_type* __s, streamsize __n);
># 768 "/usr/include/c++/4.8.0/streambuf" 3
>      virtual int_type
>      overflow(int_type __c = traits_type::eof())
>      { return traits_type::eof(); }
>
>
>
>    public:
># 783 "/usr/include/c++/4.8.0/streambuf" 3
>      void
>      stossc()
>      {
> if (this->gptr() < this->egptr())
>   this->gbump(1);
> else
>   this->uflow();
>      }
>
>
>
>      void
>      __safe_gbump(streamsize __n) { _M_in_cur += __n; }
>
>      void
>      __safe_pbump(streamsize __n) { _M_out_cur += __n; }
>
>    private:
>
>
>      basic_streambuf(const __streambuf_type& __sb)
>      : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
>      _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
>      _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
>      _M_buf_locale(__sb._M_buf_locale)
>      { }
>
>      __streambuf_type&
>      operator=(const __streambuf_type&) { return *this; };
>    };
>
>
>  template<>
>    streamsize
>    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
>     basic_streambuf<char>* __sbout, bool& __ineof);
>
>  template<>
>    streamsize
>    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
>     basic_streambuf<wchar_t>* __sbout, bool& __ineof);
>
>
>
>}
>
># 1 "/usr/include/c++/4.8.0/bits/streambuf.tcc" 1 3
># 37 "/usr/include/c++/4.8.0/bits/streambuf.tcc" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/streambuf.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _CharT, typename _Traits>
>    streamsize
>    basic_streambuf<_CharT, _Traits>::
>    xsgetn(char_type* __s, streamsize __n)
>    {
>      streamsize __ret = 0;
>      while (__ret < __n)
> {
>   const streamsize __buf_len = this->egptr() - this->gptr();
>   if (__buf_len)
>     {
>       const streamsize __remaining = __n - __ret;
>       const streamsize __len = std::min(__buf_len, __remaining);
>       traits_type::copy(__s, this->gptr(), __len);
>       __ret += __len;
>       __s += __len;
>       this->__safe_gbump(__len);
>     }
>
>   if (__ret < __n)
>     {
>       const int_type __c = this->uflow();
>       if (!traits_type::eq_int_type(__c, traits_type::eof()))
>  {
>    traits_type::assign(*__s++, traits_type::to_char_type(__c));
>    ++__ret;
>  }
>       else
>  break;
>     }
> }
>      return __ret;
>    }
>
>  template<typename _CharT, typename _Traits>
>    streamsize
>    basic_streambuf<_CharT, _Traits>::
>    xsputn(const char_type* __s, streamsize __n)
>    {
>      streamsize __ret = 0;
>      while (__ret < __n)
> {
>   const streamsize __buf_len = this->epptr() - this->pptr();
>   if (__buf_len)
>     {
>       const streamsize __remaining = __n - __ret;
>       const streamsize __len = std::min(__buf_len, __remaining);
>       traits_type::copy(this->pptr(), __s, __len);
>       __ret += __len;
>       __s += __len;
>       this->__safe_pbump(__len);
>     }
>
>   if (__ret < __n)
>     {
>       int_type __c = this->overflow(traits_type::to_int_type(*__s));
>       if (!traits_type::eq_int_type(__c, traits_type::eof()))
>  {
>    ++__ret;
>    ++__s;
>  }
>       else
>  break;
>     }
> }
>      return __ret;
>    }
>
>
>
>
>  template<typename _CharT, typename _Traits>
>    streamsize
>    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
>     basic_streambuf<_CharT, _Traits>* __sbout,
>     bool& __ineof)
>    {
>      streamsize __ret = 0;
>      __ineof = true;
>      typename _Traits::int_type __c = __sbin->sgetc();
>      while (!_Traits::eq_int_type(__c, _Traits::eof()))
> {
>   __c = __sbout->sputc(_Traits::to_char_type(__c));
>   if (_Traits::eq_int_type(__c, _Traits::eof()))
>     {
>       __ineof = false;
>       break;
>     }
>   ++__ret;
>   __c = __sbin->snextc();
> }
>      return __ret;
>    }
>
>  template<typename _CharT, typename _Traits>
>    inline streamsize
>    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
>        basic_streambuf<_CharT, _Traits>* __sbout)
>    {
>      bool __ineof;
>      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
>    }
>
>
>
>
>  extern template class basic_streambuf<char>;
>  extern template
>    streamsize
>    __copy_streambufs(basic_streambuf<char>*,
>        basic_streambuf<char>*);
>  extern template
>    streamsize
>    __copy_streambufs_eof(basic_streambuf<char>*,
>     basic_streambuf<char>*, bool&);
>
>
>  extern template class basic_streambuf<wchar_t>;
>  extern template
>    streamsize
>    __copy_streambufs(basic_streambuf<wchar_t>*,
>        basic_streambuf<wchar_t>*);
>  extern template
>    streamsize
>    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
>     basic_streambuf<wchar_t>*, bool&);
>
>
>
>
>}
># 830 "/usr/include/c++/4.8.0/streambuf" 2 3
># 44 "/usr/include/c++/4.8.0/ios" 2 3
># 1 "/usr/include/c++/4.8.0/bits/basic_ios.h" 1 3
># 33 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>       
># 34 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>
>
>
># 1 "/usr/include/c++/4.8.0/bits/locale_facets.h" 1 3
># 37 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>
># 1 "/usr/include/c++/4.8.0/cwctype" 1 3
># 39 "/usr/include/c++/4.8.0/cwctype" 3
>       
># 40 "/usr/include/c++/4.8.0/cwctype" 3
># 50 "/usr/include/c++/4.8.0/cwctype" 3
># 1 "/usr/include/wctype.h" 1 3 4
># 33 "/usr/include/wctype.h" 3 4
># 1 "/usr/include/wchar.h" 1 3 4
># 34 "/usr/include/wctype.h" 2 3 4
># 49 "/usr/include/wctype.h" 3 4
>
>
>
>typedef unsigned long int wctype_t;
>
># 71 "/usr/include/wctype.h" 3 4
>enum
>{
>  __ISwupper = 0,
>  __ISwlower = 1,
>  __ISwalpha = 2,
>  __ISwdigit = 3,
>  __ISwxdigit = 4,
>  __ISwspace = 5,
>  __ISwprint = 6,
>  __ISwgraph = 7,
>  __ISwblank = 8,
>  __ISwcntrl = 9,
>  __ISwpunct = 10,
>  __ISwalnum = 11,
>
>  _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
>  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
>  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
>  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
>  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
>  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
>  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
>  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
>  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
>  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
>  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
>  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
>};
>
>
>
>extern "C" {
>
>
>
>
>
>
>
>
>extern int iswalnum (wint_t __wc) throw ();
>
>
>
>
>
>extern int iswalpha (wint_t __wc) throw ();
>
>
>extern int iswcntrl (wint_t __wc) throw ();
>
>
>
>extern int iswdigit (wint_t __wc) throw ();
>
>
>
>extern int iswgraph (wint_t __wc) throw ();
>
>
>
>
>extern int iswlower (wint_t __wc) throw ();
>
>
>extern int iswprint (wint_t __wc) throw ();
>
>
>
>
>extern int iswpunct (wint_t __wc) throw ();
>
>
>
>
>extern int iswspace (wint_t __wc) throw ();
>
>
>
>
>extern int iswupper (wint_t __wc) throw ();
>
>
>
>
>extern int iswxdigit (wint_t __wc) throw ();
>
>
>
>
>
>extern int iswblank (wint_t __wc) throw ();
># 171 "/usr/include/wctype.h" 3 4
>extern wctype_t wctype (const char *__property) throw ();
>
>
>
>extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
>
>
>
>
>
>
>
>
>
>
>typedef const __int32_t *wctrans_t;
>
>
>
>
>
>
>
>extern wint_t towlower (wint_t __wc) throw ();
>
>
>extern wint_t towupper (wint_t __wc) throw ();
>
>
>}
># 213 "/usr/include/wctype.h" 3 4
>extern "C" {
>
>
>
>
>extern wctrans_t wctrans (const char *__property) throw ();
>
>
>extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
>
>
>
>
>
>
>
>
>extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>
>extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern wctype_t wctype_l (const char *__property, __locale_t __locale)
>     throw ();
>
>
>
>extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
>     throw ();
>
>
>
>
>
>
>
>extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
>     throw ();
>
>
>extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
>      __locale_t __locale) throw ();
>
>
>
>}
># 51 "/usr/include/c++/4.8.0/cwctype" 2 3
># 80 "/usr/include/c++/4.8.0/cwctype" 3
>namespace std
>{
>  using ::wctrans_t;
>  using ::wctype_t;
>  using ::wint_t;
>
>  using ::iswalnum;
>  using ::iswalpha;
>
>  using ::iswblank;
>
>  using ::iswcntrl;
>  using ::iswctype;
>  using ::iswdigit;
>  using ::iswgraph;
>  using ::iswlower;
>  using ::iswprint;
>  using ::iswpunct;
>  using ::iswspace;
>  using ::iswupper;
>  using ::iswxdigit;
>  using ::towctrans;
>  using ::towlower;
>  using ::towupper;
>  using ::wctrans;
>  using ::wctype;
>}
># 40 "/usr/include/c++/4.8.0/bits/locale_facets.h" 2 3
># 1 "/usr/include/c++/4.8.0/cctype" 1 3
># 39 "/usr/include/c++/4.8.0/cctype" 3
>       
># 40 "/usr/include/c++/4.8.0/cctype" 3
># 41 "/usr/include/c++/4.8.0/bits/locale_facets.h" 2 3
># 1 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/ctype_base.h" 1 3
># 36 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/ctype_base.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>  struct ctype_base
>  {
>
>    typedef const int* __to_type;
>
>
>
>    typedef unsigned short mask;
>    static const mask upper = _ISupper;
>    static const mask lower = _ISlower;
>    static const mask alpha = _ISalpha;
>    static const mask digit = _ISdigit;
>    static const mask xdigit = _ISxdigit;
>    static const mask space = _ISspace;
>    static const mask print = _ISprint;
>    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
>    static const mask cntrl = _IScntrl;
>    static const mask punct = _ISpunct;
>    static const mask alnum = _ISalpha | _ISdigit;
>  };
>
>
>}
># 42 "/usr/include/c++/4.8.0/bits/locale_facets.h" 2 3
>
>
>
>
>
>
># 1 "/usr/include/c++/4.8.0/bits/streambuf_iterator.h" 1 3
># 33 "/usr/include/c++/4.8.0/bits/streambuf_iterator.h" 3
>       
># 34 "/usr/include/c++/4.8.0/bits/streambuf_iterator.h" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 49 "/usr/include/c++/4.8.0/bits/streambuf_iterator.h" 3
>  template<typename _CharT, typename _Traits>
>    class istreambuf_iterator
>    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
>                      _CharT*,
>
>
>
>
>        _CharT&>
>
>    {
>    public:
>
>
>
>      typedef _CharT char_type;
>      typedef _Traits traits_type;
>      typedef typename _Traits::int_type int_type;
>      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
>      typedef basic_istream<_CharT, _Traits> istream_type;
>
>
>      template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
>                      ostreambuf_iterator<_CharT2> >::__type
> copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
>      ostreambuf_iterator<_CharT2>);
>
>      template<bool _IsMove, typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
>            _CharT2*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT2>,
>         istreambuf_iterator<_CharT2>, _CharT2*);
>
>      template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
>               istreambuf_iterator<_CharT2> >::__type
> find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
>      const _CharT2&);
>
>    private:
>
>
>
>
>
>
>
>      mutable streambuf_type* _M_sbuf;
>      mutable int_type _M_c;
>
>    public:
>
>      istreambuf_iterator() throw()
>      : _M_sbuf(0), _M_c(traits_type::eof()) { }
># 112 "/usr/include/c++/4.8.0/bits/streambuf_iterator.h" 3
>      istreambuf_iterator(istream_type& __s) throw()
>      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
>
>
>      istreambuf_iterator(streambuf_type* __s) throw()
>      : _M_sbuf(__s), _M_c(traits_type::eof()) { }
>
>
>
>
>      char_type
>      operator*() const
>      {
>
>
>
>
>
>
>
> return traits_type::to_char_type(_M_get());
>      }
>
>
>      istreambuf_iterator&
>      operator++()
>      {
>
>
>                        ;
> if (_M_sbuf)
>   {
>     _M_sbuf->sbumpc();
>     _M_c = traits_type::eof();
>   }
> return *this;
>      }
>
>
>      istreambuf_iterator
>      operator++(int)
>      {
>
>
>                        ;
>
> istreambuf_iterator __old = *this;
> if (_M_sbuf)
>   {
>     __old._M_c = _M_sbuf->sbumpc();
>     _M_c = traits_type::eof();
>   }
> return __old;
>      }
>
>
>
>
>
>      bool
>      equal(const istreambuf_iterator& __b) const
>      { return _M_at_eof() == __b._M_at_eof(); }
>
>    private:
>      int_type
>      _M_get() const
>      {
> const int_type __eof = traits_type::eof();
> int_type __ret = __eof;
> if (_M_sbuf)
>   {
>     if (!traits_type::eq_int_type(_M_c, __eof))
>       __ret = _M_c;
>     else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
>            __eof))
>       _M_c = __ret;
>     else
>       _M_sbuf = 0;
>   }
> return __ret;
>      }
>
>      bool
>      _M_at_eof() const
>      {
> const int_type __eof = traits_type::eof();
> return traits_type::eq_int_type(_M_get(), __eof);
>      }
>    };
>
>  template<typename _CharT, typename _Traits>
>    inline bool
>    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
>        const istreambuf_iterator<_CharT, _Traits>& __b)
>    { return __a.equal(__b); }
>
>  template<typename _CharT, typename _Traits>
>    inline bool
>    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
>        const istreambuf_iterator<_CharT, _Traits>& __b)
>    { return !__a.equal(__b); }
>
>
>  template<typename _CharT, typename _Traits>
>    class ostreambuf_iterator
>    : public iterator<output_iterator_tag, void, void, void, void>
>    {
>    public:
>
>
>
>      typedef _CharT char_type;
>      typedef _Traits traits_type;
>      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
>      typedef basic_ostream<_CharT, _Traits> ostream_type;
>
>
>      template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
>                      ostreambuf_iterator<_CharT2> >::__type
> copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
>      ostreambuf_iterator<_CharT2>);
>
>    private:
>      streambuf_type* _M_sbuf;
>      bool _M_failed;
>
>    public:
>
>      ostreambuf_iterator(ostream_type& __s) throw()
>      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
>
>
>      ostreambuf_iterator(streambuf_type* __s) throw()
>      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
>
>
>      ostreambuf_iterator&
>      operator=(_CharT __c)
>      {
> if (!_M_failed &&
>     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
>   _M_failed = true;
> return *this;
>      }
>
>
>      ostreambuf_iterator&
>      operator*()
>      { return *this; }
>
>
>      ostreambuf_iterator&
>      operator++(int)
>      { return *this; }
>
>
>      ostreambuf_iterator&
>      operator++()
>      { return *this; }
>
>
>      bool
>      failed() const throw()
>      { return _M_failed; }
>
>      ostreambuf_iterator&
>      _M_put(const _CharT* __ws, streamsize __len)
>      {
> if (__builtin_expect(!_M_failed, true)
>     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
>    false))
>   _M_failed = true;
> return *this;
>      }
>    };
>
>
>  template<typename _CharT>
>    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
>                           ostreambuf_iterator<_CharT> >::__type
>    copy(istreambuf_iterator<_CharT> __first,
>  istreambuf_iterator<_CharT> __last,
>  ostreambuf_iterator<_CharT> __result)
>    {
>      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
> {
>   bool __ineof;
>   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
>   if (!__ineof)
>     __result._M_failed = true;
> }
>      return __result;
>    }
>
>  template<bool _IsMove, typename _CharT>
>    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
>            ostreambuf_iterator<_CharT> >::__type
>    __copy_move_a2(_CharT* __first, _CharT* __last,
>     ostreambuf_iterator<_CharT> __result)
>    {
>      const streamsize __num = __last - __first;
>      if (__num > 0)
> __result._M_put(__first, __num);
>      return __result;
>    }
>
>  template<bool _IsMove, typename _CharT>
>    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
>        ostreambuf_iterator<_CharT> >::__type
>    __copy_move_a2(const _CharT* __first, const _CharT* __last,
>     ostreambuf_iterator<_CharT> __result)
>    {
>      const streamsize __num = __last - __first;
>      if (__num > 0)
> __result._M_put(__first, __num);
>      return __result;
>    }
>
>  template<bool _IsMove, typename _CharT>
>    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
>            _CharT*>::__type
>    __copy_move_a2(istreambuf_iterator<_CharT> __first,
>     istreambuf_iterator<_CharT> __last, _CharT* __result)
>    {
>      typedef istreambuf_iterator<_CharT> __is_iterator_type;
>      typedef typename __is_iterator_type::traits_type traits_type;
>      typedef typename __is_iterator_type::streambuf_type streambuf_type;
>      typedef typename traits_type::int_type int_type;
>
>      if (__first._M_sbuf && !__last._M_sbuf)
> {
>   streambuf_type* __sb = __first._M_sbuf;
>   int_type __c = __sb->sgetc();
>   while (!traits_type::eq_int_type(__c, traits_type::eof()))
>     {
>       const streamsize __n = __sb->egptr() - __sb->gptr();
>       if (__n > 1)
>  {
>    traits_type::copy(__result, __sb->gptr(), __n);
>    __sb->__safe_gbump(__n);
>    __result += __n;
>    __c = __sb->underflow();
>  }
>       else
>  {
>    *__result++ = traits_type::to_char_type(__c);
>    __c = __sb->snextc();
>  }
>     }
> }
>      return __result;
>    }
>
>  template<typename _CharT>
>    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
>          istreambuf_iterator<_CharT> >::__type
>    find(istreambuf_iterator<_CharT> __first,
>  istreambuf_iterator<_CharT> __last, const _CharT& __val)
>    {
>      typedef istreambuf_iterator<_CharT> __is_iterator_type;
>      typedef typename __is_iterator_type::traits_type traits_type;
>      typedef typename __is_iterator_type::streambuf_type streambuf_type;
>      typedef typename traits_type::int_type int_type;
>
>      if (__first._M_sbuf && !__last._M_sbuf)
> {
>   const int_type __ival = traits_type::to_int_type(__val);
>   streambuf_type* __sb = __first._M_sbuf;
>   int_type __c = __sb->sgetc();
>   while (!traits_type::eq_int_type(__c, traits_type::eof())
>   && !traits_type::eq_int_type(__c, __ival))
>     {
>       streamsize __n = __sb->egptr() - __sb->gptr();
>       if (__n > 1)
>  {
>    const _CharT* __p = traits_type::find(__sb->gptr(),
>       __n, __val);
>    if (__p)
>      __n = __p - __sb->gptr();
>    __sb->__safe_gbump(__n);
>    __c = __sb->sgetc();
>  }
>       else
>  __c = __sb->snextc();
>     }
>
>   if (!traits_type::eq_int_type(__c, traits_type::eof()))
>     __first._M_c = __c;
>   else
>     __first._M_sbuf = 0;
> }
>      return __first;
>    }
>
>
>
>
>}
># 49 "/usr/include/c++/4.8.0/bits/locale_facets.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 64 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>  template<typename _Tp>
>    void
>    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
>     const __c_locale&) throw();
>
>
>  template<>
>    void
>    __convert_to_v(const char*, float&, ios_base::iostate&,
>     const __c_locale&) throw();
>
>  template<>
>    void
>    __convert_to_v(const char*, double&, ios_base::iostate&,
>     const __c_locale&) throw();
>
>  template<>
>    void
>    __convert_to_v(const char*, long double&, ios_base::iostate&,
>     const __c_locale&) throw();
>
>
>
>  template<typename _CharT, typename _Traits>
>    struct __pad
>    {
>      static void
>      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
>      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
>    };
>
>
>
>
>
>
>  template<typename _CharT>
>    _CharT*
>    __add_grouping(_CharT* __s, _CharT __sep,
>     const char* __gbeg, size_t __gsize,
>     const _CharT* __first, const _CharT* __last);
>
>
>
>
>  template<typename _CharT>
>    inline
>    ostreambuf_iterator<_CharT>
>    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
>    {
>      __s._M_put(__ws, __len);
>      return __s;
>    }
>
>
>  template<typename _CharT, typename _OutIter>
>    inline
>    _OutIter
>    __write(_OutIter __s, const _CharT* __ws, int __len)
>    {
>      for (int __j = 0; __j < __len; __j++, ++__s)
> *__s = __ws[__j];
>      return __s;
>    }
># 142 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>  template<typename _CharT>
>    class __ctype_abstract_base : public locale::facet, public ctype_base
>    {
>    public:
>
>
>      typedef _CharT char_type;
># 161 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      bool
>      is(mask __m, char_type __c) const
>      { return this->do_is(__m, __c); }
># 178 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char_type*
>      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
>      { return this->do_is(__lo, __hi, __vec); }
># 194 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char_type*
>      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
>      { return this->do_scan_is(__m, __lo, __hi); }
># 210 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char_type*
>      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
>      { return this->do_scan_not(__m, __lo, __hi); }
># 224 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      char_type
>      toupper(char_type __c) const
>      { return this->do_toupper(__c); }
># 239 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char_type*
>      toupper(char_type *__lo, const char_type* __hi) const
>      { return this->do_toupper(__lo, __hi); }
># 253 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      char_type
>      tolower(char_type __c) const
>      { return this->do_tolower(__c); }
># 268 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char_type*
>      tolower(char_type* __lo, const char_type* __hi) const
>      { return this->do_tolower(__lo, __hi); }
># 285 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      char_type
>      widen(char __c) const
>      { return this->do_widen(__c); }
># 304 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char*
>      widen(const char* __lo, const char* __hi, char_type* __to) const
>      { return this->do_widen(__lo, __hi, __to); }
># 323 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      char
>      narrow(char_type __c, char __dfault) const
>      { return this->do_narrow(__c, __dfault); }
># 345 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char_type*
>      narrow(const char_type* __lo, const char_type* __hi,
>       char __dfault, char* __to) const
>      { return this->do_narrow(__lo, __hi, __dfault, __to); }
>
>    protected:
>      explicit
>      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
>
>      virtual
>      ~__ctype_abstract_base() { }
># 370 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual bool
>      do_is(mask __m, char_type __c) const = 0;
># 389 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_is(const char_type* __lo, const char_type* __hi,
>     mask* __vec) const = 0;
># 408 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_scan_is(mask __m, const char_type* __lo,
>   const char_type* __hi) const = 0;
># 427 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_scan_not(mask __m, const char_type* __lo,
>    const char_type* __hi) const = 0;
># 445 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_toupper(char_type __c) const = 0;
># 462 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
># 478 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_tolower(char_type __c) const = 0;
># 495 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
># 514 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_widen(char __c) const = 0;
># 535 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char*
>      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
># 556 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char
>      do_narrow(char_type __c, char __dfault) const = 0;
># 581 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_narrow(const char_type* __lo, const char_type* __hi,
>  char __dfault, char* __to) const = 0;
>    };
># 604 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>  template<typename _CharT>
>    class ctype : public __ctype_abstract_base<_CharT>
>    {
>    public:
>
>      typedef _CharT char_type;
>      typedef typename __ctype_abstract_base<_CharT>::mask mask;
>
>
>      static locale::id id;
>
>      explicit
>      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
>
>   protected:
>      virtual
>      ~ctype();
>
>      virtual bool
>      do_is(mask __m, char_type __c) const;
>
>      virtual const char_type*
>      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
>
>      virtual const char_type*
>      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
>
>      virtual const char_type*
>      do_scan_not(mask __m, const char_type* __lo,
>    const char_type* __hi) const;
>
>      virtual char_type
>      do_toupper(char_type __c) const;
>
>      virtual const char_type*
>      do_toupper(char_type* __lo, const char_type* __hi) const;
>
>      virtual char_type
>      do_tolower(char_type __c) const;
>
>      virtual const char_type*
>      do_tolower(char_type* __lo, const char_type* __hi) const;
>
>      virtual char_type
>      do_widen(char __c) const;
>
>      virtual const char*
>      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
>
>      virtual char
>      do_narrow(char_type, char __dfault) const;
>
>      virtual const char_type*
>      do_narrow(const char_type* __lo, const char_type* __hi,
>  char __dfault, char* __to) const;
>    };
>
>  template<typename _CharT>
>    locale::id ctype<_CharT>::id;
># 673 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>  template<>
>    class ctype<char> : public locale::facet, public ctype_base
>    {
>    public:
>
>
>      typedef char char_type;
>
>    protected:
>
>      __c_locale _M_c_locale_ctype;
>      bool _M_del;
>      __to_type _M_toupper;
>      __to_type _M_tolower;
>      const mask* _M_table;
>      mutable char _M_widen_ok;
>      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
>      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
>      mutable char _M_narrow_ok;
>
>
>    public:
>
>      static locale::id id;
>
>      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
># 710 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      explicit
>      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
># 723 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      explicit
>      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
>     size_t __refs = 0);
># 736 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      inline bool
>      is(mask __m, char __c) const;
># 751 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      inline const char*
>      is(const char* __lo, const char* __hi, mask* __vec) const;
># 765 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      inline const char*
>      scan_is(mask __m, const char* __lo, const char* __hi) const;
># 779 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      inline const char*
>      scan_not(mask __m, const char* __lo, const char* __hi) const;
># 794 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      char_type
>      toupper(char_type __c) const
>      { return this->do_toupper(__c); }
># 811 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char_type*
>      toupper(char_type *__lo, const char_type* __hi) const
>      { return this->do_toupper(__lo, __hi); }
># 827 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      char_type
>      tolower(char_type __c) const
>      { return this->do_tolower(__c); }
># 844 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char_type*
>      tolower(char_type* __lo, const char_type* __hi) const
>      { return this->do_tolower(__lo, __hi); }
># 864 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      char_type
>      widen(char __c) const
>      {
> if (_M_widen_ok)
>   return _M_widen[static_cast<unsigned char>(__c)];
> this->_M_widen_init();
> return this->do_widen(__c);
>      }
># 891 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char*
>      widen(const char* __lo, const char* __hi, char_type* __to) const
>      {
> if (_M_widen_ok == 1)
>   {
>     __builtin_memcpy(__to, __lo, __hi - __lo);
>     return __hi;
>   }
> if (!_M_widen_ok)
>   _M_widen_init();
> return this->do_widen(__lo, __hi, __to);
>      }
># 922 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      char
>      narrow(char_type __c, char __dfault) const
>      {
> if (_M_narrow[static_cast<unsigned char>(__c)])
>   return _M_narrow[static_cast<unsigned char>(__c)];
> const char __t = do_narrow(__c, __dfault);
> if (__t != __dfault)
>   _M_narrow[static_cast<unsigned char>(__c)] = __t;
> return __t;
>      }
># 955 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      const char_type*
>      narrow(const char_type* __lo, const char_type* __hi,
>      char __dfault, char* __to) const
>      {
> if (__builtin_expect(_M_narrow_ok == 1, true))
>   {
>     __builtin_memcpy(__to, __lo, __hi - __lo);
>     return __hi;
>   }
> if (!_M_narrow_ok)
>   _M_narrow_init();
> return this->do_narrow(__lo, __hi, __dfault, __to);
>      }
>
>
>
>
>
>      const mask*
>      table() const throw()
>      { return _M_table; }
>
>
>      static const mask*
>      classic_table() throw();
>    protected:
>
>
>
>
>
>
>
>      virtual
>      ~ctype();
># 1004 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_toupper(char_type __c) const;
># 1021 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_toupper(char_type* __lo, const char_type* __hi) const;
># 1037 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_tolower(char_type __c) const;
># 1054 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_tolower(char_type* __lo, const char_type* __hi) const;
># 1074 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_widen(char __c) const
>      { return __c; }
># 1097 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char*
>      do_widen(const char* __lo, const char* __hi, char_type* __to) const
>      {
> __builtin_memcpy(__to, __lo, __hi - __lo);
> return __hi;
>      }
># 1123 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char
>      do_narrow(char_type __c, char __dfault) const
>      { return __c; }
># 1149 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_narrow(const char_type* __lo, const char_type* __hi,
>  char __dfault, char* __to) const
>      {
> __builtin_memcpy(__to, __lo, __hi - __lo);
> return __hi;
>      }
>
>    private:
>      void _M_narrow_init() const;
>      void _M_widen_init() const;
>    };
># 1174 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>  template<>
>    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
>    {
>    public:
>
>
>      typedef wchar_t char_type;
>      typedef wctype_t __wmask_type;
>
>    protected:
>      __c_locale _M_c_locale_ctype;
>
>
>      bool _M_narrow_ok;
>      char _M_narrow[128];
>      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
>
>
>      mask _M_bit[16];
>      __wmask_type _M_wmask[16];
>
>    public:
>
>
>      static locale::id id;
># 1207 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      explicit
>      ctype(size_t __refs = 0);
># 1218 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      explicit
>      ctype(__c_locale __cloc, size_t __refs = 0);
>
>    protected:
>      __wmask_type
>      _M_convert_to_wmask(const mask __m) const throw();
>
>
>      virtual
>      ~ctype();
># 1242 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual bool
>      do_is(mask __m, char_type __c) const;
># 1261 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
># 1279 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
># 1297 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_scan_not(mask __m, const char_type* __lo,
>    const char_type* __hi) const;
># 1314 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_toupper(char_type __c) const;
># 1331 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_toupper(char_type* __lo, const char_type* __hi) const;
># 1347 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_tolower(char_type __c) const;
># 1364 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_tolower(char_type* __lo, const char_type* __hi) const;
># 1384 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_widen(char __c) const;
># 1406 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char*
>      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
># 1429 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char
>      do_narrow(char_type __c, char __dfault) const;
># 1455 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual const char_type*
>      do_narrow(const char_type* __lo, const char_type* __hi,
>  char __dfault, char* __to) const;
>
>
>      void
>      _M_initialize_ctype() throw();
>    };
>
>
>
>  template<typename _CharT>
>    class ctype_byname : public ctype<_CharT>
>    {
>    public:
>      typedef typename ctype<_CharT>::mask mask;
>
>      explicit
>      ctype_byname(const char* __s, size_t __refs = 0);
>
>    protected:
>      virtual
>      ~ctype_byname() { };
>    };
>
>
>  template<>
>    class ctype_byname<char> : public ctype<char>
>    {
>    public:
>      explicit
>      ctype_byname(const char* __s, size_t __refs = 0);
>
>    protected:
>      virtual
>      ~ctype_byname();
>    };
>
>
>  template<>
>    class ctype_byname<wchar_t> : public ctype<wchar_t>
>    {
>    public:
>      explicit
>      ctype_byname(const char* __s, size_t __refs = 0);
>
>    protected:
>      virtual
>      ~ctype_byname();
>    };
>
>
>
>}
>
>
># 1 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
># 37 "/usr/include/c++/4.8.0/x86_64-redhat-linux/bits/ctype_inline.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  bool
>  ctype<char>::
>  is(mask __m, char __c) const
>  { return _M_table[static_cast<unsigned char>(__c)] & __m; }
>
>  const char*
>  ctype<char>::
>  is(const char* __low, const char* __high, mask* __vec) const
>  {
>    while (__low < __high)
>      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
>    return __high;
>  }
>
>  const char*
>  ctype<char>::
>  scan_is(mask __m, const char* __low, const char* __high) const
>  {
>    while (__low < __high
>    && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
>      ++__low;
>    return __low;
>  }
>
>  const char*
>  ctype<char>::
>  scan_not(mask __m, const char* __low, const char* __high) const
>  {
>    while (__low < __high
>    && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
>      ++__low;
>    return __low;
>  }
>
>
>}
># 1512 "/usr/include/c++/4.8.0/bits/locale_facets.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>  class __num_base
>  {
>  public:
>
>
>    enum
>      {
> _S_ominus,
> _S_oplus,
> _S_ox,
> _S_oX,
> _S_odigits,
> _S_odigits_end = _S_odigits + 16,
> _S_oudigits = _S_odigits_end,
> _S_oudigits_end = _S_oudigits + 16,
> _S_oe = _S_odigits + 14,
> _S_oE = _S_oudigits + 14,
> _S_oend = _S_oudigits_end
>      };
>
>
>
>
>
>
>    static const char* _S_atoms_out;
>
>
>
>    static const char* _S_atoms_in;
>
>    enum
>    {
>      _S_iminus,
>      _S_iplus,
>      _S_ix,
>      _S_iX,
>      _S_izero,
>      _S_ie = _S_izero + 14,
>      _S_iE = _S_izero + 20,
>      _S_iend = 26
>    };
>
>
>
>    static void
>    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
>  };
>
>  template<typename _CharT>
>    struct __numpunct_cache : public locale::facet
>    {
>      const char* _M_grouping;
>      size_t _M_grouping_size;
>      bool _M_use_grouping;
>      const _CharT* _M_truename;
>      size_t _M_truename_size;
>      const _CharT* _M_falsename;
>      size_t _M_falsename_size;
>      _CharT _M_decimal_point;
>      _CharT _M_thousands_sep;
>
>
>
>
>
>      _CharT _M_atoms_out[__num_base::_S_oend];
>
>
>
>
>
>      _CharT _M_atoms_in[__num_base::_S_iend];
>
>      bool _M_allocated;
>
>      __numpunct_cache(size_t __refs = 0)
>      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
> _M_use_grouping(false),
> _M_truename(0), _M_truename_size(0), _M_falsename(0),
> _M_falsename_size(0), _M_decimal_point(_CharT()),
> _M_thousands_sep(_CharT()), _M_allocated(false)
> { }
>
>      ~__numpunct_cache();
>
>      void
>      _M_cache(const locale& __loc);
>
>    private:
>      __numpunct_cache&
>      operator=(const __numpunct_cache&);
>
>      explicit
>      __numpunct_cache(const __numpunct_cache&);
>    };
>
>  template<typename _CharT>
>    __numpunct_cache<_CharT>::~__numpunct_cache()
>    {
>      if (_M_allocated)
> {
>   delete [] _M_grouping;
>   delete [] _M_truename;
>   delete [] _M_falsename;
> }
>    }
># 1640 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>  template<typename _CharT>
>    class numpunct : public locale::facet
>    {
>    public:
>
>
>
>      typedef _CharT char_type;
>      typedef basic_string<_CharT> string_type;
>
>      typedef __numpunct_cache<_CharT> __cache_type;
>
>    protected:
>      __cache_type* _M_data;
>
>    public:
>
>      static locale::id id;
>
>
>
>
>
>
>      explicit
>      numpunct(size_t __refs = 0)
>      : facet(__refs), _M_data(0)
>      { _M_initialize_numpunct(); }
># 1678 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      explicit
>      numpunct(__cache_type* __cache, size_t __refs = 0)
>      : facet(__refs), _M_data(__cache)
>      { _M_initialize_numpunct(); }
># 1692 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      explicit
>      numpunct(__c_locale __cloc, size_t __refs = 0)
>      : facet(__refs), _M_data(0)
>      { _M_initialize_numpunct(__cloc); }
># 1706 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      char_type
>      decimal_point() const
>      { return this->do_decimal_point(); }
># 1719 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      char_type
>      thousands_sep() const
>      { return this->do_thousands_sep(); }
># 1750 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      string
>      grouping() const
>      { return this->do_grouping(); }
># 1763 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      string_type
>      truename() const
>      { return this->do_truename(); }
># 1776 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      string_type
>      falsename() const
>      { return this->do_falsename(); }
>
>    protected:
>
>      virtual
>      ~numpunct();
># 1793 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_decimal_point() const
>      { return _M_data->_M_decimal_point; }
># 1805 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual char_type
>      do_thousands_sep() const
>      { return _M_data->_M_thousands_sep; }
># 1818 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual string
>      do_grouping() const
>      { return _M_data->_M_grouping; }
># 1831 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual string_type
>      do_truename() const
>      { return _M_data->_M_truename; }
># 1844 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual string_type
>      do_falsename() const
>      { return _M_data->_M_falsename; }
>
>
>      void
>      _M_initialize_numpunct(__c_locale __cloc = 0);
>    };
>
>  template<typename _CharT>
>    locale::id numpunct<_CharT>::id;
>
>  template<>
>    numpunct<char>::~numpunct();
>
>  template<>
>    void
>    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
>
>
>  template<>
>    numpunct<wchar_t>::~numpunct();
>
>  template<>
>    void
>    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
>
>
>
>  template<typename _CharT>
>    class numpunct_byname : public numpunct<_CharT>
>    {
>    public:
>      typedef _CharT char_type;
>      typedef basic_string<_CharT> string_type;
>
>      explicit
>      numpunct_byname(const char* __s, size_t __refs = 0)
>      : numpunct<_CharT>(__refs)
>      {
> if (__builtin_strcmp(__s, "C") != 0
>     && __builtin_strcmp(__s, "POSIX") != 0)
>   {
>     __c_locale __tmp;
>     this->_S_create_c_locale(__tmp, __s);
>     this->_M_initialize_numpunct(__tmp);
>     this->_S_destroy_c_locale(__tmp);
>   }
>      }
>
>    protected:
>      virtual
>      ~numpunct_byname() { }
>    };
>
>
># 1914 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>  template<typename _CharT, typename _InIter>
>    class num_get : public locale::facet
>    {
>    public:
>
>
>
>      typedef _CharT char_type;
>      typedef _InIter iter_type;
>
>
>
>      static locale::id id;
># 1935 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      explicit
>      num_get(size_t __refs = 0) : facet(__refs) { }
># 1961 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, bool& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
># 1998 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, long& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
>
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, unsigned short& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
>
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, unsigned int& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
>
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, unsigned long& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
>
>
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, long long& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
>
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, unsigned long long& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
># 2058 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, float& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
>
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, double& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
>
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, long double& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
># 2101 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      iter_type
>      get(iter_type __in, iter_type __end, ios_base& __io,
>   ios_base::iostate& __err, void*& __v) const
>      { return this->do_get(__in, __end, __io, __err, __v); }
>
>    protected:
>
>      virtual ~num_get() { }
>
>      iter_type
>      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
>         string&) const;
>
>      template<typename _ValueT>
> iter_type
> _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
>         _ValueT&) const;
>
>      template<typename _CharT2>
>      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
> _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
> {
>   int __ret = -1;
>   if (__len <= 10)
>     {
>       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
>  __ret = __c - _CharT2('0');
>     }
>   else
>     {
>       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
>  __ret = __c - _CharT2('0');
>       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
>  __ret = 10 + (__c - _CharT2('a'));
>       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
>  __ret = 10 + (__c - _CharT2('A'));
>     }
>   return __ret;
> }
>
>      template<typename _CharT2>
>      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
>          int>::__type
> _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
> {
>   int __ret = -1;
>   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
>   if (__q)
>     {
>       __ret = __q - __zero;
>       if (__ret > 15)
>  __ret -= 6;
>     }
>   return __ret;
> }
># 2172 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual iter_type
>      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
>
>      virtual iter_type
>      do_get(iter_type __beg, iter_type __end, ios_base& __io,
>      ios_base::iostate& __err, long& __v) const
>      { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>      virtual iter_type
>      do_get(iter_type __beg, iter_type __end, ios_base& __io,
>      ios_base::iostate& __err, unsigned short& __v) const
>      { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>      virtual iter_type
>      do_get(iter_type __beg, iter_type __end, ios_base& __io,
>      ios_base::iostate& __err, unsigned int& __v) const
>      { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>      virtual iter_type
>      do_get(iter_type __beg, iter_type __end, ios_base& __io,
>      ios_base::iostate& __err, unsigned long& __v) const
>      { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>
>      virtual iter_type
>      do_get(iter_type __beg, iter_type __end, ios_base& __io,
>      ios_base::iostate& __err, long long& __v) const
>      { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>      virtual iter_type
>      do_get(iter_type __beg, iter_type __end, ios_base& __io,
>      ios_base::iostate& __err, unsigned long long& __v) const
>      { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>
>      virtual iter_type
>      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
>
>      virtual iter_type
>      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
>      double&) const;
>
>
>
>
>
>
>
>      virtual iter_type
>      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
>      long double&) const;
>
>
>      virtual iter_type
>      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
># 2235 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>    };
>
>  template<typename _CharT, typename _InIter>
>    locale::id num_get<_CharT, _InIter>::id;
># 2253 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>  template<typename _CharT, typename _OutIter>
>    class num_put : public locale::facet
>    {
>    public:
>
>
>
>      typedef _CharT char_type;
>      typedef _OutIter iter_type;
>
>
>
>      static locale::id id;
># 2274 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      explicit
>      num_put(size_t __refs = 0) : facet(__refs) { }
># 2292 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      iter_type
>      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
>      { return this->do_put(__s, __io, __fill, __v); }
># 2334 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      iter_type
>      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
>      { return this->do_put(__s, __io, __fill, __v); }
>
>      iter_type
>      put(iter_type __s, ios_base& __io, char_type __fill,
>   unsigned long __v) const
>      { return this->do_put(__s, __io, __fill, __v); }
>
>
>      iter_type
>      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
>      { return this->do_put(__s, __io, __fill, __v); }
>
>      iter_type
>      put(iter_type __s, ios_base& __io, char_type __fill,
>   unsigned long long __v) const
>      { return this->do_put(__s, __io, __fill, __v); }
># 2397 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      iter_type
>      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
>      { return this->do_put(__s, __io, __fill, __v); }
>
>      iter_type
>      put(iter_type __s, ios_base& __io, char_type __fill,
>   long double __v) const
>      { return this->do_put(__s, __io, __fill, __v); }
># 2422 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      iter_type
>      put(iter_type __s, ios_base& __io, char_type __fill,
>   const void* __v) const
>      { return this->do_put(__s, __io, __fill, __v); }
>
>    protected:
>      template<typename _ValueT>
> iter_type
> _M_insert_float(iter_type, ios_base& __io, char_type __fill,
>   char __mod, _ValueT __v) const;
>
>      void
>      _M_group_float(const char* __grouping, size_t __grouping_size,
>       char_type __sep, const char_type* __p, char_type* __new,
>       char_type* __cs, int& __len) const;
>
>      template<typename _ValueT>
> iter_type
> _M_insert_int(iter_type, ios_base& __io, char_type __fill,
>        _ValueT __v) const;
>
>      void
>      _M_group_int(const char* __grouping, size_t __grouping_size,
>     char_type __sep, ios_base& __io, char_type* __new,
>     char_type* __cs, int& __len) const;
>
>      void
>      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
>      char_type* __new, const char_type* __cs, int& __len) const;
>
>
>      virtual
>      ~num_put() { };
># 2470 "/usr/include/c++/4.8.0/bits/locale_facets.h" 3
>      virtual iter_type
>      do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
>
>      virtual iter_type
>      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
>      { return _M_insert_int(__s, __io, __fill, __v); }
>
>      virtual iter_type
>      do_put(iter_type __s, ios_base& __io, char_type __fill,
>      unsigned long __v) const
>      { return _M_insert_int(__s, __io, __fill, __v); }
>
>
>      virtual iter_type
>      do_put(iter_type __s, ios_base& __io, char_type __fill,
>      long long __v) const
>      { return _M_insert_int(__s, __io, __fill, __v); }
>
>      virtual iter_type
>      do_put(iter_type __s, ios_base& __io, char_type __fill,
>      unsigned long long __v) const
>      { return _M_insert_int(__s, __io, __fill, __v); }
>
>
>      virtual iter_type
>      do_put(iter_type, ios_base&, char_type, double) const;
>
>
>
>
>
>
>      virtual iter_type
>      do_put(iter_type, ios_base&, char_type, long double) const;
>
>
>      virtual iter_type
>      do_put(iter_type, ios_base&, char_type, const void*) const;
>
>
>
>
>
>
>
>    };
>
>  template <typename _CharT, typename _OutIter>
>    locale::id num_put<_CharT, _OutIter>::id;
>
>
>
>
>
>
>
>
>
>  template<typename _CharT>
>    inline bool
>    isspace(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
>
>
>  template<typename _CharT>
>    inline bool
>    isprint(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
>
>
>  template<typename _CharT>
>    inline bool
>    iscntrl(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
>
>
>  template<typename _CharT>
>    inline bool
>    isupper(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
>
>
>  template<typename _CharT>
>    inline bool
>    islower(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
>
>
>  template<typename _CharT>
>    inline bool
>    isalpha(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
>
>
>  template<typename _CharT>
>    inline bool
>    isdigit(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
>
>
>  template<typename _CharT>
>    inline bool
>    ispunct(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
>
>
>  template<typename _CharT>
>    inline bool
>    isxdigit(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
>
>
>  template<typename _CharT>
>    inline bool
>    isalnum(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
>
>
>  template<typename _CharT>
>    inline bool
>    isgraph(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
>
>
>  template<typename _CharT>
>    inline _CharT
>    toupper(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
>
>
>  template<typename _CharT>
>    inline _CharT
>    tolower(_CharT __c, const locale& __loc)
>    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
>
>
>}
>
># 1 "/usr/include/c++/4.8.0/bits/locale_facets.tcc" 1 3
># 33 "/usr/include/c++/4.8.0/bits/locale_facets.tcc" 3
>       
># 34 "/usr/include/c++/4.8.0/bits/locale_facets.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>  template<typename _Facet>
>    struct __use_cache
>    {
>      const _Facet*
>      operator() (const locale& __loc) const;
>    };
>
>
>  template<typename _CharT>
>    struct __use_cache<__numpunct_cache<_CharT> >
>    {
>      const __numpunct_cache<_CharT>*
>      operator() (const locale& __loc) const
>      {
> const size_t __i = numpunct<_CharT>::id._M_id();
> const locale::facet** __caches = __loc._M_impl->_M_caches;
> if (!__caches[__i])
>   {
>     __numpunct_cache<_CharT>* __tmp = 0;
>     try
>       {
>  __tmp = new __numpunct_cache<_CharT>;
>  __tmp->_M_cache(__loc);
>       }
>     catch(...)
>       {
>  delete __tmp;
>  throw;
>       }
>     __loc._M_impl->_M_install_cache(__tmp, __i);
>   }
> return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
>      }
>    };
>
>  template<typename _CharT>
>    void
>    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
>    {
>      _M_allocated = true;
>
>      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
>
>      char* __grouping = 0;
>      _CharT* __truename = 0;
>      _CharT* __falsename = 0;
>      try
> {
>   _M_grouping_size = __np.grouping().size();
>   __grouping = new char[_M_grouping_size];
>   __np.grouping().copy(__grouping, _M_grouping_size);
>   _M_grouping = __grouping;
>   _M_use_grouping = (_M_grouping_size
>        && static_cast<signed char>(_M_grouping[0]) > 0
>        && (_M_grouping[0]
>     != __gnu_cxx::__numeric_traits<char>::__max));
>
>   _M_truename_size = __np.truename().size();
>   __truename = new _CharT[_M_truename_size];
>   __np.truename().copy(__truename, _M_truename_size);
>   _M_truename = __truename;
>
>   _M_falsename_size = __np.falsename().size();
>   __falsename = new _CharT[_M_falsename_size];
>   __np.falsename().copy(__falsename, _M_falsename_size);
>   _M_falsename = __falsename;
>
>   _M_decimal_point = __np.decimal_point();
>   _M_thousands_sep = __np.thousands_sep();
>
>   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
>   __ct.widen(__num_base::_S_atoms_out,
>       __num_base::_S_atoms_out
>       + __num_base::_S_oend, _M_atoms_out);
>   __ct.widen(__num_base::_S_atoms_in,
>       __num_base::_S_atoms_in
>       + __num_base::_S_iend, _M_atoms_in);
> }
>      catch(...)
> {
>   delete [] __grouping;
>   delete [] __truename;
>   delete [] __falsename;
>   throw;
> }
>    }
># 136 "/usr/include/c++/4.8.0/bits/locale_facets.tcc" 3
>  __attribute__ ((__pure__)) bool
>  __verify_grouping(const char* __grouping, size_t __grouping_size,
>      const string& __grouping_tmp) throw ();
>
>
>
>  template<typename _CharT, typename _InIter>
>    _InIter
>    num_get<_CharT, _InIter>::
>    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
>       ios_base::iostate& __err, string& __xtrc) const
>    {
>      typedef char_traits<_CharT> __traits_type;
>      typedef __numpunct_cache<_CharT> __cache_type;
>      __use_cache<__cache_type> __uc;
>      const locale& __loc = __io._M_getloc();
>      const __cache_type* __lc = __uc(__loc);
>      const _CharT* __lit = __lc->_M_atoms_in;
>      char_type __c = char_type();
>
>
>      bool __testeof = __beg == __end;
>
>
>      if (!__testeof)
> {
>   __c = *__beg;
>   const bool __plus = __c == __lit[__num_base::_S_iplus];
>   if ((__plus || __c == __lit[__num_base::_S_iminus])
>       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
>       && !(__c == __lc->_M_decimal_point))
>     {
>       __xtrc += __plus ? '+' : '-';
>       if (++__beg != __end)
>  __c = *__beg;
>       else
>  __testeof = true;
>     }
> }
>
>
>      bool __found_mantissa = false;
>      int __sep_pos = 0;
>      while (!__testeof)
> {
>   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
>       || __c == __lc->_M_decimal_point)
>     break;
>   else if (__c == __lit[__num_base::_S_izero])
>     {
>       if (!__found_mantissa)
>  {
>    __xtrc += '0';
>    __found_mantissa = true;
>  }
>       ++__sep_pos;
>
>       if (++__beg != __end)
>  __c = *__beg;
>       else
>  __testeof = true;
>     }
>   else
>     break;
> }
>
>
>      bool __found_dec = false;
>      bool __found_sci = false;
>      string __found_grouping;
>      if (__lc->_M_use_grouping)
> __found_grouping.reserve(32);
>      const char_type* __lit_zero = __lit + __num_base::_S_izero;
>
>      if (!__lc->_M_allocated)
>
> while (!__testeof)
>   {
>     const int __digit = _M_find(__lit_zero, 10, __c);
>     if (__digit != -1)
>       {
>  __xtrc += '0' + __digit;
>  __found_mantissa = true;
>       }
>     else if (__c == __lc->_M_decimal_point
>       && !__found_dec && !__found_sci)
>       {
>  __xtrc += '.';
>  __found_dec = true;
>       }
>     else if ((__c == __lit[__num_base::_S_ie]
>        || __c == __lit[__num_base::_S_iE])
>       && !__found_sci && __found_mantissa)
>       {
>
>  __xtrc += 'e';
>  __found_sci = true;
>
>
>  if (++__beg != __end)
>    {
>      __c = *__beg;
>      const bool __plus = __c == __lit[__num_base::_S_iplus];
>      if (__plus || __c == __lit[__num_base::_S_iminus])
>        __xtrc += __plus ? '+' : '-';
>      else
>        continue;
>    }
>  else
>    {
>      __testeof = true;
>      break;
>    }
>       }
>     else
>       break;
>
>     if (++__beg != __end)
>       __c = *__beg;
>     else
>       __testeof = true;
>   }
>      else
> while (!__testeof)
>   {
>
>
>     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
>       {
>  if (!__found_dec && !__found_sci)
>    {
>
>
>      if (__sep_pos)
>        {
>   __found_grouping += static_cast<char>(__sep_pos);
>   __sep_pos = 0;
>        }
>      else
>        {
>
>
>   __xtrc.clear();
>   break;
>        }
>    }
>  else
>    break;
>       }
>     else if (__c == __lc->_M_decimal_point)
>       {
>  if (!__found_dec && !__found_sci)
>    {
>
>
>
>      if (__found_grouping.size())
>        __found_grouping += static_cast<char>(__sep_pos);
>      __xtrc += '.';
>      __found_dec = true;
>    }
>  else
>    break;
>       }
>     else
>       {
>  const char_type* __q =
>    __traits_type::find(__lit_zero, 10, __c);
>  if (__q)
>    {
>      __xtrc += '0' + (__q - __lit_zero);
>      __found_mantissa = true;
>      ++__sep_pos;
>    }
>  else if ((__c == __lit[__num_base::_S_ie]
>     || __c == __lit[__num_base::_S_iE])
>    && !__found_sci && __found_mantissa)
>    {
>
>      if (__found_grouping.size() && !__found_dec)
>        __found_grouping += static_cast<char>(__sep_pos);
>      __xtrc += 'e';
>      __found_sci = true;
>
>
>      if (++__beg != __end)
>        {
>   __c = *__beg;
>   const bool __plus = __c == __lit[__num_base::_S_iplus];
>   if ((__plus || __c == __lit[__num_base::_S_iminus])
>       && !(__lc->_M_use_grouping
>     && __c == __lc->_M_thousands_sep)
>       && !(__c == __lc->_M_decimal_point))
>        __xtrc += __plus ? '+' : '-';
>   else
>     continue;
>        }
>      else
>        {
>   __testeof = true;
>   break;
>        }
>    }
>  else
>    break;
>       }
>
>     if (++__beg != __end)
>       __c = *__beg;
>     else
>       __testeof = true;
>   }
>
>
>
>      if (__found_grouping.size())
>        {
>
>   if (!__found_dec && !__found_sci)
>     __found_grouping += static_cast<char>(__sep_pos);
>
>          if (!std::__verify_grouping(__lc->_M_grouping,
>          __lc->_M_grouping_size,
>          __found_grouping))
>     __err = ios_base::failbit;
>        }
>
>      return __beg;
>    }
>
>  template<typename _CharT, typename _InIter>
>    template<typename _ValueT>
>      _InIter
>      num_get<_CharT, _InIter>::
>      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
>       ios_base::iostate& __err, _ValueT& __v) const
>      {
>        typedef char_traits<_CharT> __traits_type;
> using __gnu_cxx::__add_unsigned;
> typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_in;
> char_type __c = char_type();
>
>
> const ios_base::fmtflags __basefield = __io.flags()
>                                        & ios_base::basefield;
> const bool __oct = __basefield == ios_base::oct;
> int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
>
>
> bool __testeof = __beg == __end;
>
>
> bool __negative = false;
> if (!__testeof)
>   {
>     __c = *__beg;
>     __negative = __c == __lit[__num_base::_S_iminus];
>     if ((__negative || __c == __lit[__num_base::_S_iplus])
>  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
>  && !(__c == __lc->_M_decimal_point))
>       {
>  if (++__beg != __end)
>    __c = *__beg;
>  else
>    __testeof = true;
>       }
>   }
>
>
>
> bool __found_zero = false;
> int __sep_pos = 0;
> while (!__testeof)
>   {
>     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
>  || __c == __lc->_M_decimal_point)
>       break;
>     else if (__c == __lit[__num_base::_S_izero]
>       && (!__found_zero || __base == 10))
>       {
>  __found_zero = true;
>  ++__sep_pos;
>  if (__basefield == 0)
>    __base = 8;
>  if (__base == 8)
>    __sep_pos = 0;
>       }
>     else if (__found_zero
>       && (__c == __lit[__num_base::_S_ix]
>    || __c == __lit[__num_base::_S_iX]))
>       {
>  if (__basefield == 0)
>    __base = 16;
>  if (__base == 16)
>    {
>      __found_zero = false;
>      __sep_pos = 0;
>    }
>  else
>    break;
>       }
>     else
>       break;
>
>     if (++__beg != __end)
>       {
>  __c = *__beg;
>  if (!__found_zero)
>    break;
>       }
>     else
>       __testeof = true;
>   }
>
>
>
> const size_t __len = (__base == 16 ? __num_base::_S_iend
>         - __num_base::_S_izero : __base);
>
>
> string __found_grouping;
> if (__lc->_M_use_grouping)
>   __found_grouping.reserve(32);
> bool __testfail = false;
> bool __testoverflow = false;
> const __unsigned_type __max =
>   (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
>   ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
>   : __gnu_cxx::__numeric_traits<_ValueT>::__max;
> const __unsigned_type __smax = __max / __base;
> __unsigned_type __result = 0;
> int __digit = 0;
> const char_type* __lit_zero = __lit + __num_base::_S_izero;
>
> if (!__lc->_M_allocated)
>
>   while (!__testeof)
>     {
>       __digit = _M_find(__lit_zero, __len, __c);
>       if (__digit == -1)
>  break;
>
>       if (__result > __smax)
>  __testoverflow = true;
>       else
>  {
>    __result *= __base;
>    __testoverflow |= __result > __max - __digit;
>    __result += __digit;
>    ++__sep_pos;
>  }
>
>       if (++__beg != __end)
>  __c = *__beg;
>       else
>  __testeof = true;
>     }
> else
>   while (!__testeof)
>     {
>
>
>       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
>  {
>
>
>    if (__sep_pos)
>      {
>        __found_grouping += static_cast<char>(__sep_pos);
>        __sep_pos = 0;
>      }
>    else
>      {
>        __testfail = true;
>        break;
>      }
>  }
>       else if (__c == __lc->_M_decimal_point)
>  break;
>       else
>  {
>    const char_type* __q =
>      __traits_type::find(__lit_zero, __len, __c);
>    if (!__q)
>      break;
>
>    __digit = __q - __lit_zero;
>    if (__digit > 15)
>      __digit -= 6;
>    if (__result > __smax)
>      __testoverflow = true;
>    else
>      {
>        __result *= __base;
>        __testoverflow |= __result > __max - __digit;
>        __result += __digit;
>        ++__sep_pos;
>      }
>  }
>
>       if (++__beg != __end)
>  __c = *__beg;
>       else
>  __testeof = true;
>     }
>
>
>
> if (__found_grouping.size())
>   {
>
>     __found_grouping += static_cast<char>(__sep_pos);
>
>     if (!std::__verify_grouping(__lc->_M_grouping,
>     __lc->_M_grouping_size,
>     __found_grouping))
>       __err = ios_base::failbit;
>   }
>
>
>
> if ((!__sep_pos && !__found_zero && !__found_grouping.size())
>     || __testfail)
>   {
>     __v = 0;
>     __err = ios_base::failbit;
>   }
> else if (__testoverflow)
>   {
>     if (__negative
>  && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
>       __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
>     else
>       __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
>     __err = ios_base::failbit;
>   }
> else
>   __v = __negative ? -__result : __result;
>
> if (__testeof)
>   __err |= ios_base::eofbit;
> return __beg;
>      }
>
>
>
>  template<typename _CharT, typename _InIter>
>    _InIter
>    num_get<_CharT, _InIter>::
>    do_get(iter_type __beg, iter_type __end, ios_base& __io,
>           ios_base::iostate& __err, bool& __v) const
>    {
>      if (!(__io.flags() & ios_base::boolalpha))
>        {
>
>
>
>   long __l = -1;
>          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
>   if (__l == 0 || __l == 1)
>     __v = bool(__l);
>   else
>     {
>
>
>       __v = true;
>       __err = ios_base::failbit;
>       if (__beg == __end)
>  __err |= ios_base::eofbit;
>     }
>        }
>      else
>        {
>
>   typedef __numpunct_cache<_CharT> __cache_type;
>   __use_cache<__cache_type> __uc;
>   const locale& __loc = __io._M_getloc();
>   const __cache_type* __lc = __uc(__loc);
>
>   bool __testf = true;
>   bool __testt = true;
>   bool __donef = __lc->_M_falsename_size == 0;
>   bool __donet = __lc->_M_truename_size == 0;
>   bool __testeof = false;
>   size_t __n = 0;
>   while (!__donef || !__donet)
>     {
>       if (__beg == __end)
>  {
>    __testeof = true;
>    break;
>  }
>
>       const char_type __c = *__beg;
>
>       if (!__donef)
>  __testf = __c == __lc->_M_falsename[__n];
>
>       if (!__testf && __donet)
>  break;
>
>       if (!__donet)
>  __testt = __c == __lc->_M_truename[__n];
>
>       if (!__testt && __donef)
>  break;
>
>       if (!__testt && !__testf)
>  break;
>
>       ++__n;
>       ++__beg;
>
>       __donef = !__testf || __n >= __lc->_M_falsename_size;
>       __donet = !__testt || __n >= __lc->_M_truename_size;
>     }
>   if (__testf && __n == __lc->_M_falsename_size && __n)
>     {
>       __v = false;
>       if (__testt && __n == __lc->_M_truename_size)
>  __err = ios_base::failbit;
>       else
>  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
>     }
>   else if (__testt && __n == __lc->_M_truename_size && __n)
>     {
>       __v = true;
>       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
>     }
>   else
>     {
>
>
>       __v = false;
>       __err = ios_base::failbit;
>       if (__testeof)
>  __err |= ios_base::eofbit;
>     }
> }
>      return __beg;
>    }
>
>  template<typename _CharT, typename _InIter>
>    _InIter
>    num_get<_CharT, _InIter>::
>    do_get(iter_type __beg, iter_type __end, ios_base& __io,
>    ios_base::iostate& __err, float& __v) const
>    {
>      string __xtrc;
>      __xtrc.reserve(32);
>      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
>      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
>      if (__beg == __end)
> __err |= ios_base::eofbit;
>      return __beg;
>    }
>
>  template<typename _CharT, typename _InIter>
>    _InIter
>    num_get<_CharT, _InIter>::
>    do_get(iter_type __beg, iter_type __end, ios_base& __io,
>           ios_base::iostate& __err, double& __v) const
>    {
>      string __xtrc;
>      __xtrc.reserve(32);
>      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
>      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
>      if (__beg == __end)
> __err |= ios_base::eofbit;
>      return __beg;
>    }
># 730 "/usr/include/c++/4.8.0/bits/locale_facets.tcc" 3
>  template<typename _CharT, typename _InIter>
>    _InIter
>    num_get<_CharT, _InIter>::
>    do_get(iter_type __beg, iter_type __end, ios_base& __io,
>           ios_base::iostate& __err, long double& __v) const
>    {
>      string __xtrc;
>      __xtrc.reserve(32);
>      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
>      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
>      if (__beg == __end)
> __err |= ios_base::eofbit;
>      return __beg;
>    }
>
>  template<typename _CharT, typename _InIter>
>    _InIter
>    num_get<_CharT, _InIter>::
>    do_get(iter_type __beg, iter_type __end, ios_base& __io,
>           ios_base::iostate& __err, void*& __v) const
>    {
>
>      typedef ios_base::fmtflags fmtflags;
>      const fmtflags __fmt = __io.flags();
>      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
>
>      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
>          <= sizeof(unsigned long)),
> unsigned long, unsigned long long>::__type _UIntPtrType;
>
>      _UIntPtrType __ul;
>      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
>
>
>      __io.flags(__fmt);
>
>      __v = reinterpret_cast<void*>(__ul);
>      return __beg;
>    }
>
>
>
>  template<typename _CharT, typename _OutIter>
>    void
>    num_put<_CharT, _OutIter>::
>    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
>    _CharT* __new, const _CharT* __cs, int& __len) const
>    {
>
>
>      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
>        __cs, __w, __len);
>      __len = static_cast<int>(__w);
>    }
>
>
>
>  template<typename _CharT, typename _ValueT>
>    int
>    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
>    ios_base::fmtflags __flags, bool __dec)
>    {
>      _CharT* __buf = __bufend;
>      if (__builtin_expect(__dec, true))
> {
>
>   do
>     {
>       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
>       __v /= 10;
>     }
>   while (__v != 0);
> }
>      else if ((__flags & ios_base::basefield) == ios_base::oct)
> {
>
>   do
>     {
>       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
>       __v >>= 3;
>     }
>   while (__v != 0);
> }
>      else
> {
>
>   const bool __uppercase = __flags & ios_base::uppercase;
>   const int __case_offset = __uppercase ? __num_base::_S_oudigits
>                                         : __num_base::_S_odigits;
>   do
>     {
>       *--__buf = __lit[(__v & 0xf) + __case_offset];
>       __v >>= 4;
>     }
>   while (__v != 0);
> }
>      return __bufend - __buf;
>    }
>
>
>
>  template<typename _CharT, typename _OutIter>
>    void
>    num_put<_CharT, _OutIter>::
>    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
>   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
>    {
>      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
>     __grouping_size, __cs, __cs + __len);
>      __len = __p - __new;
>    }
>
>  template<typename _CharT, typename _OutIter>
>    template<typename _ValueT>
>      _OutIter
>      num_put<_CharT, _OutIter>::
>      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
>      _ValueT __v) const
>      {
> using __gnu_cxx::__add_unsigned;
> typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_out;
> const ios_base::fmtflags __flags = __io.flags();
>
>
> const int __ilen = 5 * sizeof(_ValueT);
> _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
>            * __ilen));
>
>
>
> const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
> const bool __dec = (__basefield != ios_base::oct
>       && __basefield != ios_base::hex);
> const __unsigned_type __u = ((__v > 0 || !__dec)
>         ? __unsigned_type(__v)
>         : -__unsigned_type(__v));
>  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
> __cs += __ilen - __len;
>
>
> if (__lc->_M_use_grouping)
>   {
>
>
>     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
>          * (__len + 1)
>          * 2));
>     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
>    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
>     __cs = __cs2 + 2;
>   }
>
>
> if (__builtin_expect(__dec, true))
>   {
>
>     if (__v >= 0)
>       {
>  if (bool(__flags & ios_base::showpos)
>      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
>    *--__cs = __lit[__num_base::_S_oplus], ++__len;
>       }
>     else
>       *--__cs = __lit[__num_base::_S_ominus], ++__len;
>   }
> else if (bool(__flags & ios_base::showbase) && __v)
>   {
>     if (__basefield == ios_base::oct)
>       *--__cs = __lit[__num_base::_S_odigits], ++__len;
>     else
>       {
>
>  const bool __uppercase = __flags & ios_base::uppercase;
>  *--__cs = __lit[__num_base::_S_ox + __uppercase];
>
>  *--__cs = __lit[__num_base::_S_odigits];
>  __len += 2;
>       }
>   }
>
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
>   {
>     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
>          * __w));
>     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
>     __cs = __cs3;
>   }
> __io.width(0);
>
>
>
> return std::__write(__s, __cs, __len);
>      }
>
>  template<typename _CharT, typename _OutIter>
>    void
>    num_put<_CharT, _OutIter>::
>    _M_group_float(const char* __grouping, size_t __grouping_size,
>     _CharT __sep, const _CharT* __p, _CharT* __new,
>     _CharT* __cs, int& __len) const
>    {
>
>
>
>      const int __declen = __p ? __p - __cs : __len;
>      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
>      __grouping_size,
>      __cs, __cs + __declen);
>
>
>      int __newlen = __p2 - __new;
>      if (__p)
> {
>   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
>   __newlen += __len - __declen;
> }
>      __len = __newlen;
>    }
># 966 "/usr/include/c++/4.8.0/bits/locale_facets.tcc" 3
>  template<typename _CharT, typename _OutIter>
>    template<typename _ValueT>
>      _OutIter
>      num_put<_CharT, _OutIter>::
>      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
>         _ValueT __v) const
>      {
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
>
> const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
>
> const int __max_digits =
>   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
>
>
> int __len;
>
> char __fbuf[16];
> __num_base::_S_format_float(__io, __fbuf, __mod);
>
>
>
>
> int __cs_size = __max_digits * 3;
> char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
>          __fbuf, __prec, __v);
>
>
> if (__len >= __cs_size)
>   {
>     __cs_size = __len + 1;
>     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
>     __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
>       __fbuf, __prec, __v);
>   }
># 1027 "/usr/include/c++/4.8.0/bits/locale_facets.tcc" 3
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
>            * __len));
> __ctype.widen(__cs, __cs + __len, __ws);
>
>
> _CharT* __wp = 0;
> const char* __p = char_traits<char>::find(__cs, __len, '.');
> if (__p)
>   {
>     __wp = __ws + (__p - __cs);
>     *__wp = __lc->_M_decimal_point;
>   }
>
>
>
>
> if (__lc->_M_use_grouping
>     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
>          && __cs[1] >= '0' && __cs[2] >= '0')))
>   {
>
>
>     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
>          * __len * 2));
>
>     streamsize __off = 0;
>     if (__cs[0] == '-' || __cs[0] == '+')
>       {
>  __off = 1;
>  __ws2[0] = __ws[0];
>  __len -= 1;
>       }
>
>     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
>      __lc->_M_thousands_sep, __wp, __ws2 + __off,
>      __ws + __off, __len);
>     __len += __off;
>
>     __ws = __ws2;
>   }
>
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
>   {
>     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
>          * __w));
>     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
>     __ws = __ws3;
>   }
> __io.width(0);
>
>
>
> return std::__write(__s, __ws, __len);
>      }
>
>  template<typename _CharT, typename _OutIter>
>    _OutIter
>    num_put<_CharT, _OutIter>::
>    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
>    {
>      const ios_base::fmtflags __flags = __io.flags();
>      if ((__flags & ios_base::boolalpha) == 0)
>        {
>          const long __l = __v;
>          __s = _M_insert_int(__s, __io, __fill, __l);
>        }
>      else
>        {
>   typedef __numpunct_cache<_CharT> __cache_type;
>   __use_cache<__cache_type> __uc;
>   const locale& __loc = __io._M_getloc();
>   const __cache_type* __lc = __uc(__loc);
>
>   const _CharT* __name = __v ? __lc->_M_truename
>                              : __lc->_M_falsename;
>   int __len = __v ? __lc->_M_truename_size
>                   : __lc->_M_falsename_size;
>
>   const streamsize __w = __io.width();
>   if (__w > static_cast<streamsize>(__len))
>     {
>       const streamsize __plen = __w - __len;
>       _CharT* __ps
>  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
>       * __plen));
>
>       char_traits<_CharT>::assign(__ps, __plen, __fill);
>       __io.width(0);
>
>       if ((__flags & ios_base::adjustfield) == ios_base::left)
>  {
>    __s = std::__write(__s, __name, __len);
>    __s = std::__write(__s, __ps, __plen);
>  }
>       else
>  {
>    __s = std::__write(__s, __ps, __plen);
>    __s = std::__write(__s, __name, __len);
>  }
>       return __s;
>     }
>   __io.width(0);
>   __s = std::__write(__s, __name, __len);
> }
>      return __s;
>    }
>
>  template<typename _CharT, typename _OutIter>
>    _OutIter
>    num_put<_CharT, _OutIter>::
>    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
>    { return _M_insert_float(__s, __io, __fill, char(), __v); }
># 1152 "/usr/include/c++/4.8.0/bits/locale_facets.tcc" 3
>  template<typename _CharT, typename _OutIter>
>    _OutIter
>    num_put<_CharT, _OutIter>::
>    do_put(iter_type __s, ios_base& __io, char_type __fill,
>    long double __v) const
>    { return _M_insert_float(__s, __io, __fill, 'L', __v); }
>
>  template<typename _CharT, typename _OutIter>
>    _OutIter
>    num_put<_CharT, _OutIter>::
>    do_put(iter_type __s, ios_base& __io, char_type __fill,
>           const void* __v) const
>    {
>      const ios_base::fmtflags __flags = __io.flags();
>      const ios_base::fmtflags __fmt = ~(ios_base::basefield
>      | ios_base::uppercase);
>      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
>
>      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
>          <= sizeof(unsigned long)),
> unsigned long, unsigned long long>::__type _UIntPtrType;
>
>      __s = _M_insert_int(__s, __io, __fill,
>     reinterpret_cast<_UIntPtrType>(__v));
>      __io.flags(__flags);
>      return __s;
>    }
>
>
># 1189 "/usr/include/c++/4.8.0/bits/locale_facets.tcc" 3
>  template<typename _CharT, typename _Traits>
>    void
>    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
>       _CharT* __news, const _CharT* __olds,
>       streamsize __newlen, streamsize __oldlen)
>    {
>      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
>      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
>
>
>      if (__adjust == ios_base::left)
> {
>   _Traits::copy(__news, __olds, __oldlen);
>   _Traits::assign(__news + __oldlen, __plen, __fill);
>   return;
> }
>
>      size_t __mod = 0;
>      if (__adjust == ios_base::internal)
> {
>
>
>
>          const locale& __loc = __io._M_getloc();
>   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
>   if (__ctype.widen('-') == __olds[0]
>       || __ctype.widen('+') == __olds[0])
>     {
>       __news[0] = __olds[0];
>       __mod = 1;
>       ++__news;
>     }
>   else if (__ctype.widen('0') == __olds[0]
>     && __oldlen > 1
>     && (__ctype.widen('x') == __olds[1]
>         || __ctype.widen('X') == __olds[1]))
>     {
>       __news[0] = __olds[0];
>       __news[1] = __olds[1];
>       __mod = 2;
>       __news += 2;
>     }
>
> }
>      _Traits::assign(__news, __plen, __fill);
>      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
>    }
>
>  template<typename _CharT>
>    _CharT*
>    __add_grouping(_CharT* __s, _CharT __sep,
>     const char* __gbeg, size_t __gsize,
>     const _CharT* __first, const _CharT* __last)
>    {
>      size_t __idx = 0;
>      size_t __ctr = 0;
>
>      while (__last - __first > __gbeg[__idx]
>      && static_cast<signed char>(__gbeg[__idx]) > 0
>      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
> {
>   __last -= __gbeg[__idx];
>   __idx < __gsize - 1 ? ++__idx : ++__ctr;
> }
>
>      while (__first != __last)
> *__s++ = *__first++;
>
>      while (__ctr--)
> {
>   *__s++ = __sep;
>   for (char __i = __gbeg[__idx]; __i > 0; --__i)
>     *__s++ = *__first++;
> }
>
>      while (__idx--)
> {
>   *__s++ = __sep;
>   for (char __i = __gbeg[__idx]; __i > 0; --__i)
>     *__s++ = *__first++;
> }
>
>      return __s;
>    }
>
>
>
>
>  extern template class numpunct<char>;
>  extern template class numpunct_byname<char>;
>  extern template class num_get<char>;
>  extern template class num_put<char>;
>  extern template class ctype_byname<char>;
>
>  extern template
>    const ctype<char>&
>    use_facet<ctype<char> >(const locale&);
>
>  extern template
>    const numpunct<char>&
>    use_facet<numpunct<char> >(const locale&);
>
>  extern template
>    const num_put<char>&
>    use_facet<num_put<char> >(const locale&);
>
>  extern template
>    const num_get<char>&
>    use_facet<num_get<char> >(const locale&);
>
>  extern template
>    bool
>    has_facet<ctype<char> >(const locale&);
>
>  extern template
>    bool
>    has_facet<numpunct<char> >(const locale&);
>
>  extern template
>    bool
>    has_facet<num_put<char> >(const locale&);
>
>  extern template
>    bool
>    has_facet<num_get<char> >(const locale&);
>
>
>  extern template class numpunct<wchar_t>;
>  extern template class numpunct_byname<wchar_t>;
>  extern template class num_get<wchar_t>;
>  extern template class num_put<wchar_t>;
>  extern template class ctype_byname<wchar_t>;
>
>  extern template
>    const ctype<wchar_t>&
>    use_facet<ctype<wchar_t> >(const locale&);
>
>  extern template
>    const numpunct<wchar_t>&
>    use_facet<numpunct<wchar_t> >(const locale&);
>
>  extern template
>    const num_put<wchar_t>&
>    use_facet<num_put<wchar_t> >(const locale&);
>
>  extern template
>    const num_get<wchar_t>&
>    use_facet<num_get<wchar_t> >(const locale&);
>
> extern template
>    bool
>    has_facet<ctype<wchar_t> >(const locale&);
>
>  extern template
>    bool
>    has_facet<numpunct<wchar_t> >(const locale&);
>
>  extern template
>    bool
>    has_facet<num_put<wchar_t> >(const locale&);
>
>  extern template
>    bool
>    has_facet<num_get<wchar_t> >(const locale&);
>
>
>
>
>}
># 2609 "/usr/include/c++/4.8.0/bits/locale_facets.h" 2 3
># 38 "/usr/include/c++/4.8.0/bits/basic_ios.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _Facet>
>    inline const _Facet&
>    __check_facet(const _Facet* __f)
>    {
>      if (!__f)
> __throw_bad_cast();
>      return *__f;
>    }
># 65 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>  template<typename _CharT, typename _Traits>
>    class basic_ios : public ios_base
>    {
>    public:
>
>
>
>
>
>
>      typedef _CharT char_type;
>      typedef typename _Traits::int_type int_type;
>      typedef typename _Traits::pos_type pos_type;
>      typedef typename _Traits::off_type off_type;
>      typedef _Traits traits_type;
>
>
>
>
>
>
>      typedef ctype<_CharT> __ctype_type;
>      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
>           __num_put_type;
>      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
>           __num_get_type;
>
>
>
>    protected:
>      basic_ostream<_CharT, _Traits>* _M_tie;
>      mutable char_type _M_fill;
>      mutable bool _M_fill_init;
>      basic_streambuf<_CharT, _Traits>* _M_streambuf;
>
>
>      const __ctype_type* _M_ctype;
>
>      const __num_put_type* _M_num_put;
>
>      const __num_get_type* _M_num_get;
>
>    public:
>
>
>
>
>
>
>
>      operator void*() const
>      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
>
>      bool
>      operator!() const
>      { return this->fail(); }
># 130 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      iostate
>      rdstate() const
>      { return _M_streambuf_state; }
># 141 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      void
>      clear(iostate __state = goodbit);
>
>
>
>
>
>
>
>      void
>      setstate(iostate __state)
>      { this->clear(this->rdstate() | __state); }
>
>
>
>
>      void
>      _M_setstate(iostate __state)
>      {
>
>
> _M_streambuf_state |= __state;
> if (this->exceptions() & __state)
>   throw;
>      }
>
>
>
>
>
>
>
>      bool
>      good() const
>      { return this->rdstate() == 0; }
>
>
>
>
>
>
>
>      bool
>      eof() const
>      { return (this->rdstate() & eofbit) != 0; }
># 194 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      bool
>      fail() const
>      { return (this->rdstate() & (badbit | failbit)) != 0; }
>
>
>
>
>
>
>
>      bool
>      bad() const
>      { return (this->rdstate() & badbit) != 0; }
># 215 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      iostate
>      exceptions() const
>      { return _M_exception; }
># 250 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      void
>      exceptions(iostate __except)
>      {
>        _M_exception = __except;
>        this->clear(_M_streambuf_state);
>      }
>
>
>
>
>
>
>
>      explicit
>      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
>      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
> _M_ctype(0), _M_num_put(0), _M_num_get(0)
>      { this->init(__sb); }
>
>
>
>
>
>
>
>      virtual
>      ~basic_ios() { }
># 288 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      basic_ostream<_CharT, _Traits>*
>      tie() const
>      { return _M_tie; }
># 300 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      basic_ostream<_CharT, _Traits>*
>      tie(basic_ostream<_CharT, _Traits>* __tiestr)
>      {
>        basic_ostream<_CharT, _Traits>* __old = _M_tie;
>        _M_tie = __tiestr;
>        return __old;
>      }
>
>
>
>
>
>
>
>      basic_streambuf<_CharT, _Traits>*
>      rdbuf() const
>      { return _M_streambuf; }
># 340 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      basic_streambuf<_CharT, _Traits>*
>      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
># 354 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      basic_ios&
>      copyfmt(const basic_ios& __rhs);
>
>
>
>
>
>
>
>      char_type
>      fill() const
>      {
> if (!_M_fill_init)
>   {
>     _M_fill = this->widen(' ');
>     _M_fill_init = true;
>   }
> return _M_fill;
>      }
># 383 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      char_type
>      fill(char_type __ch)
>      {
> char_type __old = this->fill();
> _M_fill = __ch;
> return __old;
>      }
># 403 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      locale
>      imbue(const locale& __loc);
># 423 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      char
>      narrow(char_type __c, char __dfault) const
>      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
># 442 "/usr/include/c++/4.8.0/bits/basic_ios.h" 3
>      char_type
>      widen(char __c) const
>      { return __check_facet(_M_ctype).widen(__c); }
>
>    protected:
>
>
>
>
>
>
>
>      basic_ios()
>      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
> _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
>      { }
>
>
>
>
>
>
>
>      void
>      init(basic_streambuf<_CharT, _Traits>* __sb);
>
>      void
>      _M_cache_locale(const locale& __loc);
>    };
>
>
>}
>
># 1 "/usr/include/c++/4.8.0/bits/basic_ios.tcc" 1 3
># 33 "/usr/include/c++/4.8.0/bits/basic_ios.tcc" 3
>       
># 34 "/usr/include/c++/4.8.0/bits/basic_ios.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _CharT, typename _Traits>
>    void
>    basic_ios<_CharT, _Traits>::clear(iostate __state)
>    {
>      if (this->rdbuf())
> _M_streambuf_state = __state;
>      else
>   _M_streambuf_state = __state | badbit;
>      if (this->exceptions() & this->rdstate())
> __throw_ios_failure(("basic_ios::clear"));
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_streambuf<_CharT, _Traits>*
>    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
>    {
>      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
>      _M_streambuf = __sb;
>      this->clear();
>      return __old;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ios<_CharT, _Traits>&
>    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
>    {
>
>
>      if (this != &__rhs)
> {
>
>
>
>
>   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
>                      _M_local_word : new _Words[__rhs._M_word_size];
>
>
>   _Callback_list* __cb = __rhs._M_callbacks;
>   if (__cb)
>     __cb->_M_add_reference();
>   _M_call_callbacks(erase_event);
>   if (_M_word != _M_local_word)
>     {
>       delete [] _M_word;
>       _M_word = 0;
>     }
>   _M_dispose_callbacks();
>
>
>   _M_callbacks = __cb;
>   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
>     __words[__i] = __rhs._M_word[__i];
>   _M_word = __words;
>   _M_word_size = __rhs._M_word_size;
>
>   this->flags(__rhs.flags());
>   this->width(__rhs.width());
>   this->precision(__rhs.precision());
>   this->tie(__rhs.tie());
>   this->fill(__rhs.fill());
>   _M_ios_locale = __rhs.getloc();
>   _M_cache_locale(_M_ios_locale);
>
>   _M_call_callbacks(copyfmt_event);
>
>
>   this->exceptions(__rhs.exceptions());
> }
>      return *this;
>    }
>
>
>  template<typename _CharT, typename _Traits>
>    locale
>    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
>    {
>      locale __old(this->getloc());
>      ios_base::imbue(__loc);
>      _M_cache_locale(__loc);
>      if (this->rdbuf() != 0)
> this->rdbuf()->pubimbue(__loc);
>      return __old;
>    }
>
>  template<typename _CharT, typename _Traits>
>    void
>    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
>    {
>
>      ios_base::_M_init();
>
>
>      _M_cache_locale(_M_ios_locale);
># 146 "/usr/include/c++/4.8.0/bits/basic_ios.tcc" 3
>      _M_fill = _CharT();
>      _M_fill_init = false;
>
>      _M_tie = 0;
>      _M_exception = goodbit;
>      _M_streambuf = __sb;
>      _M_streambuf_state = __sb ? goodbit : badbit;
>    }
>
>  template<typename _CharT, typename _Traits>
>    void
>    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
>    {
>      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
> _M_ctype = &use_facet<__ctype_type>(__loc);
>      else
> _M_ctype = 0;
>
>      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
> _M_num_put = &use_facet<__num_put_type>(__loc);
>      else
> _M_num_put = 0;
>
>      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
> _M_num_get = &use_facet<__num_get_type>(__loc);
>      else
> _M_num_get = 0;
>    }
>
>
>
>
>  extern template class basic_ios<char>;
>
>
>  extern template class basic_ios<wchar_t>;
>
>
>
>
>}
># 476 "/usr/include/c++/4.8.0/bits/basic_ios.h" 2 3
># 45 "/usr/include/c++/4.8.0/ios" 2 3
># 39 "/usr/include/c++/4.8.0/ostream" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 57 "/usr/include/c++/4.8.0/ostream" 3
>  template<typename _CharT, typename _Traits>
>    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
>    {
>    public:
>
>      typedef _CharT char_type;
>      typedef typename _Traits::int_type int_type;
>      typedef typename _Traits::pos_type pos_type;
>      typedef typename _Traits::off_type off_type;
>      typedef _Traits traits_type;
>
>
>      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
>      typedef basic_ios<_CharT, _Traits> __ios_type;
>      typedef basic_ostream<_CharT, _Traits> __ostream_type;
>      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
>             __num_put_type;
>      typedef ctype<_CharT> __ctype_type;
># 83 "/usr/include/c++/4.8.0/ostream" 3
>      explicit
>      basic_ostream(__streambuf_type* __sb)
>      { this->init(__sb); }
>
>
>
>
>
>
>      virtual
>      ~basic_ostream() { }
>
>
>      class sentry;
>      friend class sentry;
># 107 "/usr/include/c++/4.8.0/ostream" 3
>      __ostream_type&
>      operator<<(__ostream_type& (*__pf)(__ostream_type&))
>      {
>
>
>
> return __pf(*this);
>      }
>
>      __ostream_type&
>      operator<<(__ios_type& (*__pf)(__ios_type&))
>      {
>
>
>
> __pf(*this);
> return *this;
>      }
>
>      __ostream_type&
>      operator<<(ios_base& (*__pf) (ios_base&))
>      {
>
>
>
> __pf(*this);
> return *this;
>      }
># 165 "/usr/include/c++/4.8.0/ostream" 3
>      __ostream_type&
>      operator<<(long __n)
>      { return _M_insert(__n); }
>
>      __ostream_type&
>      operator<<(unsigned long __n)
>      { return _M_insert(__n); }
>
>      __ostream_type&
>      operator<<(bool __n)
>      { return _M_insert(__n); }
>
>      __ostream_type&
>      operator<<(short __n);
>
>      __ostream_type&
>      operator<<(unsigned short __n)
>      {
>
>
> return _M_insert(static_cast<unsigned long>(__n));
>      }
>
>      __ostream_type&
>      operator<<(int __n);
>
>      __ostream_type&
>      operator<<(unsigned int __n)
>      {
>
>
> return _M_insert(static_cast<unsigned long>(__n));
>      }
>
>
>      __ostream_type&
>      operator<<(long long __n)
>      { return _M_insert(__n); }
>
>      __ostream_type&
>      operator<<(unsigned long long __n)
>      { return _M_insert(__n); }
># 219 "/usr/include/c++/4.8.0/ostream" 3
>      __ostream_type&
>      operator<<(double __f)
>      { return _M_insert(__f); }
>
>      __ostream_type&
>      operator<<(float __f)
>      {
>
>
> return _M_insert(static_cast<double>(__f));
>      }
>
>      __ostream_type&
>      operator<<(long double __f)
>      { return _M_insert(__f); }
># 244 "/usr/include/c++/4.8.0/ostream" 3
>      __ostream_type&
>      operator<<(const void* __p)
>      { return _M_insert(__p); }
># 269 "/usr/include/c++/4.8.0/ostream" 3
>      __ostream_type&
>      operator<<(__streambuf_type* __sb);
># 302 "/usr/include/c++/4.8.0/ostream" 3
>      __ostream_type&
>      put(char_type __c);
>
>
>
>
>
>
>      void
>      _M_write(const char_type* __s, streamsize __n)
>      {
> const streamsize __put = this->rdbuf()->sputn(__s, __n);
> if (__put != __n)
>   this->setstate(ios_base::badbit);
>      }
># 334 "/usr/include/c++/4.8.0/ostream" 3
>      __ostream_type&
>      write(const char_type* __s, streamsize __n);
># 347 "/usr/include/c++/4.8.0/ostream" 3
>      __ostream_type&
>      flush();
># 357 "/usr/include/c++/4.8.0/ostream" 3
>      pos_type
>      tellp();
># 368 "/usr/include/c++/4.8.0/ostream" 3
>      __ostream_type&
>      seekp(pos_type);
># 380 "/usr/include/c++/4.8.0/ostream" 3
>       __ostream_type&
>      seekp(off_type, ios_base::seekdir);
>
>    protected:
>      basic_ostream()
>      { this->init(0); }
>
>      template<typename _ValueT>
> __ostream_type&
> _M_insert(_ValueT __v);
>    };
># 399 "/usr/include/c++/4.8.0/ostream" 3
>  template <typename _CharT, typename _Traits>
>    class basic_ostream<_CharT, _Traits>::sentry
>    {
>
>      bool _M_ok;
>      basic_ostream<_CharT, _Traits>& _M_os;
>
>    public:
># 418 "/usr/include/c++/4.8.0/ostream" 3
>      explicit
>      sentry(basic_ostream<_CharT, _Traits>& __os);
># 428 "/usr/include/c++/4.8.0/ostream" 3
>      ~sentry()
>      {
>
> if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
>   {
>
>     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
>       _M_os.setstate(ios_base::badbit);
>   }
>      }
># 449 "/usr/include/c++/4.8.0/ostream" 3
>      operator bool() const
>      { return _M_ok; }
>    };
># 469 "/usr/include/c++/4.8.0/ostream" 3
>  template<typename _CharT, typename _Traits>
>    inline basic_ostream<_CharT, _Traits>&
>    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
>    { return __ostream_insert(__out, &__c, 1); }
>
>  template<typename _CharT, typename _Traits>
>    inline basic_ostream<_CharT, _Traits>&
>    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
>    { return (__out << __out.widen(__c)); }
>
>
>  template <class _Traits>
>    inline basic_ostream<char, _Traits>&
>    operator<<(basic_ostream<char, _Traits>& __out, char __c)
>    { return __ostream_insert(__out, &__c, 1); }
>
>
>  template<class _Traits>
>    inline basic_ostream<char, _Traits>&
>    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
>    { return (__out << static_cast<char>(__c)); }
>
>  template<class _Traits>
>    inline basic_ostream<char, _Traits>&
>    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
>    { return (__out << static_cast<char>(__c)); }
># 511 "/usr/include/c++/4.8.0/ostream" 3
>  template<typename _CharT, typename _Traits>
>    inline basic_ostream<_CharT, _Traits>&
>    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
>    {
>      if (!__s)
> __out.setstate(ios_base::badbit);
>      else
> __ostream_insert(__out, __s,
>    static_cast<streamsize>(_Traits::length(__s)));
>      return __out;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits> &
>    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
>
>
>  template<class _Traits>
>    inline basic_ostream<char, _Traits>&
>    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
>    {
>      if (!__s)
> __out.setstate(ios_base::badbit);
>      else
> __ostream_insert(__out, __s,
>    static_cast<streamsize>(_Traits::length(__s)));
>      return __out;
>    }
>
>
>  template<class _Traits>
>    inline basic_ostream<char, _Traits>&
>    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
>    { return (__out << reinterpret_cast<const char*>(__s)); }
>
>  template<class _Traits>
>    inline basic_ostream<char, _Traits> &
>    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
>    { return (__out << reinterpret_cast<const char*>(__s)); }
># 562 "/usr/include/c++/4.8.0/ostream" 3
>  template<typename _CharT, typename _Traits>
>    inline basic_ostream<_CharT, _Traits>&
>    endl(basic_ostream<_CharT, _Traits>& __os)
>    { return flush(__os.put(__os.widen('\n'))); }
># 574 "/usr/include/c++/4.8.0/ostream" 3
>  template<typename _CharT, typename _Traits>
>    inline basic_ostream<_CharT, _Traits>&
>    ends(basic_ostream<_CharT, _Traits>& __os)
>    { return __os.put(_CharT()); }
>
>
>
>
>
>
>  template<typename _CharT, typename _Traits>
>    inline basic_ostream<_CharT, _Traits>&
>    flush(basic_ostream<_CharT, _Traits>& __os)
>    { return __os.flush(); }
># 606 "/usr/include/c++/4.8.0/ostream" 3
>
>}
>
># 1 "/usr/include/c++/4.8.0/bits/ostream.tcc" 1 3
># 37 "/usr/include/c++/4.8.0/bits/ostream.tcc" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/ostream.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>::sentry::
>    sentry(basic_ostream<_CharT, _Traits>& __os)
>    : _M_ok(false), _M_os(__os)
>    {
>
>      if (__os.tie() && __os.good())
> __os.tie()->flush();
>
>      if (__os.good())
> _M_ok = true;
>      else
> __os.setstate(ios_base::failbit);
>    }
>
>  template<typename _CharT, typename _Traits>
>    template<typename _ValueT>
>      basic_ostream<_CharT, _Traits>&
>      basic_ostream<_CharT, _Traits>::
>      _M_insert(_ValueT __v)
>      {
> sentry __cerb(*this);
> if (__cerb)
>   {
>     ios_base::iostate __err = ios_base::goodbit;
>     try
>       {
>  const __num_put_type& __np = __check_facet(this->_M_num_put);
>  if (__np.put(*this, *this, this->fill(), __v).failed())
>    __err |= ios_base::badbit;
>       }
>     catch(__cxxabiv1::__forced_unwind&)
>       {
>  this->_M_setstate(ios_base::badbit);
>  throw;
>       }
>     catch(...)
>       { this->_M_setstate(ios_base::badbit); }
>     if (__err)
>       this->setstate(__err);
>   }
> return *this;
>      }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>&
>    basic_ostream<_CharT, _Traits>::
>    operator<<(short __n)
>    {
>
>
>      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
>      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
> return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
>      else
> return _M_insert(static_cast<long>(__n));
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>&
>    basic_ostream<_CharT, _Traits>::
>    operator<<(int __n)
>    {
>
>
>      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
>      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
> return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
>      else
> return _M_insert(static_cast<long>(__n));
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>&
>    basic_ostream<_CharT, _Traits>::
>    operator<<(__streambuf_type* __sbin)
>    {
>      ios_base::iostate __err = ios_base::goodbit;
>      sentry __cerb(*this);
>      if (__cerb && __sbin)
> {
>   try
>     {
>       if (!__copy_streambufs(__sbin, this->rdbuf()))
>  __err |= ios_base::failbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::failbit); }
> }
>      else if (!__sbin)
> __err |= ios_base::badbit;
>      if (__err)
> this->setstate(__err);
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>&
>    basic_ostream<_CharT, _Traits>::
>    put(char_type __c)
>    {
>
>
>
>
>
>
>      sentry __cerb(*this);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       const int_type __put = this->rdbuf()->sputc(__c);
>       if (traits_type::eq_int_type(__put, traits_type::eof()))
>  __err |= ios_base::badbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>&
>    basic_ostream<_CharT, _Traits>::
>    write(const _CharT* __s, streamsize __n)
>    {
>
>
>
>
>
>
>
>      sentry __cerb(*this);
>      if (__cerb)
> {
>   try
>     { _M_write(__s, __n); }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>&
>    basic_ostream<_CharT, _Traits>::
>    flush()
>    {
>
>
>
>      ios_base::iostate __err = ios_base::goodbit;
>      try
> {
>   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
>     __err |= ios_base::badbit;
> }
>      catch(__cxxabiv1::__forced_unwind&)
> {
>   this->_M_setstate(ios_base::badbit);
>   throw;
> }
>      catch(...)
> { this->_M_setstate(ios_base::badbit); }
>      if (__err)
> this->setstate(__err);
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    typename basic_ostream<_CharT, _Traits>::pos_type
>    basic_ostream<_CharT, _Traits>::
>    tellp()
>    {
>      pos_type __ret = pos_type(-1);
>      try
> {
>   if (!this->fail())
>     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
> }
>      catch(__cxxabiv1::__forced_unwind&)
> {
>   this->_M_setstate(ios_base::badbit);
>   throw;
> }
>      catch(...)
> { this->_M_setstate(ios_base::badbit); }
>      return __ret;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>&
>    basic_ostream<_CharT, _Traits>::
>    seekp(pos_type __pos)
>    {
>      ios_base::iostate __err = ios_base::goodbit;
>      try
> {
>   if (!this->fail())
>     {
>
>
>       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
>            ios_base::out);
>
>
>       if (__p == pos_type(off_type(-1)))
>  __err |= ios_base::failbit;
>     }
> }
>      catch(__cxxabiv1::__forced_unwind&)
> {
>   this->_M_setstate(ios_base::badbit);
>   throw;
> }
>      catch(...)
> { this->_M_setstate(ios_base::badbit); }
>      if (__err)
> this->setstate(__err);
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>&
>    basic_ostream<_CharT, _Traits>::
>    seekp(off_type __off, ios_base::seekdir __dir)
>    {
>      ios_base::iostate __err = ios_base::goodbit;
>      try
> {
>   if (!this->fail())
>     {
>
>
>       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
>            ios_base::out);
>
>
>       if (__p == pos_type(off_type(-1)))
>  __err |= ios_base::failbit;
>     }
> }
>      catch(__cxxabiv1::__forced_unwind&)
> {
>   this->_M_setstate(ios_base::badbit);
>   throw;
> }
>      catch(...)
> { this->_M_setstate(ios_base::badbit); }
>      if (__err)
> this->setstate(__err);
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_ostream<_CharT, _Traits>&
>    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
>    {
>      if (!__s)
> __out.setstate(ios_base::badbit);
>      else
> {
>
>
>   const size_t __clen = char_traits<char>::length(__s);
>   try
>     {
>       struct __ptr_guard
>       {
>  _CharT *__p;
>  __ptr_guard (_CharT *__ip): __p(__ip) { }
>  ~__ptr_guard() { delete[] __p; }
>  _CharT* __get() { return __p; }
>       } __pg (new _CharT[__clen]);
>
>       _CharT *__ws = __pg.__get();
>       for (size_t __i = 0; __i < __clen; ++__i)
>  __ws[__i] = __out.widen(__s[__i]);
>       __ostream_insert(__out, __ws, __clen);
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       __out._M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { __out._M_setstate(ios_base::badbit); }
> }
>      return __out;
>    }
>
>
>
>
>  extern template class basic_ostream<char>;
>  extern template ostream& endl(ostream&);
>  extern template ostream& ends(ostream&);
>  extern template ostream& flush(ostream&);
>  extern template ostream& operator<<(ostream&, char);
>  extern template ostream& operator<<(ostream&, unsigned char);
>  extern template ostream& operator<<(ostream&, signed char);
>  extern template ostream& operator<<(ostream&, const char*);
>  extern template ostream& operator<<(ostream&, const unsigned char*);
>  extern template ostream& operator<<(ostream&, const signed char*);
>
>  extern template ostream& ostream::_M_insert(long);
>  extern template ostream& ostream::_M_insert(unsigned long);
>  extern template ostream& ostream::_M_insert(bool);
>
>  extern template ostream& ostream::_M_insert(long long);
>  extern template ostream& ostream::_M_insert(unsigned long long);
>
>  extern template ostream& ostream::_M_insert(double);
>  extern template ostream& ostream::_M_insert(long double);
>  extern template ostream& ostream::_M_insert(const void*);
>
>
>  extern template class basic_ostream<wchar_t>;
>  extern template wostream& endl(wostream&);
>  extern template wostream& ends(wostream&);
>  extern template wostream& flush(wostream&);
>  extern template wostream& operator<<(wostream&, wchar_t);
>  extern template wostream& operator<<(wostream&, char);
>  extern template wostream& operator<<(wostream&, const wchar_t*);
>  extern template wostream& operator<<(wostream&, const char*);
>
>  extern template wostream& wostream::_M_insert(long);
>  extern template wostream& wostream::_M_insert(unsigned long);
>  extern template wostream& wostream::_M_insert(bool);
>
>  extern template wostream& wostream::_M_insert(long long);
>  extern template wostream& wostream::_M_insert(unsigned long long);
>
>  extern template wostream& wostream::_M_insert(double);
>  extern template wostream& wostream::_M_insert(long double);
>  extern template wostream& wostream::_M_insert(const void*);
>
>
>
>
>}
># 610 "/usr/include/c++/4.8.0/ostream" 2 3
># 40 "/usr/include/c++/4.8.0/iostream" 2 3
># 1 "/usr/include/c++/4.8.0/istream" 1 3
># 36 "/usr/include/c++/4.8.0/istream" 3
>       
># 37 "/usr/include/c++/4.8.0/istream" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 57 "/usr/include/c++/4.8.0/istream" 3
>  template<typename _CharT, typename _Traits>
>    class basic_istream : virtual public basic_ios<_CharT, _Traits>
>    {
>    public:
>
>      typedef _CharT char_type;
>      typedef typename _Traits::int_type int_type;
>      typedef typename _Traits::pos_type pos_type;
>      typedef typename _Traits::off_type off_type;
>      typedef _Traits traits_type;
>
>
>      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
>      typedef basic_ios<_CharT, _Traits> __ios_type;
>      typedef basic_istream<_CharT, _Traits> __istream_type;
>      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
>        __num_get_type;
>      typedef ctype<_CharT> __ctype_type;
>
>    protected:
>
>
>
>
>
>      streamsize _M_gcount;
>
>    public:
>
>
>
>
>
>
>
>      explicit
>      basic_istream(__streambuf_type* __sb)
>      : _M_gcount(streamsize(0))
>      { this->init(__sb); }
>
>
>
>
>
>
>      virtual
>      ~basic_istream()
>      { _M_gcount = streamsize(0); }
>
>
>      class sentry;
>      friend class sentry;
># 119 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      operator>>(__istream_type& (*__pf)(__istream_type&))
>      { return __pf(*this); }
>
>      __istream_type&
>      operator>>(__ios_type& (*__pf)(__ios_type&))
>      {
> __pf(*this);
> return *this;
>      }
>
>      __istream_type&
>      operator>>(ios_base& (*__pf)(ios_base&))
>      {
> __pf(*this);
> return *this;
>      }
># 167 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      operator>>(bool& __n)
>      { return _M_extract(__n); }
>
>      __istream_type&
>      operator>>(short& __n);
>
>      __istream_type&
>      operator>>(unsigned short& __n)
>      { return _M_extract(__n); }
>
>      __istream_type&
>      operator>>(int& __n);
>
>      __istream_type&
>      operator>>(unsigned int& __n)
>      { return _M_extract(__n); }
>
>      __istream_type&
>      operator>>(long& __n)
>      { return _M_extract(__n); }
>
>      __istream_type&
>      operator>>(unsigned long& __n)
>      { return _M_extract(__n); }
>
>
>      __istream_type&
>      operator>>(long long& __n)
>      { return _M_extract(__n); }
>
>      __istream_type&
>      operator>>(unsigned long long& __n)
>      { return _M_extract(__n); }
># 213 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      operator>>(float& __f)
>      { return _M_extract(__f); }
>
>      __istream_type&
>      operator>>(double& __f)
>      { return _M_extract(__f); }
>
>      __istream_type&
>      operator>>(long double& __f)
>      { return _M_extract(__f); }
># 234 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      operator>>(void*& __p)
>      { return _M_extract(__p); }
># 258 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      operator>>(__streambuf_type* __sb);
># 268 "/usr/include/c++/4.8.0/istream" 3
>      streamsize
>      gcount() const
>      { return _M_gcount; }
># 301 "/usr/include/c++/4.8.0/istream" 3
>      int_type
>      get();
># 315 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      get(char_type& __c);
># 342 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      get(char_type* __s, streamsize __n, char_type __delim);
># 353 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      get(char_type* __s, streamsize __n)
>      { return this->get(__s, __n, this->widen('\n')); }
># 376 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      get(__streambuf_type& __sb, char_type __delim);
># 386 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      get(__streambuf_type& __sb)
>      { return this->get(__sb, this->widen('\n')); }
># 415 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      getline(char_type* __s, streamsize __n, char_type __delim);
># 426 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      getline(char_type* __s, streamsize __n)
>      { return this->getline(__s, __n, this->widen('\n')); }
># 450 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      ignore(streamsize __n, int_type __delim);
>
>      __istream_type&
>      ignore(streamsize __n);
>
>      __istream_type&
>      ignore();
># 467 "/usr/include/c++/4.8.0/istream" 3
>      int_type
>      peek();
># 485 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      read(char_type* __s, streamsize __n);
># 504 "/usr/include/c++/4.8.0/istream" 3
>      streamsize
>      readsome(char_type* __s, streamsize __n);
># 521 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      putback(char_type __c);
># 537 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      unget();
># 555 "/usr/include/c++/4.8.0/istream" 3
>      int
>      sync();
># 570 "/usr/include/c++/4.8.0/istream" 3
>      pos_type
>      tellg();
># 585 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      seekg(pos_type);
># 601 "/usr/include/c++/4.8.0/istream" 3
>      __istream_type&
>      seekg(off_type, ios_base::seekdir);
>
>
>    protected:
>      basic_istream()
>      : _M_gcount(streamsize(0))
>      { this->init(0); }
>
>      template<typename _ValueT>
> __istream_type&
> _M_extract(_ValueT& __v);
>    };
>
>
>  template<>
>    basic_istream<char>&
>    basic_istream<char>::
>    getline(char_type* __s, streamsize __n, char_type __delim);
>
>  template<>
>    basic_istream<char>&
>    basic_istream<char>::
>    ignore(streamsize __n);
>
>  template<>
>    basic_istream<char>&
>    basic_istream<char>::
>    ignore(streamsize __n, int_type __delim);
>
>
>  template<>
>    basic_istream<wchar_t>&
>    basic_istream<wchar_t>::
>    getline(char_type* __s, streamsize __n, char_type __delim);
>
>  template<>
>    basic_istream<wchar_t>&
>    basic_istream<wchar_t>::
>    ignore(streamsize __n);
>
>  template<>
>    basic_istream<wchar_t>&
>    basic_istream<wchar_t>::
>    ignore(streamsize __n, int_type __delim);
># 656 "/usr/include/c++/4.8.0/istream" 3
>  template<typename _CharT, typename _Traits>
>    class basic_istream<_CharT, _Traits>::sentry
>    {
>
>      bool _M_ok;
>
>    public:
>
>      typedef _Traits traits_type;
>      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
>      typedef basic_istream<_CharT, _Traits> __istream_type;
>      typedef typename __istream_type::__ctype_type __ctype_type;
>      typedef typename _Traits::int_type __int_type;
># 692 "/usr/include/c++/4.8.0/istream" 3
>      explicit
>      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
># 705 "/usr/include/c++/4.8.0/istream" 3
>      operator bool() const
>      { return _M_ok; }
>    };
># 721 "/usr/include/c++/4.8.0/istream" 3
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
>
>  template<class _Traits>
>    inline basic_istream<char, _Traits>&
>    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
>    { return (__in >> reinterpret_cast<char&>(__c)); }
>
>  template<class _Traits>
>    inline basic_istream<char, _Traits>&
>    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
>    { return (__in >> reinterpret_cast<char&>(__c)); }
># 763 "/usr/include/c++/4.8.0/istream" 3
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
>
>
>  template<>
>    basic_istream<char>&
>    operator>>(basic_istream<char>& __in, char* __s);
>
>  template<class _Traits>
>    inline basic_istream<char, _Traits>&
>    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
>    { return (__in >> reinterpret_cast<char*>(__s)); }
>
>  template<class _Traits>
>    inline basic_istream<char, _Traits>&
>    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
>    { return (__in >> reinterpret_cast<char*>(__s)); }
># 794 "/usr/include/c++/4.8.0/istream" 3
>  template<typename _CharT, typename _Traits>
>    class basic_iostream
>    : public basic_istream<_CharT, _Traits>,
>      public basic_ostream<_CharT, _Traits>
>    {
>    public:
>
>
>
>      typedef _CharT char_type;
>      typedef typename _Traits::int_type int_type;
>      typedef typename _Traits::pos_type pos_type;
>      typedef typename _Traits::off_type off_type;
>      typedef _Traits traits_type;
>
>
>      typedef basic_istream<_CharT, _Traits> __istream_type;
>      typedef basic_ostream<_CharT, _Traits> __ostream_type;
>
>
>
>
>
>
>
>      explicit
>      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
>      : __istream_type(__sb), __ostream_type(__sb) { }
>
>
>
>
>      virtual
>      ~basic_iostream() { }
>
>    protected:
>      basic_iostream()
>      : __istream_type(), __ostream_type() { }
>    };
># 854 "/usr/include/c++/4.8.0/istream" 3
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    ws(basic_istream<_CharT, _Traits>& __is);
># 876 "/usr/include/c++/4.8.0/istream" 3
>
>}
>
># 1 "/usr/include/c++/4.8.0/bits/istream.tcc" 1 3
># 37 "/usr/include/c++/4.8.0/bits/istream.tcc" 3
>       
># 38 "/usr/include/c++/4.8.0/bits/istream.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>::sentry::
>    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
>    {
>      ios_base::iostate __err = ios_base::goodbit;
>      if (__in.good())
> {
>   if (__in.tie())
>     __in.tie()->flush();
>   if (!__noskip && bool(__in.flags() & ios_base::skipws))
>     {
>       const __int_type __eof = traits_type::eof();
>       __streambuf_type* __sb = __in.rdbuf();
>       __int_type __c = __sb->sgetc();
>
>       const __ctype_type& __ct = __check_facet(__in._M_ctype);
>       while (!traits_type::eq_int_type(__c, __eof)
>       && __ct.is(ctype_base::space,
>    traits_type::to_char_type(__c)))
>  __c = __sb->snextc();
>
>
>
>
>       if (traits_type::eq_int_type(__c, __eof))
>  __err |= ios_base::eofbit;
>     }
> }
>
>      if (__in.good() && __err == ios_base::goodbit)
> _M_ok = true;
>      else
> {
>   __err |= ios_base::failbit;
>   __in.setstate(__err);
> }
>    }
>
>  template<typename _CharT, typename _Traits>
>    template<typename _ValueT>
>      basic_istream<_CharT, _Traits>&
>      basic_istream<_CharT, _Traits>::
>      _M_extract(_ValueT& __v)
>      {
> sentry __cerb(*this, false);
> if (__cerb)
>   {
>     ios_base::iostate __err = ios_base::goodbit;
>     try
>       {
>  const __num_get_type& __ng = __check_facet(this->_M_num_get);
>  __ng.get(*this, 0, *this, __err, __v);
>       }
>     catch(__cxxabiv1::__forced_unwind&)
>       {
>  this->_M_setstate(ios_base::badbit);
>  throw;
>       }
>     catch(...)
>       { this->_M_setstate(ios_base::badbit); }
>     if (__err)
>       this->setstate(__err);
>   }
> return *this;
>      }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    operator>>(short& __n)
>    {
>
>
>      sentry __cerb(*this, false);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       long __l;
>       const __num_get_type& __ng = __check_facet(this->_M_num_get);
>       __ng.get(*this, 0, *this, __err, __l);
>
>
>
>       if (__l < __gnu_cxx::__numeric_traits<short>::__min)
>  {
>    __err |= ios_base::failbit;
>    __n = __gnu_cxx::__numeric_traits<short>::__min;
>  }
>       else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
>  {
>    __err |= ios_base::failbit;
>    __n = __gnu_cxx::__numeric_traits<short>::__max;
>  }
>       else
>  __n = short(__l);
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    operator>>(int& __n)
>    {
>
>
>      sentry __cerb(*this, false);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       long __l;
>       const __num_get_type& __ng = __check_facet(this->_M_num_get);
>       __ng.get(*this, 0, *this, __err, __l);
>
>
>
>       if (__l < __gnu_cxx::__numeric_traits<int>::__min)
>  {
>    __err |= ios_base::failbit;
>    __n = __gnu_cxx::__numeric_traits<int>::__min;
>  }
>       else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
>  {
>    __err |= ios_base::failbit;
>    __n = __gnu_cxx::__numeric_traits<int>::__max;
>  }
>       else
>  __n = int(__l);
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    operator>>(__streambuf_type* __sbout)
>    {
>      ios_base::iostate __err = ios_base::goodbit;
>      sentry __cerb(*this, false);
>      if (__cerb && __sbout)
> {
>   try
>     {
>       bool __ineof;
>       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
>  __err |= ios_base::failbit;
>       if (__ineof)
>  __err |= ios_base::eofbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::failbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::failbit); }
> }
>      else if (!__sbout)
> __err |= ios_base::failbit;
>      if (__err)
> this->setstate(__err);
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    typename basic_istream<_CharT, _Traits>::int_type
>    basic_istream<_CharT, _Traits>::
>    get(void)
>    {
>      const int_type __eof = traits_type::eof();
>      int_type __c = __eof;
>      _M_gcount = 0;
>      ios_base::iostate __err = ios_base::goodbit;
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   try
>     {
>       __c = this->rdbuf()->sbumpc();
>
>       if (!traits_type::eq_int_type(__c, __eof))
>  _M_gcount = 1;
>       else
>  __err |= ios_base::eofbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
> }
>      if (!_M_gcount)
> __err |= ios_base::failbit;
>      if (__err)
> this->setstate(__err);
>      return __c;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    get(char_type& __c)
>    {
>      _M_gcount = 0;
>      ios_base::iostate __err = ios_base::goodbit;
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   try
>     {
>       const int_type __cb = this->rdbuf()->sbumpc();
>
>       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
>  {
>    _M_gcount = 1;
>    __c = traits_type::to_char_type(__cb);
>  }
>       else
>  __err |= ios_base::eofbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
> }
>      if (!_M_gcount)
> __err |= ios_base::failbit;
>      if (__err)
> this->setstate(__err);
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    get(char_type* __s, streamsize __n, char_type __delim)
>    {
>      _M_gcount = 0;
>      ios_base::iostate __err = ios_base::goodbit;
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   try
>     {
>       const int_type __idelim = traits_type::to_int_type(__delim);
>       const int_type __eof = traits_type::eof();
>       __streambuf_type* __sb = this->rdbuf();
>       int_type __c = __sb->sgetc();
>
>       while (_M_gcount + 1 < __n
>       && !traits_type::eq_int_type(__c, __eof)
>       && !traits_type::eq_int_type(__c, __idelim))
>  {
>    *__s++ = traits_type::to_char_type(__c);
>    ++_M_gcount;
>    __c = __sb->snextc();
>  }
>       if (traits_type::eq_int_type(__c, __eof))
>  __err |= ios_base::eofbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
> }
>
>
>      if (__n > 0)
> *__s = char_type();
>      if (!_M_gcount)
> __err |= ios_base::failbit;
>      if (__err)
> this->setstate(__err);
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    get(__streambuf_type& __sb, char_type __delim)
>    {
>      _M_gcount = 0;
>      ios_base::iostate __err = ios_base::goodbit;
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   try
>     {
>       const int_type __idelim = traits_type::to_int_type(__delim);
>       const int_type __eof = traits_type::eof();
>       __streambuf_type* __this_sb = this->rdbuf();
>       int_type __c = __this_sb->sgetc();
>       char_type __c2 = traits_type::to_char_type(__c);
>
>       while (!traits_type::eq_int_type(__c, __eof)
>       && !traits_type::eq_int_type(__c, __idelim)
>       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
>  {
>    ++_M_gcount;
>    __c = __this_sb->snextc();
>    __c2 = traits_type::to_char_type(__c);
>  }
>       if (traits_type::eq_int_type(__c, __eof))
>  __err |= ios_base::eofbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
> }
>      if (!_M_gcount)
> __err |= ios_base::failbit;
>      if (__err)
> this->setstate(__err);
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    getline(char_type* __s, streamsize __n, char_type __delim)
>    {
>      _M_gcount = 0;
>      ios_base::iostate __err = ios_base::goodbit;
>      sentry __cerb(*this, true);
>      if (__cerb)
>        {
>          try
>            {
>              const int_type __idelim = traits_type::to_int_type(__delim);
>              const int_type __eof = traits_type::eof();
>              __streambuf_type* __sb = this->rdbuf();
>              int_type __c = __sb->sgetc();
>
>              while (_M_gcount + 1 < __n
>                     && !traits_type::eq_int_type(__c, __eof)
>                     && !traits_type::eq_int_type(__c, __idelim))
>                {
>                  *__s++ = traits_type::to_char_type(__c);
>                  __c = __sb->snextc();
>                  ++_M_gcount;
>                }
>              if (traits_type::eq_int_type(__c, __eof))
>                __err |= ios_base::eofbit;
>              else
>                {
>                  if (traits_type::eq_int_type(__c, __idelim))
>                    {
>                      __sb->sbumpc();
>                      ++_M_gcount;
>                    }
>                  else
>                    __err |= ios_base::failbit;
>                }
>            }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>          catch(...)
>            { this->_M_setstate(ios_base::badbit); }
>        }
>
>
>      if (__n > 0)
> *__s = char_type();
>      if (!_M_gcount)
>        __err |= ios_base::failbit;
>      if (__err)
>        this->setstate(__err);
>      return *this;
>    }
>
>
>
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    ignore(void)
>    {
>      _M_gcount = 0;
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       const int_type __eof = traits_type::eof();
>       __streambuf_type* __sb = this->rdbuf();
>
>       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
>  __err |= ios_base::eofbit;
>       else
>  _M_gcount = 1;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    ignore(streamsize __n)
>    {
>      _M_gcount = 0;
>      sentry __cerb(*this, true);
>      if (__cerb && __n > 0)
>        {
>          ios_base::iostate __err = ios_base::goodbit;
>          try
>            {
>              const int_type __eof = traits_type::eof();
>              __streambuf_type* __sb = this->rdbuf();
>              int_type __c = __sb->sgetc();
># 513 "/usr/include/c++/4.8.0/bits/istream.tcc" 3
>       bool __large_ignore = false;
>       while (true)
>  {
>    while (_M_gcount < __n
>    && !traits_type::eq_int_type(__c, __eof))
>      {
>        ++_M_gcount;
>        __c = __sb->snextc();
>      }
>    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
>        && !traits_type::eq_int_type(__c, __eof))
>      {
>        _M_gcount =
>   __gnu_cxx::__numeric_traits<streamsize>::__min;
>        __large_ignore = true;
>      }
>    else
>      break;
>  }
>
>       if (__large_ignore)
>  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
>       if (traits_type::eq_int_type(__c, __eof))
>                __err |= ios_base::eofbit;
>            }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>          catch(...)
>            { this->_M_setstate(ios_base::badbit); }
>          if (__err)
>            this->setstate(__err);
>        }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    ignore(streamsize __n, int_type __delim)
>    {
>      _M_gcount = 0;
>      sentry __cerb(*this, true);
>      if (__cerb && __n > 0)
>        {
>          ios_base::iostate __err = ios_base::goodbit;
>          try
>            {
>              const int_type __eof = traits_type::eof();
>              __streambuf_type* __sb = this->rdbuf();
>              int_type __c = __sb->sgetc();
>
>
>       bool __large_ignore = false;
>       while (true)
>  {
>    while (_M_gcount < __n
>    && !traits_type::eq_int_type(__c, __eof)
>    && !traits_type::eq_int_type(__c, __delim))
>      {
>        ++_M_gcount;
>        __c = __sb->snextc();
>      }
>    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
>        && !traits_type::eq_int_type(__c, __eof)
>        && !traits_type::eq_int_type(__c, __delim))
>      {
>        _M_gcount =
>   __gnu_cxx::__numeric_traits<streamsize>::__min;
>        __large_ignore = true;
>      }
>    else
>      break;
>  }
>
>       if (__large_ignore)
>  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
>              if (traits_type::eq_int_type(__c, __eof))
>                __err |= ios_base::eofbit;
>       else if (traits_type::eq_int_type(__c, __delim))
>  {
>    if (_M_gcount
>        < __gnu_cxx::__numeric_traits<streamsize>::__max)
>      ++_M_gcount;
>    __sb->sbumpc();
>  }
>            }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>          catch(...)
>            { this->_M_setstate(ios_base::badbit); }
>          if (__err)
>            this->setstate(__err);
>        }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    typename basic_istream<_CharT, _Traits>::int_type
>    basic_istream<_CharT, _Traits>::
>    peek(void)
>    {
>      int_type __c = traits_type::eof();
>      _M_gcount = 0;
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       __c = this->rdbuf()->sgetc();
>       if (traits_type::eq_int_type(__c, traits_type::eof()))
>  __err |= ios_base::eofbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return __c;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    read(char_type* __s, streamsize __n)
>    {
>      _M_gcount = 0;
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       _M_gcount = this->rdbuf()->sgetn(__s, __n);
>       if (_M_gcount != __n)
>  __err |= (ios_base::eofbit | ios_base::failbit);
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    streamsize
>    basic_istream<_CharT, _Traits>::
>    readsome(char_type* __s, streamsize __n)
>    {
>      _M_gcount = 0;
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>
>       const streamsize __num = this->rdbuf()->in_avail();
>       if (__num > 0)
>  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
>       else if (__num == -1)
>  __err |= ios_base::eofbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return _M_gcount;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    putback(char_type __c)
>    {
>
>
>      _M_gcount = 0;
>
>      this->clear(this->rdstate() & ~ios_base::eofbit);
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       const int_type __eof = traits_type::eof();
>       __streambuf_type* __sb = this->rdbuf();
>       if (!__sb
>    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
>  __err |= ios_base::badbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    unget(void)
>    {
>
>
>      _M_gcount = 0;
>
>      this->clear(this->rdstate() & ~ios_base::eofbit);
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       const int_type __eof = traits_type::eof();
>       __streambuf_type* __sb = this->rdbuf();
>       if (!__sb
>    || traits_type::eq_int_type(__sb->sungetc(), __eof))
>  __err |= ios_base::badbit;
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    int
>    basic_istream<_CharT, _Traits>::
>    sync(void)
>    {
>
>
>      int __ret = -1;
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       __streambuf_type* __sb = this->rdbuf();
>       if (__sb)
>  {
>    if (__sb->pubsync() == -1)
>      __err |= ios_base::badbit;
>    else
>      __ret = 0;
>  }
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return __ret;
>    }
>
>  template<typename _CharT, typename _Traits>
>    typename basic_istream<_CharT, _Traits>::pos_type
>    basic_istream<_CharT, _Traits>::
>    tellg(void)
>    {
>
>
>      pos_type __ret = pos_type(-1);
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   try
>     {
>       if (!this->fail())
>  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
>        ios_base::in);
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
> }
>      return __ret;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    seekg(pos_type __pos)
>    {
>
>
>
>      this->clear(this->rdstate() & ~ios_base::eofbit);
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       if (!this->fail())
>  {
>
>    const pos_type __p = this->rdbuf()->pubseekpos(__pos,
>         ios_base::in);
>
>
>    if (__p == pos_type(off_type(-1)))
>      __err |= ios_base::failbit;
>  }
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return *this;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    basic_istream<_CharT, _Traits>::
>    seekg(off_type __off, ios_base::seekdir __dir)
>    {
>
>
>
>      this->clear(this->rdstate() & ~ios_base::eofbit);
>      sentry __cerb(*this, true);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       if (!this->fail())
>  {
>
>    const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
>         ios_base::in);
>
>
>    if (__p == pos_type(off_type(-1)))
>      __err |= ios_base::failbit;
>  }
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       this->_M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { this->_M_setstate(ios_base::badbit); }
>   if (__err)
>     this->setstate(__err);
> }
>      return *this;
>    }
>
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
>    {
>      typedef basic_istream<_CharT, _Traits> __istream_type;
>      typedef typename __istream_type::int_type __int_type;
>
>      typename __istream_type::sentry __cerb(__in, false);
>      if (__cerb)
> {
>   ios_base::iostate __err = ios_base::goodbit;
>   try
>     {
>       const __int_type __cb = __in.rdbuf()->sbumpc();
>       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
>  __c = _Traits::to_char_type(__cb);
>       else
>  __err |= (ios_base::eofbit | ios_base::failbit);
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       __in._M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { __in._M_setstate(ios_base::badbit); }
>   if (__err)
>     __in.setstate(__err);
> }
>      return __in;
>    }
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
>    {
>      typedef basic_istream<_CharT, _Traits> __istream_type;
>      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
>      typedef typename _Traits::int_type int_type;
>      typedef _CharT char_type;
>      typedef ctype<_CharT> __ctype_type;
>
>      streamsize __extracted = 0;
>      ios_base::iostate __err = ios_base::goodbit;
>      typename __istream_type::sentry __cerb(__in, false);
>      if (__cerb)
> {
>   try
>     {
>
>       streamsize __num = __in.width();
>       if (__num <= 0)
>  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
>       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
>
>       const int_type __eof = _Traits::eof();
>       __streambuf_type* __sb = __in.rdbuf();
>       int_type __c = __sb->sgetc();
>
>       while (__extracted < __num - 1
>       && !_Traits::eq_int_type(__c, __eof)
>       && !__ct.is(ctype_base::space,
>     _Traits::to_char_type(__c)))
>  {
>    *__s++ = _Traits::to_char_type(__c);
>    ++__extracted;
>    __c = __sb->snextc();
>  }
>       if (_Traits::eq_int_type(__c, __eof))
>  __err |= ios_base::eofbit;
>
>
>
>       *__s = char_type();
>       __in.width(0);
>     }
>   catch(__cxxabiv1::__forced_unwind&)
>     {
>       __in._M_setstate(ios_base::badbit);
>       throw;
>     }
>   catch(...)
>     { __in._M_setstate(ios_base::badbit); }
> }
>      if (!__extracted)
> __err |= ios_base::failbit;
>      if (__err)
> __in.setstate(__err);
>      return __in;
>    }
>
>
>  template<typename _CharT, typename _Traits>
>    basic_istream<_CharT, _Traits>&
>    ws(basic_istream<_CharT, _Traits>& __in)
>    {
>      typedef basic_istream<_CharT, _Traits> __istream_type;
>      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
>      typedef typename __istream_type::int_type __int_type;
>      typedef ctype<_CharT> __ctype_type;
>
>      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
>      const __int_type __eof = _Traits::eof();
>      __streambuf_type* __sb = __in.rdbuf();
>      __int_type __c = __sb->sgetc();
>
>      while (!_Traits::eq_int_type(__c, __eof)
>      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
> __c = __sb->snextc();
>
>       if (_Traits::eq_int_type(__c, __eof))
>  __in.setstate(ios_base::eofbit);
>      return __in;
>    }
>
>
>
>
>  extern template class basic_istream<char>;
>  extern template istream& ws(istream&);
>  extern template istream& operator>>(istream&, char&);
>  extern template istream& operator>>(istream&, char*);
>  extern template istream& operator>>(istream&, unsigned char&);
>  extern template istream& operator>>(istream&, signed char&);
>  extern template istream& operator>>(istream&, unsigned char*);
>  extern template istream& operator>>(istream&, signed char*);
>
>  extern template istream& istream::_M_extract(unsigned short&);
>  extern template istream& istream::_M_extract(unsigned int&);
>  extern template istream& istream::_M_extract(long&);
>  extern template istream& istream::_M_extract(unsigned long&);
>  extern template istream& istream::_M_extract(bool&);
>
>  extern template istream& istream::_M_extract(long long&);
>  extern template istream& istream::_M_extract(unsigned long long&);
>
>  extern template istream& istream::_M_extract(float&);
>  extern template istream& istream::_M_extract(double&);
>  extern template istream& istream::_M_extract(long double&);
>  extern template istream& istream::_M_extract(void*&);
>
>  extern template class basic_iostream<char>;
>
>
>  extern template class basic_istream<wchar_t>;
>  extern template wistream& ws(wistream&);
>  extern template wistream& operator>>(wistream&, wchar_t&);
>  extern template wistream& operator>>(wistream&, wchar_t*);
>
>  extern template wistream& wistream::_M_extract(unsigned short&);
>  extern template wistream& wistream::_M_extract(unsigned int&);
>  extern template wistream& wistream::_M_extract(long&);
>  extern template wistream& wistream::_M_extract(unsigned long&);
>  extern template wistream& wistream::_M_extract(bool&);
>
>  extern template wistream& wistream::_M_extract(long long&);
>  extern template wistream& wistream::_M_extract(unsigned long long&);
>
>  extern template wistream& wistream::_M_extract(float&);
>  extern template wistream& wistream::_M_extract(double&);
>  extern template wistream& wistream::_M_extract(long double&);
>  extern template wistream& wistream::_M_extract(void*&);
>
>  extern template class basic_iostream<wchar_t>;
>
>
>
>
>}
># 880 "/usr/include/c++/4.8.0/istream" 2 3
># 41 "/usr/include/c++/4.8.0/iostream" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 60 "/usr/include/c++/4.8.0/iostream" 3
>  extern istream cin;
>  extern ostream cout;
>  extern ostream cerr;
>  extern ostream clog;
>
>
>  extern wistream wcin;
>  extern wostream wcout;
>  extern wostream wcerr;
>  extern wostream wclog;
>
>
>
>
>  static ios_base::Init __ioinit;
>
>
>}
># 11 "../src/CoinError.hpp" 2
># 1 "/usr/include/c++/4.8.0/cassert" 1 3
># 41 "/usr/include/c++/4.8.0/cassert" 3
>       
># 42 "/usr/include/c++/4.8.0/cassert" 3
>
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
>      unsigned int __line, const char *__function)
>     throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
>      unsigned int __line, const char *__function)
>     throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
>     throw () __attribute__ ((__noreturn__));
>
>
>}
># 43 "/usr/include/c++/4.8.0/cassert" 2 3
># 12 "../src/CoinError.hpp" 2
># 1 "/usr/include/c++/4.8.0/cstring" 1 3
># 39 "/usr/include/c++/4.8.0/cstring" 3
>       
># 40 "/usr/include/c++/4.8.0/cstring" 3
>
>
># 1 "/usr/include/string.h" 1 3 4
># 27 "/usr/include/string.h" 3 4
>extern "C" {
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.0/include/stddef.h" 1 3 4
># 33 "/usr/include/string.h" 2 3 4
>
>
>
>
>
>
>
>
>
>extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
>       size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, const void *__src, size_t __n)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
>        int __c, size_t __n)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (const void *__s1, const void *__s2, size_t __n)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern "C++"
>{
>extern void *memchr (void *__s, int __c, size_t __n)
>      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const void *memchr (const void *__s, int __c, size_t __n)
>      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void *
>memchr (void *__s, int __c, size_t __n) throw ()
>{
>  return __builtin_memchr (__s, __c, __n);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void *
>memchr (const void *__s, int __c, size_t __n) throw ()
>{
>  return __builtin_memchr (__s, __c, __n);
>}
>
>}
>
>
>
>
>
>
>
>
>
>
>extern "C++" void *rawmemchr (void *__s, int __c)
>     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern "C++" const void *rawmemchr (const void *__s, int __c)
>     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern "C++" void *memrchr (void *__s, int __c, size_t __n)
>      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
>      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>
>
>extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
>        const char *__restrict __src, size_t __n)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, const char *__restrict __src)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, const char *__restrict __src,
>        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (const char *__s1, const char *__s2)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (const char *__s1, const char *__s2, size_t __n)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (const char *__s1, const char *__s2)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
>         const char *__restrict __src, size_t __n)
>     throw () __attribute__ ((__nonnull__ (2)));
>
># 162 "/usr/include/string.h" 3 4
>extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
>    __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>
>extern char *strdup (const char *__s)
>     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strndup (const char *__string, size_t __n)
>     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 207 "/usr/include/string.h" 3 4
>
>
>
>extern "C++"
>{
>extern char *strchr (char *__s, int __c)
>     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *strchr (const char *__s, int __c)
>     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strchr (char *__s, int __c) throw ()
>{
>  return __builtin_strchr (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strchr (const char *__s, int __c) throw ()
>{
>  return __builtin_strchr (__s, __c);
>}
>
>}
>
>
>
>
>
>
>extern "C++"
>{
>extern char *strrchr (char *__s, int __c)
>     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *strrchr (const char *__s, int __c)
>     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strrchr (char *__s, int __c) throw ()
>{
>  return __builtin_strrchr (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strrchr (const char *__s, int __c) throw ()
>{
>  return __builtin_strrchr (__s, __c);
>}
>
>}
>
>
>
>
>
>
>
>
>
>
>extern "C++" char *strchrnul (char *__s, int __c)
>     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern "C++" const char *strchrnul (const char *__s, int __c)
>     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>
>
>extern size_t strcspn (const char *__s, const char *__reject)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (const char *__s, const char *__accept)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern "C++"
>{
>extern char *strpbrk (char *__s, const char *__accept)
>     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>extern const char *strpbrk (const char *__s, const char *__accept)
>     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strpbrk (char *__s, const char *__accept) throw ()
>{
>  return __builtin_strpbrk (__s, __accept);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strpbrk (const char *__s, const char *__accept) throw ()
>{
>  return __builtin_strpbrk (__s, __accept);
>}
>
>}
>
>
>
>
>
>
>extern "C++"
>{
>extern char *strstr (char *__haystack, const char *__needle)
>     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>extern const char *strstr (const char *__haystack, const char *__needle)
>     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strstr (char *__haystack, const char *__needle) throw ()
>{
>  return __builtin_strstr (__haystack, __needle);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strstr (const char *__haystack, const char *__needle) throw ()
>{
>  return __builtin_strstr (__haystack, __needle);
>}
>
>}
>
>
>
>
>
>
>
>extern char *strtok (char *__restrict __s, const char *__restrict __delim)
>     throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern char *__strtok_r (char *__restrict __s,
>    const char *__restrict __delim,
>    char **__restrict __save_ptr)
>     throw () __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
>         char **__restrict __save_ptr)
>     throw () __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>
>extern "C++" char *strcasestr (char *__haystack, const char *__needle)
>     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>extern "C++" const char *strcasestr (const char *__haystack,
>         const char *__needle)
>     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 378 "/usr/include/string.h" 3 4
>extern void *memmem (const void *__haystack, size_t __haystacklen,
>       const void *__needle, size_t __needlelen)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern void *__mempcpy (void *__restrict __dest,
>   const void *__restrict __src, size_t __n)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>extern void *mempcpy (void *__restrict __dest,
>        const void *__restrict __src, size_t __n)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern size_t strlen (const char *__s)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strnlen (const char *__string, size_t __maxlen)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strerror (int __errnum) throw ();
>
># 434 "/usr/include/string.h" 3 4
>extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
>     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *strerror_l (int __errnum, __locale_t __l) throw ();
>
>
>
>
>
>extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void bcopy (const void *__src, void *__dest, size_t __n)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int bcmp (const void *__s1, const void *__s2, size_t __n)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern "C++"
>{
>extern char *index (char *__s, int __c)
>     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *index (const char *__s, int __c)
>     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>index (char *__s, int __c) throw ()
>{
>  return __builtin_index (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>index (const char *__s, int __c) throw ()
>{
>  return __builtin_index (__s, __c);
>}
>
>}
>
>
>
>
>
>
>
>extern "C++"
>{
>extern char *rindex (char *__s, int __c)
>     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *rindex (const char *__s, int __c)
>     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>rindex (char *__s, int __c) throw ()
>{
>  return __builtin_rindex (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>rindex (const char *__s, int __c) throw ()
>{
>  return __builtin_rindex (__s, __c);
>}
>
>}
>
>
>
>
>
>
>
>extern int ffs (int __i) throw () __attribute__ ((__const__));
>
>
>
>
>extern int ffsl (long int __l) throw () __attribute__ ((__const__));
>
>__extension__ extern int ffsll (long long int __ll)
>     throw () __attribute__ ((__const__));
>
>
>
>
>extern int strcasecmp (const char *__s1, const char *__s2)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int strcasecmp_l (const char *__s1, const char *__s2,
>    __locale_t __loc)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern int strncasecmp_l (const char *__s1, const char *__s2,
>     size_t __n, __locale_t __loc)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
>
>
>
>
>
>extern char *strsep (char **__restrict __stringp,
>       const char *__restrict __delim)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern char *strsignal (int __sig) throw ();
>
>
>extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *__stpncpy (char *__restrict __dest,
>   const char *__restrict __src, size_t __n)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpncpy (char *__restrict __dest,
>        const char *__restrict __src, size_t __n)
>     throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int strverscmp (const char *__s1, const char *__s2)
>     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern "C++" char *basename (char *__filename)
>     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
>extern "C++" const char *basename (const char *__filename)
>     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
># 638 "/usr/include/string.h" 3 4
># 1 "/usr/include/bits/string3.h" 1 3 4
># 22 "/usr/include/bits/string3.h" 3 4
>extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("memset used with constant zero length parameter; this could be due to transposed parameters")))
>                                                                                                   ;
># 47 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__leaf__)) memcpy (void *__restrict __dest, const void *__restrict __src, size_t __len) throw ()
>
>{
>  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__leaf__)) memmove (void *__dest, const void *__src, size_t __len) throw ()
>{
>  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__leaf__)) mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __len) throw ()
>
>{
>  return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
># 75 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__leaf__)) memset (void *__dest, int __ch, size_t __len) throw ()
>{
>  if (__builtin_constant_p (__len) && __len == 0
>      && (!__builtin_constant_p (__ch) || __ch != 0))
>    {
>      __warn_memset_zero_len ();
>      return __dest;
>    }
>  return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void
>__attribute__ ((__leaf__)) bcopy (const void *__src, void *__dest, size_t __len) throw ()
>{
>  (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void
>__attribute__ ((__leaf__)) bzero (void *__dest, size_t __len) throw ()
>{
>  (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__leaf__)) strcpy (char *__restrict __dest, const char *__restrict __src) throw ()
>{
>  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__leaf__)) stpcpy (char *__restrict __dest, const char *__restrict __src) throw ()
>{
>  return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__leaf__)) strncpy (char *__restrict __dest, const char *__restrict __src, size_t __len) throw ()
>
>{
>  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern char *__stpncpy_chk (char *__dest, const char *__src, size_t __n,
>       size_t __destlen) throw ();
>extern char *__stpncpy_alias (char *__dest, const char *__src, size_t __n) throw () __asm__ ("" "stpncpy")
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__leaf__)) stpncpy (char *__dest, const char *__src, size_t __n) throw ()
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
>      && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
>    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
>  return __stpncpy_alias (__dest, __src, __n);
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__leaf__)) strcat (char *__restrict __dest, const char *__restrict __src) throw ()
>{
>  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__leaf__)) strncat (char *__restrict __dest, const char *__restrict __src, size_t __len) throw ()
>
>{
>  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
>}
># 639 "/usr/include/string.h" 2 3 4
>
>
>
>}
># 43 "/usr/include/c++/4.8.0/cstring" 2 3
># 71 "/usr/include/c++/4.8.0/cstring" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>  using ::memchr;
>  using ::memcmp;
>  using ::memcpy;
>  using ::memmove;
>  using ::memset;
>  using ::strcat;
>  using ::strcmp;
>  using ::strcoll;
>  using ::strcpy;
>  using ::strcspn;
>  using ::strerror;
>  using ::strlen;
>  using ::strncat;
>  using ::strncmp;
>  using ::strncpy;
>  using ::strspn;
>  using ::strtok;
>  using ::strxfrm;
>  using ::strchr;
>  using ::strpbrk;
>  using ::strrchr;
>  using ::strstr;
># 120 "/usr/include/c++/4.8.0/cstring" 3
>
>}
># 13 "../src/CoinError.hpp" 2
>
># 1 "../src/CoinUtilsConfig.h" 1
># 30 "../src/CoinUtilsConfig.h"
># 1 "../src/config.h" 1
># 31 "../src/CoinUtilsConfig.h" 2
># 15 "../src/CoinError.hpp" 2
>
>
>
>
>void WindowsErrorPopupBlocker();
># 42 "../src/CoinError.hpp"
>class CoinError {
>    friend void CoinErrorUnitTest();
>
>private:
>    CoinError()
>      :
>      message_(),
>      method_(),
>      class_(),
>      file_(),
>      lineNumber_()
>    {
>
>    }
>
>public:
>
>
>
>
>
>
>
>    inline const std::string & message() const
>    { return message_; }
>
>    inline const std::string & methodName() const
>    { return method_; }
>
>    inline const std::string & className() const
>    { return class_; }
>
>    inline const std::string & fileName() const
>    { return file_; }
>
>    inline int lineNumber() const
>    { return lineNumber_; }
>
>    inline void print(bool doPrint = true) const
>    {
>      if (! doPrint)
>        return;
>      if (lineNumber_<0) {
>        std::cout<<message_<<" in "<<class_<<"::"<<method_<<std::endl;
>      } else {
>        std::cout<<file_<<":"<<lineNumber_<<" method "<<method_
>                 <<" : assertion \'"<<message_<<"\' failed."<<std::endl;
>        if(class_!="")
>          std::cout<<"Possible reason: "<<class_<<std::endl;
>      }
>    }
>
>
>
>
>
>
>    CoinError (
>      std::string message__,
>      std::string methodName__,
>      std::string className__,
>      std::string fileName_ = std::string(),
>      int line = -1)
>      :
>      message_(message__),
>      method_(methodName__),
>      class_(className__),
>      file_(fileName_),
>      lineNumber_(line)
>    {
>      print(printErrors_);
>    }
>
>
>    CoinError (const CoinError & source)
>      :
>      message_(source.message_),
>      method_(source.method_),
>      class_(source.class_),
>      file_(source.file_),
>      lineNumber_(source.lineNumber_)
>    {
>
>    }
>
>
>    CoinError & operator=(const CoinError& rhs)
>    {
>      if (this != &rhs) {
> message_=rhs.message_;
> method_=rhs.method_;
> class_=rhs.class_;
> file_=rhs.file_;
> lineNumber_ = rhs.lineNumber_;
>      }
>      return *this;
>    }
>
>
>    virtual ~CoinError ()
>    {
>
>    }
>
>
>private:
>
>
>
>
>    std::string message_;
>
>    std::string method_;
>
>    std::string class_;
>
>    std::string file_;
>
>    int lineNumber_;
>
>
>public:
>
>  static bool printErrors_;
>};
># 250 "../src/CoinError.hpp"
>void
>CoinErrorUnitTest();
># 13 "../src/CoinPackedVectorBase.hpp" 2
>
>class CoinPackedVector;
># 23 "../src/CoinPackedVectorBase.hpp"
>class CoinPackedVectorBase {
>
>public:
>
>
>
>   virtual int getNumElements() const = 0;
>
>   virtual const int * getIndices() const = 0;
>
>   virtual const double * getElements() const = 0;
># 51 "../src/CoinPackedVectorBase.hpp"
>   void setTestForDuplicateIndex(bool test) const;
># 60 "../src/CoinPackedVectorBase.hpp"
>   void setTestForDuplicateIndexWhenTrue(bool test) const;
>
>
>   bool testForDuplicateIndex() const { return testForDuplicateIndex_; }
>
>   inline void setTestsOff() const
>   { testForDuplicateIndex_=false; testedDuplicateIndex_=false;}
># 76 "../src/CoinPackedVectorBase.hpp"
>   double * denseVector(int denseSize) const;
>
>
>
>
>
>
>
>   double operator[](int i) const;
>
>
>
>
>
>   int getMaxIndex() const;
>
>   int getMinIndex() const;
>
>
>   void duplicateIndex(const char* methodName = __null,
>         const char * className = __null) const;
>
>
>
>   bool isExistingIndex(int i) const;
>
>
>
>   int findIndex(int i) const;
>
>
>
>
>
>
>
>   bool operator==(const CoinPackedVectorBase & rhs) const;
>
>   bool operator!=(const CoinPackedVectorBase & rhs) const;
># 130 "../src/CoinPackedVectorBase.hpp"
>   int compare(const CoinPackedVectorBase& rhs) const;
># 139 "../src/CoinPackedVectorBase.hpp"
>   template <class FloatEqual> bool
>   isEquivalent(const CoinPackedVectorBase& rhs, const FloatEqual& eq) const
>   {
>      if (getNumElements() != rhs.getNumElements())
>  return false;
>
>      duplicateIndex("equivalent", "CoinPackedVector");
>      rhs.duplicateIndex("equivalent", "CoinPackedVector");
>
>      std::map<int,double> mv;
>      const int * inds = getIndices();
>      const double * elems = getElements();
>      int i;
>      for ( i = getNumElements() - 1; i >= 0; --i) {
>  mv.insert(std::make_pair(inds[i], elems[i]));
>      }
>
>      std::map<int,double> mvRhs;
>      inds = rhs.getIndices();
>      elems = rhs.getElements();
>      for ( i = getNumElements() - 1; i >= 0; --i) {
>  mvRhs.insert(std::make_pair(inds[i], elems[i]));
>      }
>
>      std::map<int,double>::const_iterator mvI = mv.begin();
>      std::map<int,double>::const_iterator mvIlast = mv.end();
>      std::map<int,double>::const_iterator mvIrhs = mvRhs.begin();
>      while (mvI != mvIlast) {
>  if (mvI->first != mvIrhs->first || ! eq(mvI->second, mvIrhs->second))
>     return false;
>  ++mvI;
>  ++mvIrhs;
>      }
>      return true;
>   }
>
>   bool isEquivalent(const CoinPackedVectorBase& rhs) const;
>
>
>
>
>
>
>   double dotProduct(const double* dense) const;
>
>
>   double oneNorm() const;
>
>
>   double normSquare() const;
>
>
>   double twoNorm() const;
>
>
>   double infNorm() const;
>
>
>   double sum() const;
>
>
>protected:
>
>
>
>
>
>
>   CoinPackedVectorBase();
>
>public:
>
>   virtual ~CoinPackedVectorBase();
>
>
>private:
># 223 "../src/CoinPackedVectorBase.hpp"
>   CoinPackedVectorBase(const CoinPackedVectorBase&);
>
>
>   CoinPackedVectorBase& operator=(const CoinPackedVectorBase&);
>
>
>protected:
>
>
>
>
>   void findMaxMinIndices() const;
>
>
>   std::set<int> * indexSet(const char* methodName = __null,
>       const char * className = __null) const;
>
>
>   void clearIndexSet() const;
>   void clearBase() const;
>   void copyMaxMinIndex(const CoinPackedVectorBase & x) const {
>      maxIndex_ = x.maxIndex_;
>      minIndex_ = x.minIndex_;
>   }
>
>
>private:
>
>
>
>   mutable int maxIndex_;
>
>   mutable int minIndex_;
>
>
>
>   mutable std::set<int> * indexSetPtr_;
>
>
>   mutable bool testForDuplicateIndex_;
>
>
>   mutable bool testedDuplicateIndex_;
>
>};
># 13 "../src/CoinPackedVector.hpp" 2
># 1 "../src/CoinSort.hpp" 1
># 9 "../src/CoinSort.hpp"
># 1 "/usr/include/c++/4.8.0/functional" 1 3
># 46 "/usr/include/c++/4.8.0/functional" 3
>       
># 47 "/usr/include/c++/4.8.0/functional" 3
># 10 "../src/CoinSort.hpp" 2
>
>
># 1 "../src/CoinDistance.hpp" 1
># 9 "../src/CoinDistance.hpp"
># 1 "/usr/include/c++/4.8.0/iterator" 1 3
># 58 "/usr/include/c++/4.8.0/iterator" 3
>       
># 59 "/usr/include/c++/4.8.0/iterator" 3
>
>
>
>
>
>
>
># 1 "/usr/include/c++/4.8.0/bits/stream_iterator.h" 1 3
># 33 "/usr/include/c++/4.8.0/bits/stream_iterator.h" 3
>       
># 34 "/usr/include/c++/4.8.0/bits/stream_iterator.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
>  template<typename _Tp, typename _CharT = char,
>           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
>    class istream_iterator
>    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
>    {
>    public:
>      typedef _CharT char_type;
>      typedef _Traits traits_type;
>      typedef basic_istream<_CharT, _Traits> istream_type;
>
>    private:
>      istream_type* _M_stream;
>      _Tp _M_value;
>      bool _M_ok;
>
>    public:
>
>      istream_iterator()
>      : _M_stream(0), _M_value(), _M_ok(false) {}
>
>
>      istream_iterator(istream_type& __s)
>      : _M_stream(&__s)
>      { _M_read(); }
>
>      istream_iterator(const istream_iterator& __obj)
>      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
>        _M_ok(__obj._M_ok)
>      { }
>
>      const _Tp&
>      operator*() const
>      {
>
>
>                        ;
> return _M_value;
>      }
>
>      const _Tp*
>      operator->() const { return &(operator*()); }
>
>      istream_iterator&
>      operator++()
>      {
>
>
>                        ;
> _M_read();
> return *this;
>      }
>
>      istream_iterator
>      operator++(int)
>      {
>
>
>                        ;
> istream_iterator __tmp = *this;
> _M_read();
> return __tmp;
>      }
>
>      bool
>      _M_equal(const istream_iterator& __x) const
>      { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
>
>    private:
>      void
>      _M_read()
>      {
> _M_ok = (_M_stream && *_M_stream) ? true : false;
> if (_M_ok)
>   {
>     *_M_stream >> _M_value;
>     _M_ok = *_M_stream ? true : false;
>   }
>      }
>    };
>
>
>  template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
>    inline bool
>    operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
>        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
>    { return __x._M_equal(__y); }
>
>
>  template <class _Tp, class _CharT, class _Traits, class _Dist>
>    inline bool
>    operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
>        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
>    { return !__x._M_equal(__y); }
># 152 "/usr/include/c++/4.8.0/bits/stream_iterator.h" 3
>  template<typename _Tp, typename _CharT = char,
>           typename _Traits = char_traits<_CharT> >
>    class ostream_iterator
>    : public iterator<output_iterator_tag, void, void, void, void>
>    {
>    public:
>
>
>      typedef _CharT char_type;
>      typedef _Traits traits_type;
>      typedef basic_ostream<_CharT, _Traits> ostream_type;
>
>
>    private:
>      ostream_type* _M_stream;
>      const _CharT* _M_string;
>
>    public:
>
>      ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
># 183 "/usr/include/c++/4.8.0/bits/stream_iterator.h" 3
>      ostream_iterator(ostream_type& __s, const _CharT* __c)
>      : _M_stream(&__s), _M_string(__c) { }
>
>
>      ostream_iterator(const ostream_iterator& __obj)
>      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
>
>
>
>      ostream_iterator&
>      operator=(const _Tp& __value)
>      {
>
>
>                        ;
> *_M_stream << __value;
> if (_M_string) *_M_stream << _M_string;
> return *this;
>      }
>
>      ostream_iterator&
>      operator*()
>      { return *this; }
>
>      ostream_iterator&
>      operator++()
>      { return *this; }
>
>      ostream_iterator&
>      operator++(int)
>      { return *this; }
>    };
>
>
>
>
>}
># 67 "/usr/include/c++/4.8.0/iterator" 2 3
># 10 "../src/CoinDistance.hpp" 2
># 23 "../src/CoinDistance.hpp"
>template <class ForwardIterator, class Distance>
>void coinDistance(ForwardIterator first, ForwardIterator last,
>    Distance& n)
>{
>
>
>
>
>   n = std::distance(first,last);
>
>}
>
>template <class ForwardIterator>
>size_t coinDistance(ForwardIterator first, ForwardIterator last)
>{
>   size_t retVal;
>
>
>
>
>   retVal = std::distance(first,last);
>
>  return retVal;
>}
># 13 "../src/CoinSort.hpp" 2
># 29 "../src/CoinSort.hpp"
>template <class S, class T>
>struct CoinPair {
>public:
>
>  S first;
>
>  T second;
>public:
>
>  CoinPair(const S& s, const T& t) : first(s), second(t) {}
>};
>
>
>
>
>
>
>
>template < class S, class T>
>class CoinFirstLess_2 {
>public:
>
>  inline bool operator()(const CoinPair<S,T>& t1,
>    const CoinPair<S,T>& t2) const
>  { return t1.first < t2.first; }
>};
>
>
>
>template < class S, class T>
>class CoinFirstGreater_2 {
>public:
>
>  inline bool operator()(const CoinPair<S,T>& t1,
>    const CoinPair<S,T>& t2) const
>  { return t1.first > t2.first; }
>};
>
>
>
>template < class S, class T>
>class CoinFirstAbsLess_2 {
>public:
>
>  inline bool operator()(const CoinPair<S,T>& t1,
>    const CoinPair<S,T>& t2) const
>  {
>    const T t1Abs = t1.first < static_cast<T>(0) ? -t1.first : t1.first;
>    const T t2Abs = t2.first < static_cast<T>(0) ? -t2.first : t2.first;
>    return t1Abs < t2Abs;
>  }
>};
>
>
>
>template < class S, class T>
>class CoinFirstAbsGreater_2 {
>public:
>
>  inline bool operator()(CoinPair<S,T> t1, CoinPair<S,T> t2) const
>  {
>    const T t1Abs = t1.first < static_cast<T>(0) ? -t1.first : t1.first;
>    const T t2Abs = t2.first < static_cast<T>(0) ? -t2.first : t2.first;
>    return t1Abs > t2Abs;
>  }
>};
>
>
>
>
>
>
>template < class S, class T, class V>
>class CoinExternalVectorFirstLess_2 {
>private:
>  CoinExternalVectorFirstLess_2();
>private:
>  const V* vec_;
>public:
>  inline bool operator()(const CoinPair<S,T>& t1,
>    const CoinPair<S,T>& t2) const
>  { return vec_[t1.first] < vec_[t2.first]; }
>  CoinExternalVectorFirstLess_2(const V* v) : vec_(v) {}
>};
>
>
>
>
>
>
>template < class S, class T, class V>
>class CoinExternalVectorFirstGreater_2 {
>private:
>  CoinExternalVectorFirstGreater_2();
>private:
>  const V* vec_;
>public:
>  inline bool operator()(const CoinPair<S,T>& t1,
>    const CoinPair<S,T>& t2) const
>  { return vec_[t1.first] > vec_[t2.first]; }
>  CoinExternalVectorFirstGreater_2(const V* v) : vec_(v) {}
>};
># 187 "../src/CoinSort.hpp"
>template <class S, class T, class CoinCompare2> void
>CoinSort_2(S* sfirst, S* slast, T* tfirst, const CoinCompare2& pc)
>{
>  const size_t len = coinDistance(sfirst, slast);
>  if (len <= 1)
>    return;
>
>  typedef CoinPair<S,T> ST_pair;
>  ST_pair* x = static_cast<ST_pair*>(::operator new(len * sizeof(ST_pair)));
>
>
>
>
>
>
>  size_t i = 0;
>  S* scurrent = sfirst;
>  T* tcurrent = tfirst;
>  while (scurrent != slast) {
>    new (x+i++) ST_pair(*scurrent++, *tcurrent++);
>  }
>
>  std::sort(x, x + len, pc);
>
>  scurrent = sfirst;
>  tcurrent = tfirst;
>  for (i = 0; i < len; ++i) {
>    *scurrent++ = x[i].first;
>    *tcurrent++ = x[i].second;
>  }
>
>  ::operator delete(x);
>}
>template <class S, class T> void
>
>CoinSort_2Std(S* sfirst, S* slast, T* tfirst)
>{
>  CoinSort_2(sfirst, slast, tfirst, CoinFirstLess_2<S,T>());
>}
>
>
>template <class S, class T> void
>CoinSort_2(S* sfirst, S* slast, T* tfirst)
>{
>  CoinSort_2(sfirst, slast, tfirst, CoinFirstLess_2<S,T>());
>}
># 359 "../src/CoinSort.hpp"
>template <class S, class T, class U>
>class CoinTriple {
>public:
>
>  S first;
>
>  T second;
>
>  U third;
>public:
>
>  CoinTriple(const S& s, const T& t, const U& u):first(s),second(t),third(u) {}
>};
>
>
>
>
>
>
>template < class S, class T, class U >
>class CoinFirstLess_3 {
>public:
>
>  inline bool operator()(const CoinTriple<S,T,U>& t1,
>    const CoinTriple<S,T,U>& t2) const
>  { return t1.first < t2.first; }
>};
>
>
>
>template < class S, class T, class U >
>class CoinFirstGreater_3 {
>public:
>
>  inline bool operator()(const CoinTriple<S,T,U>& t1,
>    const CoinTriple<S,T,U>& t2) const
>  { return t1.first>t2.first; }
>};
>
>
>
>template < class S, class T, class U >
>class CoinFirstAbsLess_3 {
>public:
>
>  inline bool operator()(const CoinTriple<S,T,U>& t1,
>    const CoinTriple<S,T,U>& t2) const
>  {
>    const T t1Abs = t1.first < static_cast<T>(0) ? -t1.first : t1.first;
>    const T t2Abs = t2.first < static_cast<T>(0) ? -t2.first : t2.first;
>    return t1Abs < t2Abs;
>  }
>};
>
>
>
>template < class S, class T, class U >
>class CoinFirstAbsGreater_3 {
>public:
>
>  inline bool operator()(const CoinTriple<S,T,U>& t1,
>    const CoinTriple<S,T,U>& t2) const
>  {
>    const T t1Abs = t1.first < static_cast<T>(0) ? -t1.first : t1.first;
>    const T t2Abs = t2.first < static_cast<T>(0) ? -t2.first : t2.first;
>    return t1Abs > t2Abs;
>  }
>};
>
>
>
>
>
>
>template < class S, class T, class U, class V>
>class CoinExternalVectorFirstLess_3 {
>private:
>  CoinExternalVectorFirstLess_3();
>private:
>  const V* vec_;
>public:
>  inline bool operator()(const CoinTriple<S,T,U>& t1,
>    const CoinTriple<S,T,U>& t2) const
>  { return vec_[t1.first] < vec_[t2.first]; }
>  CoinExternalVectorFirstLess_3(const V* v) : vec_(v) {}
>};
>
>
>
>
>
>
>template < class S, class T, class U, class V>
>class CoinExternalVectorFirstGreater_3 {
>private:
>  CoinExternalVectorFirstGreater_3();
>private:
>  const V* vec_;
>public:
>  inline bool operator()(const CoinTriple<S,T,U>& t1,
>    const CoinTriple<S,T,U>& t2) const
>  { return vec_[t1.first] > vec_[t2.first]; }
>  CoinExternalVectorFirstGreater_3(const V* v) : vec_(v) {}
>};
># 471 "../src/CoinSort.hpp"
>typedef CoinExternalVectorFirstLess_3<int, int, double, double>
>CoinIncrSolutionOrdered;
>
>typedef CoinExternalVectorFirstGreater_3<int, int, double, double>
>CoinDecrSolutionOrdered;
># 536 "../src/CoinSort.hpp"
>template <class S, class T, class U, class CoinCompare3> void
>CoinSort_3(S* sfirst, S* slast, T* tfirst, U* ufirst, const CoinCompare3& tc)
>{
>  const size_t len = coinDistance(sfirst,slast);
>  if (len <= 1)
>    return;
>
>  typedef CoinTriple<S,T,U> STU_triple;
>  STU_triple* x =
>    static_cast<STU_triple*>(::operator new(len * sizeof(STU_triple)));
>
>  size_t i = 0;
>  S* scurrent = sfirst;
>  T* tcurrent = tfirst;
>  U* ucurrent = ufirst;
>  while (scurrent != slast) {
>    new (x+i++) STU_triple(*scurrent++, *tcurrent++, *ucurrent++);
>  }
>
>  std::sort(x, x+len, tc);
>
>  scurrent = sfirst;
>  tcurrent = tfirst;
>  ucurrent = ufirst;
>  for (i = 0; i < len; ++i) {
>    *scurrent++ = x[i].first;
>    *tcurrent++ = x[i].second;
>    *ucurrent++ = x[i].third;
>  }
>
>  ::operator delete(x);
>}
>
>template <class S, class T, class U> void
>CoinSort_3(S* sfirst, S* slast, T* tfirst, U* ufirst)
>{
>  CoinSort_3(sfirst, slast, tfirst, ufirst, CoinFirstLess_3<S,T,U>());
>}
># 14 "../src/CoinPackedVector.hpp" 2
># 123 "../src/CoinPackedVector.hpp"
>class CoinPackedVector : public CoinPackedVectorBase {
>   friend void CoinPackedVectorUnitTest();
>
>public:
>
>
>
>   virtual int getNumElements() const { return nElements_; }
>
>   virtual const int * getIndices() const { return indices_; }
>
>   virtual const double * getElements() const { return elements_; }
>
>   int * getIndices() { return indices_; }
>
>   double * getElements() { return elements_; }
>
>
>
>   const int * getOriginalPosition() const { return origIndices_; }
># 151 "../src/CoinPackedVector.hpp"
>   void clear();
>
>
>
>
>   CoinPackedVector & operator=(const CoinPackedVector &);
>
>
>
>
>   CoinPackedVector & operator=(const CoinPackedVectorBase & rhs);
>
>
>
>
>
>
>
>   void assignVector(int size, int*& inds, double*& elems,
>       bool testForDuplicateIndex = true);
>
>
>
>
>
>
>   void setVector(int size, const int * inds, const double * elems,
>    bool testForDuplicateIndex = true);
>
>
>   void setConstant(int size, const int * inds, double elems,
>      bool testForDuplicateIndex = true);
>
>
>   void setFull(int size, const double * elems,
>  bool testForDuplicateIndex = true);
>
>
>
>   void setFullNonZero(int size, const double * elems,
>  bool testForDuplicateIndex = true);
>
>
>
>
>   void setElement(int index, double element);
>
>
>   void insert(int index, double element);
>
>   void append(const CoinPackedVectorBase & caboose);
>
>
>   void swap(int i, int j);
>
>
>
>   void truncate(int newSize);
>
>
>
>
>
>   void operator+=(double value);
>
>   void operator-=(double value);
>
>   void operator*=(double value);
>
>   void operator/=(double value);
># 232 "../src/CoinPackedVector.hpp"
>   template <class CoinCompare3>
>   void sort(const CoinCompare3 & tc)
>   { CoinSort_3(indices_, indices_ + nElements_, origIndices_, elements_,
>  tc); }
>
>   void sortIncrIndex()
>   { CoinSort_3(indices_, indices_ + nElements_, origIndices_, elements_,
>  CoinFirstLess_3<int, int, double>()); }
>
>   void sortDecrIndex()
>   { CoinSort_3(indices_, indices_ + nElements_, origIndices_, elements_,
>  CoinFirstGreater_3<int, int, double>()); }
>
>   void sortIncrElement()
>   { CoinSort_3(elements_, elements_ + nElements_, origIndices_, indices_,
>  CoinFirstLess_3<double, int, int>()); }
>
>   void sortDecrElement()
>   { CoinSort_3(elements_, elements_ + nElements_, origIndices_, indices_,
>  CoinFirstGreater_3<double, int, int>()); }
>
>
>
>
>
>
>   void sortOriginalOrder();
># 267 "../src/CoinPackedVector.hpp"
>   void reserve(int n);
>
>
>
>   int capacity() const { return capacity_; }
>
>
>
>
>   CoinPackedVector(bool testForDuplicateIndex = true);
>
>
>
>
>   CoinPackedVector(int size, const int * inds, const double * elems,
>     bool testForDuplicateIndex = true);
>
>
>
>
>
>   CoinPackedVector(int capacity, int size, int *&inds, double *&elems,
>      bool testForDuplicateIndex = true);
>
>   CoinPackedVector(int size, const int * inds, double element,
>     bool testForDuplicateIndex = true);
>
>
>   CoinPackedVector(int size, const double * elements,
>     bool testForDuplicateIndex = true);
>
>   CoinPackedVector(const CoinPackedVector &);
>
>   CoinPackedVector(const CoinPackedVectorBase & rhs);
>
>   virtual ~CoinPackedVector ();
>
>
>private:
>
>
>
>   void gutsOfSetVector(int size,
>   const int * inds, const double * elems,
>   bool testForDuplicateIndex,
>   const char * method);
>
>   void gutsOfSetConstant(int size,
>     const int * inds, double value,
>     bool testForDuplicateIndex,
>     const char * method);
>
>
>private:
>
>
>
>   int * indices_;
>
>   double * elements_;
>
>   int nElements_;
>
>   int * origIndices_;
>
>   int capacity_;
>
>};
># 353 "../src/CoinPackedVector.hpp"
>template <class BinaryFunction> void
>binaryOp(CoinPackedVector& retVal,
>  const CoinPackedVectorBase& op1, double value,
>  BinaryFunction bf)
>{
>   retVal.clear();
>   const int s = op1.getNumElements();
>   if (s > 0) {
>      retVal.reserve(s);
>      const int * inds = op1.getIndices();
>      const double * elems = op1.getElements();
>      for (int i=0; i<s; ++i ) {
>  retVal.insert(inds[i], bf(value, elems[i]));
>      }
>   }
>}
>
>template <class BinaryFunction> inline void
>binaryOp(CoinPackedVector& retVal,
>  double value, const CoinPackedVectorBase& op2,
>  BinaryFunction bf)
>{
>   binaryOp(retVal, op2, value, bf);
>}
>
>template <class BinaryFunction> void
>binaryOp(CoinPackedVector& retVal,
>  const CoinPackedVectorBase& op1, const CoinPackedVectorBase& op2,
>  BinaryFunction bf)
>{
>   retVal.clear();
>   const int s1 = op1.getNumElements();
>   const int s2 = op2.getNumElements();
>
>
>
>
>
>
>   if (s1 == 0 && s2 == 0)
>      return;
>
>   retVal.reserve(s1+s2);
>
>   const int * inds1 = op1.getIndices();
>   const double * elems1 = op1.getElements();
>   const int * inds2 = op2.getIndices();
>   const double * elems2 = op2.getElements();
>
>   int i;
>
>   for ( i=0; i<s1; ++i ) {
>      const int index = inds1[i];
>      const int pos2 = op2.findIndex(index);
>      const double val = bf(elems1[i], pos2 == -1 ? 0.0 : elems2[pos2]);
>
>      retVal.insert(index, val);
>   }
>
>   for ( i=0; i<s2; ++i ) {
>      const int index = inds2[i];
>
>      if ( op1.isExistingIndex(index) )
>  continue;
>
>      const double val = bf(0.0, elems2[i]);
>
>      retVal.insert(index, val);
>   }
>}
>
>
>
>template <class BinaryFunction> CoinPackedVector
>binaryOp(const CoinPackedVectorBase& op1, double value,
>  BinaryFunction bf)
>{
>   CoinPackedVector retVal;
>   retVal.setTestForDuplicateIndex(true);
>   binaryOp(retVal, op1, value, bf);
>   return retVal;
>}
>
>template <class BinaryFunction> CoinPackedVector
>binaryOp(double value, const CoinPackedVectorBase& op2,
>  BinaryFunction bf)
>{
>   CoinPackedVector retVal;
>   retVal.setTestForDuplicateIndex(true);
>   binaryOp(retVal, op2, value, bf);
>   return retVal;
>}
>
>template <class BinaryFunction> CoinPackedVector
>binaryOp(const CoinPackedVectorBase& op1, const CoinPackedVectorBase& op2,
>  BinaryFunction bf)
>{
>   CoinPackedVector retVal;
>   retVal.setTestForDuplicateIndex(true);
>   binaryOp(retVal, op1, op2, bf);
>   return retVal;
>}
>
>
>
>inline CoinPackedVector operator+(const CoinPackedVectorBase& op1,
>      const CoinPackedVectorBase& op2)
>{
>   CoinPackedVector retVal;
>   retVal.setTestForDuplicateIndex(true);
>   binaryOp(retVal, op1, op2, std::plus<double>());
>   return retVal;
>}
>
>
>inline CoinPackedVector operator-(const CoinPackedVectorBase& op1,
>     const CoinPackedVectorBase& op2)
>{
>   CoinPackedVector retVal;
>   retVal.setTestForDuplicateIndex(true);
>   binaryOp(retVal, op1, op2, std::minus<double>());
>   return retVal;
>}
>
>
>inline CoinPackedVector operator*(const CoinPackedVectorBase& op1,
>      const CoinPackedVectorBase& op2)
>{
>   CoinPackedVector retVal;
>   retVal.setTestForDuplicateIndex(true);
>   binaryOp(retVal, op1, op2, std::multiplies<double>());
>   return retVal;
>}
>
>
>inline CoinPackedVector operator/(const CoinPackedVectorBase& op1,
>      const CoinPackedVectorBase& op2)
>{
>   CoinPackedVector retVal;
>   retVal.setTestForDuplicateIndex(true);
>   binaryOp(retVal, op1, op2, std::divides<double>());
>   return retVal;
>}
>
>
>
>
>inline double sparseDotProduct(const CoinPackedVectorBase& op1,
>                        const CoinPackedVectorBase& op2){
>  int len, i;
>  double acc = 0.0;
>  CoinPackedVector retVal;
>
>  CoinPackedVector retval = op1*op2;
>  len = retval.getNumElements();
>  double * CParray = retval.getElements();
>
>  for(i = 0; i < len; i++){
>    acc += CParray[i];
>  }
>return acc;
>}
>
>
>
>
>inline double sortedSparseDotProduct(const CoinPackedVectorBase& op1,
>                        const CoinPackedVectorBase& op2){
>  int i, j, len1, len2;
>  double acc = 0.0;
>
>  const double* v1val = op1.getElements();
>  const double* v2val = op2.getElements();
>  const int* v1ind = op1.getIndices();
>  const int* v2ind = op2.getIndices();
>
>  len1 = op1.getNumElements();
>  len2 = op2.getNumElements();
>
>  i = 0;
>  j = 0;
>
>  while(i < len1 && j < len2){
>    if(v1ind[i] == v2ind[j]){
>      acc += v1val[i] * v2val[j];
>      i++;
>      j++;
>   }
>    else if(v2ind[j] < v1ind[i]){
>      j++;
>    }
>    else{
>      i++;
>    }
>  }
>  return acc;
> }
># 560 "../src/CoinPackedVector.hpp"
>inline CoinPackedVector
>operator+(const CoinPackedVectorBase& op1, double value)
>{
>   CoinPackedVector retVal(op1);
>   retVal += value;
>   return retVal;
>}
>
>
>inline CoinPackedVector
>operator-(const CoinPackedVectorBase& op1, double value)
>{
>   CoinPackedVector retVal(op1);
>   retVal -= value;
>   return retVal;
>}
>
>
>inline CoinPackedVector
>operator*(const CoinPackedVectorBase& op1, double value)
>{
>   CoinPackedVector retVal(op1);
>   retVal *= value;
>   return retVal;
>}
>
>
>inline CoinPackedVector
>operator/(const CoinPackedVectorBase& op1, double value)
>{
>   CoinPackedVector retVal(op1);
>   retVal /= value;
>   return retVal;
>}
>
>
>
>
>inline CoinPackedVector
>operator+(double value, const CoinPackedVectorBase& op1)
>{
>   CoinPackedVector retVal(op1);
>   retVal += value;
>   return retVal;
>}
>
>
>inline CoinPackedVector
>operator-(double value, const CoinPackedVectorBase& op1)
>{
>   CoinPackedVector retVal(op1);
>   const int size = retVal.getNumElements();
>   double* elems = retVal.getElements();
>   for (int i = 0; i < size; ++i) {
>      elems[i] = value - elems[i];
>   }
>   return retVal;
>}
>
>
>inline CoinPackedVector
>operator*(double value, const CoinPackedVectorBase& op1)
>{
>   CoinPackedVector retVal(op1);
>   retVal *= value;
>   return retVal;
>}
>
>
>inline CoinPackedVector
>operator/(double value, const CoinPackedVectorBase& op1)
>{
>   CoinPackedVector retVal(op1);
>   const int size = retVal.getNumElements();
>   double* elems = retVal.getElements();
>   for (int i = 0; i < size; ++i) {
>      elems[i] = value / elems[i];
>   }
>   return retVal;
>}
># 648 "../src/CoinPackedVector.hpp"
>void
>CoinPackedVectorUnitTest();
># 15 "CoinPackedVectorTest.cpp" 2
># 1 "../src/CoinShallowPackedVector.hpp" 1
># 74 "../src/CoinShallowPackedVector.hpp"
>class CoinShallowPackedVector : public CoinPackedVectorBase {
>   friend void CoinShallowPackedVectorUnitTest();
>
>public:
>
>
>
>
>   virtual int getNumElements() const { return nElements_; }
>
>   virtual const int * getIndices() const { return indices_; }
>
>   virtual const double * getElements() const { return elements_; }
>
>
>
>
>
>   void clear();
>
>   CoinShallowPackedVector& operator=(const CoinShallowPackedVector & x);
>
>   CoinShallowPackedVector& operator=(const CoinPackedVectorBase & x);
>
>   void setVector(int size, const int * indices, const double * elements,
>    bool testForDuplicateIndex = true);
>
>
>
>
>
>   CoinShallowPackedVector(bool testForDuplicateIndex = true);
># 114 "../src/CoinShallowPackedVector.hpp"
>   CoinShallowPackedVector(int size,
>     const int * indices, const double * elements,
>     bool testForDuplicateIndex = true);
>
>   CoinShallowPackedVector(const CoinPackedVectorBase &);
>
>   CoinShallowPackedVector(const CoinShallowPackedVector &);
>
>   ~CoinShallowPackedVector() {}
>
>   void print();
>
>
>private:
>
>
>
>   const int * indices_;
>
>   const double * elements_;
>
>   int nElements_;
>
>};
>
>
>
>
>
>
>
>void
>CoinShallowPackedVectorUnitTest();
># 16 "CoinPackedVectorTest.cpp" 2
>
>
>void
>CoinPackedVectorUnitTest()
>{
>
>  int i;
>
>  {
>    CoinPackedVector r;
>    ((r.indices_==__null) ? static_cast<void> (0) : __assert_fail ("r.indices_==__null", "CoinPackedVectorTest.cpp", 26, __PRETTY_FUNCTION__));
>    ((r.origIndices_==__null) ? static_cast<void> (0) : __assert_fail ("r.origIndices_==__null", "CoinPackedVectorTest.cpp", 27, __PRETTY_FUNCTION__));
>    ((r.elements_==__null) ? static_cast<void> (0) : __assert_fail ("r.elements_==__null", "CoinPackedVectorTest.cpp", 28, __PRETTY_FUNCTION__));
>    ((r.getNumElements()==0) ? static_cast<void> (0) : __assert_fail ("r.getNumElements()==0", "CoinPackedVectorTest.cpp", 29, __PRETTY_FUNCTION__));
>    ((r.capacity_==0) ? static_cast<void> (0) : __assert_fail ("r.capacity_==0", "CoinPackedVectorTest.cpp", 30, __PRETTY_FUNCTION__));
>  }
>
>
>  const int ne = 4;
>  int inx[ne] = { 1, 3, 4, 7 };
>  double el[ne] = { 1.2, 3.4, 5.6, 7.8 };
>  {
>    CoinPackedVector r;
>    ((r.getNumElements()==0) ? static_cast<void> (0) : __assert_fail ("r.getNumElements()==0", "CoinPackedVectorTest.cpp", 39, __PRETTY_FUNCTION__));
>
>
>    r.setVector( ne, inx, el );
>    ((r.getNumElements()==ne) ? static_cast<void> (0) : __assert_fail ("r.getNumElements()==ne", "CoinPackedVectorTest.cpp", 43, __PRETTY_FUNCTION__));
>    for ( i=0; i<ne; i++ ) {
>      ((r.getIndices()[i] == inx[i]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[i] == inx[i]", "CoinPackedVectorTest.cpp", 45, __PRETTY_FUNCTION__));
>      ((r.getOriginalPosition()[i] == i) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[i] == i", "CoinPackedVectorTest.cpp", 46, __PRETTY_FUNCTION__));
>      ((r.getElements()[i] == el[i]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[i] == el[i]", "CoinPackedVectorTest.cpp", 47, __PRETTY_FUNCTION__));
>    }
>    ((r.getMaxIndex()==7) ? static_cast<void> (0) : __assert_fail ("r.getMaxIndex()==7", "CoinPackedVectorTest.cpp", 49, __PRETTY_FUNCTION__));
>    ((r.getMinIndex()==1) ? static_cast<void> (0) : __assert_fail ("r.getMinIndex()==1", "CoinPackedVectorTest.cpp", 50, __PRETTY_FUNCTION__));
>
>
>    const int ne2 = 5;
>    int inx2[ne2] = { 2, 4, 8, 14, 3 };
>    double el2[ne2] = { 2.2, 4.4, 6.6, 8.8, 3.3 };
>
>    r.setVector(ne2,inx2,el2);
>
>    ((r.getNumElements()==ne2) ? static_cast<void> (0) : __assert_fail ("r.getNumElements()==ne2", "CoinPackedVectorTest.cpp", 59, __PRETTY_FUNCTION__));
>
>    ((r.getIndices()[0]==inx2[0]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[0]==inx2[0]", "CoinPackedVectorTest.cpp", 61, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[0]==0) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[0]==0", "CoinPackedVectorTest.cpp", 62, __PRETTY_FUNCTION__));
>    ((r.getElements()[0]==el2[0]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[0]==el2[0]", "CoinPackedVectorTest.cpp", 63, __PRETTY_FUNCTION__));
>
>    ((r.getIndices()[1]==inx2[1]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[1]==inx2[1]", "CoinPackedVectorTest.cpp", 65, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[1]==1) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[1]==1", "CoinPackedVectorTest.cpp", 66, __PRETTY_FUNCTION__));
>    ((r.getElements()[1]==el2[1]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[1]==el2[1]", "CoinPackedVectorTest.cpp", 67, __PRETTY_FUNCTION__));
>
>    ((r.getIndices()[2]==inx2[2]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[2]==inx2[2]", "CoinPackedVectorTest.cpp", 69, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[2]==2) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[2]==2", "CoinPackedVectorTest.cpp", 70, __PRETTY_FUNCTION__));
>    ((r.getElements()[2]==el2[2]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[2]==el2[2]", "CoinPackedVectorTest.cpp", 71, __PRETTY_FUNCTION__));
>
>    ((r.getIndices()[3]==inx2[3]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[3]==inx2[3]", "CoinPackedVectorTest.cpp", 73, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[3]==3) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[3]==3", "CoinPackedVectorTest.cpp", 74, __PRETTY_FUNCTION__));
>    ((r.getElements()[3]==el2[3]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[3]==el2[3]", "CoinPackedVectorTest.cpp", 75, __PRETTY_FUNCTION__));
>
>    ((r.getIndices()[4]==inx2[4]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[4]==inx2[4]", "CoinPackedVectorTest.cpp", 77, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[4]==4) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[4]==4", "CoinPackedVectorTest.cpp", 78, __PRETTY_FUNCTION__));
>    ((r.getElements()[4]==el2[4]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[4]==el2[4]", "CoinPackedVectorTest.cpp", 79, __PRETTY_FUNCTION__));
>
>    ((r.getMaxIndex()==14) ? static_cast<void> (0) : __assert_fail ("r.getMaxIndex()==14", "CoinPackedVectorTest.cpp", 81, __PRETTY_FUNCTION__));
>    ((r.getMinIndex()==2) ? static_cast<void> (0) : __assert_fail ("r.getMinIndex()==2", "CoinPackedVectorTest.cpp", 82, __PRETTY_FUNCTION__));
>    ((r.getMaxIndex()==14) ? static_cast<void> (0) : __assert_fail ("r.getMaxIndex()==14", "CoinPackedVectorTest.cpp", 83, __PRETTY_FUNCTION__));
>    ((r.getMinIndex()==2) ? static_cast<void> (0) : __assert_fail ("r.getMinIndex()==2", "CoinPackedVectorTest.cpp", 84, __PRETTY_FUNCTION__));
>    {
>      bool errorThrown = false;
>      try {
>        r.duplicateIndex();
>      }
>      catch (CoinError e) {
>        errorThrown = true;
>      }
>      ((!errorThrown) ? static_cast<void> (0) : __assert_fail ("!errorThrown", "CoinPackedVectorTest.cpp", 93, __PRETTY_FUNCTION__));
>    }
>
>    CoinPackedVector r1(ne2,inx2,el2,true);
>    ((r == r1) ? static_cast<void> (0) : __assert_fail ("r == r1", "CoinPackedVectorTest.cpp", 97, __PRETTY_FUNCTION__));
>
>
>
>    {
>      const int ne3 = 4;
>      int inx3[ne3] = { 2, 4, 2, 3 };
>      double el3[ne3] = { 2.2, 4.4, 8.8, 6.6 };
>      bool errorThrown = false;
>      try {
> r.setVector(ne3,inx3,el3,true);
>      }
>      catch (CoinError e) {
>  errorThrown = true;
>      }
>      ((errorThrown) ? static_cast<void> (0) : __assert_fail ("errorThrown", "CoinPackedVectorTest.cpp", 112, __PRETTY_FUNCTION__));
>
>      errorThrown = false;
>      try {
>  r.duplicateIndex();
>      }
>      catch (CoinError e) {
>  errorThrown = true;
>      }
>      ((errorThrown) ? static_cast<void> (0) : __assert_fail ("errorThrown", "CoinPackedVectorTest.cpp", 121, __PRETTY_FUNCTION__));
>    }
>
>
>
>    r.setVector(ne2,inx2,el2);
>    bool incr=true;
>    for ( i=1; i<ne2; i++ )
>       if ( r.getElements()[i-1]>r.getElements()[i] )
>   incr=false;
>    ((!incr) ? static_cast<void> (0) : __assert_fail ("!incr", "CoinPackedVectorTest.cpp", 131, __PRETTY_FUNCTION__));
>    r.sortIncrElement();
>    incr = true;
>    for ( i=1; i<ne2; i++ )
>       if ( r.getElements()[i-1]>r.getElements()[i] )
>   incr=false;
>    ((incr) ? static_cast<void> (0) : __assert_fail ("incr", "CoinPackedVectorTest.cpp", 137, __PRETTY_FUNCTION__));
>
>  }
>
>
>  {
>    CoinPackedVector r;
>    const int ne = 3;
>    int inx[ne] = { 1, 2, 3 };
>    double el[ne] = { 2.2, 4.4, 8.8};
>    r.setVector(ne,inx,el);
>    int c = r.capacity();
>    int max = r.getMaxIndex();
>    int min = r.getMinIndex();
>
>    r.swap(0,2);
>    ((r.getIndices()[0]==3) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[0]==3", "CoinPackedVectorTest.cpp", 153, __PRETTY_FUNCTION__));
>    ((r.getIndices()[1]==2) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[1]==2", "CoinPackedVectorTest.cpp", 154, __PRETTY_FUNCTION__));
>    ((r.getIndices()[2]==1) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[2]==1", "CoinPackedVectorTest.cpp", 155, __PRETTY_FUNCTION__));
>    ((r.getElements()[0]==8.8) ? static_cast<void> (0) : __assert_fail ("r.getElements()[0]==8.8", "CoinPackedVectorTest.cpp", 156, __PRETTY_FUNCTION__));
>    ((r.getElements()[1]==4.4) ? static_cast<void> (0) : __assert_fail ("r.getElements()[1]==4.4", "CoinPackedVectorTest.cpp", 157, __PRETTY_FUNCTION__));
>    ((r.getElements()[2]==2.2) ? static_cast<void> (0) : __assert_fail ("r.getElements()[2]==2.2", "CoinPackedVectorTest.cpp", 158, __PRETTY_FUNCTION__));
>    ((r.getMaxIndex() == max) ? static_cast<void> (0) : __assert_fail ("r.getMaxIndex() == max", "CoinPackedVectorTest.cpp", 159, __PRETTY_FUNCTION__));
>    ((r.getMinIndex() == min) ? static_cast<void> (0) : __assert_fail ("r.getMinIndex() == min", "CoinPackedVectorTest.cpp", 160, __PRETTY_FUNCTION__));
>    ((r.capacity() == c) ? static_cast<void> (0) : __assert_fail ("r.capacity() == c", "CoinPackedVectorTest.cpp", 161, __PRETTY_FUNCTION__));
>
>
>    CoinPackedVector s;
>    const int nes = 4;
>    int inxs[nes] = { 11, 12, 13, 14 };
>    double els[nes] = { .122, 14.4, 18.8, 19.9};
>    s.setVector(nes,inxs,els);
>    r.append(s);
>    ((r.getNumElements()==7) ? static_cast<void> (0) : __assert_fail ("r.getNumElements()==7", "CoinPackedVectorTest.cpp", 170, __PRETTY_FUNCTION__));
>    ((r.getIndices()[0]==3) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[0]==3", "CoinPackedVectorTest.cpp", 171, __PRETTY_FUNCTION__));
>    ((r.getIndices()[1]==2) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[1]==2", "CoinPackedVectorTest.cpp", 172, __PRETTY_FUNCTION__));
>    ((r.getIndices()[2]==1) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[2]==1", "CoinPackedVectorTest.cpp", 173, __PRETTY_FUNCTION__));
>    ((r.getIndices()[3]==11) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[3]==11", "CoinPackedVectorTest.cpp", 174, __PRETTY_FUNCTION__));
>    ((r.getIndices()[4]==12) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[4]==12", "CoinPackedVectorTest.cpp", 175, __PRETTY_FUNCTION__));
>    ((r.getIndices()[5]==13) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[5]==13", "CoinPackedVectorTest.cpp", 176, __PRETTY_FUNCTION__));
>    ((r.getIndices()[6]==14) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[6]==14", "CoinPackedVectorTest.cpp", 177, __PRETTY_FUNCTION__));
>    ((r.getElements()[0]==8.8) ? static_cast<void> (0) : __assert_fail ("r.getElements()[0]==8.8", "CoinPackedVectorTest.cpp", 178, __PRETTY_FUNCTION__));
>    ((r.getElements()[1]==4.4) ? static_cast<void> (0) : __assert_fail ("r.getElements()[1]==4.4", "CoinPackedVectorTest.cpp", 179, __PRETTY_FUNCTION__));
>    ((r.getElements()[2]==2.2) ? static_cast<void> (0) : __assert_fail ("r.getElements()[2]==2.2", "CoinPackedVectorTest.cpp", 180, __PRETTY_FUNCTION__));
>    ((r.getElements()[3]==.122) ? static_cast<void> (0) : __assert_fail ("r.getElements()[3]==.122", "CoinPackedVectorTest.cpp", 181, __PRETTY_FUNCTION__));
>    ((r.getElements()[4]==14.4) ? static_cast<void> (0) : __assert_fail ("r.getElements()[4]==14.4", "CoinPackedVectorTest.cpp", 182, __PRETTY_FUNCTION__));
>    ((r.getElements()[5]==18.8) ? static_cast<void> (0) : __assert_fail ("r.getElements()[5]==18.8", "CoinPackedVectorTest.cpp", 183, __PRETTY_FUNCTION__));
>    ((r.getElements()[6]==19.9) ? static_cast<void> (0) : __assert_fail ("r.getElements()[6]==19.9", "CoinPackedVectorTest.cpp", 184, __PRETTY_FUNCTION__));
>    ((r.getMaxIndex() == 14) ? static_cast<void> (0) : __assert_fail ("r.getMaxIndex() == 14", "CoinPackedVectorTest.cpp", 185, __PRETTY_FUNCTION__));
>    ((r.getMinIndex() == 1) ? static_cast<void> (0) : __assert_fail ("r.getMinIndex() == 1", "CoinPackedVectorTest.cpp", 186, __PRETTY_FUNCTION__));
>
>
>    c = r.capacity();
>    r.truncate(4);
>    ((r.getNumElements()==4) ? static_cast<void> (0) : __assert_fail ("r.getNumElements()==4", "CoinPackedVectorTest.cpp", 191, __PRETTY_FUNCTION__));
>    ((r.getIndices()[0]==3) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[0]==3", "CoinPackedVectorTest.cpp", 192, __PRETTY_FUNCTION__));
>    ((r.getIndices()[1]==2) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[1]==2", "CoinPackedVectorTest.cpp", 193, __PRETTY_FUNCTION__));
>    ((r.getIndices()[2]==1) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[2]==1", "CoinPackedVectorTest.cpp", 194, __PRETTY_FUNCTION__));
>    ((r.getIndices()[3]==11) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[3]==11", "CoinPackedVectorTest.cpp", 195, __PRETTY_FUNCTION__));
>    ((r.getElements()[0]==8.8) ? static_cast<void> (0) : __assert_fail ("r.getElements()[0]==8.8", "CoinPackedVectorTest.cpp", 196, __PRETTY_FUNCTION__));
>    ((r.getElements()[1]==4.4) ? static_cast<void> (0) : __assert_fail ("r.getElements()[1]==4.4", "CoinPackedVectorTest.cpp", 197, __PRETTY_FUNCTION__));
>    ((r.getElements()[2]==2.2) ? static_cast<void> (0) : __assert_fail ("r.getElements()[2]==2.2", "CoinPackedVectorTest.cpp", 198, __PRETTY_FUNCTION__));
>    ((r.getElements()[3]==.122) ? static_cast<void> (0) : __assert_fail ("r.getElements()[3]==.122", "CoinPackedVectorTest.cpp", 199, __PRETTY_FUNCTION__));
>    ((r.getMaxIndex() == 11) ? static_cast<void> (0) : __assert_fail ("r.getMaxIndex() == 11", "CoinPackedVectorTest.cpp", 200, __PRETTY_FUNCTION__));
>    ((r.getMinIndex() == 1) ? static_cast<void> (0) : __assert_fail ("r.getMinIndex() == 1", "CoinPackedVectorTest.cpp", 201, __PRETTY_FUNCTION__));
>    ((r.capacity() == c) ? static_cast<void> (0) : __assert_fail ("r.capacity() == c", "CoinPackedVectorTest.cpp", 202, __PRETTY_FUNCTION__));
>  }
>
>
>
>  {
>    CoinPackedVector rhs;
>    {
>      CoinPackedVector r;
>      {
>        CoinPackedVector rC1(r);
>        ((0==r.getNumElements()) ? static_cast<void> (0) : __assert_fail ("0==r.getNumElements()", "CoinPackedVectorTest.cpp", 213, __PRETTY_FUNCTION__));
>        ((0==rC1.getNumElements()) ? static_cast<void> (0) : __assert_fail ("0==rC1.getNumElements()", "CoinPackedVectorTest.cpp", 214, __PRETTY_FUNCTION__));
>
>
>        r.setVector( ne, inx, el );
>
>        ((ne==r.getNumElements()) ? static_cast<void> (0) : __assert_fail ("ne==r.getNumElements()", "CoinPackedVectorTest.cpp", 219, __PRETTY_FUNCTION__));
>        ((0==rC1.getNumElements()) ? static_cast<void> (0) : __assert_fail ("0==rC1.getNumElements()", "CoinPackedVectorTest.cpp", 220, __PRETTY_FUNCTION__));
>      }
>
>      CoinPackedVector rC2(r);
>
>      ((ne==r.getNumElements()) ? static_cast<void> (0) : __assert_fail ("ne==r.getNumElements()", "CoinPackedVectorTest.cpp", 225, __PRETTY_FUNCTION__));
>      ((ne==rC2.getNumElements()) ? static_cast<void> (0) : __assert_fail ("ne==rC2.getNumElements()", "CoinPackedVectorTest.cpp", 226, __PRETTY_FUNCTION__));
>
>      for ( i=0; i<ne; i++ ) {
>        ((r.getIndices()[i] == rC2.getIndices()[i]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[i] == rC2.getIndices()[i]", "CoinPackedVectorTest.cpp", 229, __PRETTY_FUNCTION__));
>        ((r.getOriginalPosition()[i] == rC2.getOriginalPosition()[i]) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[i] == rC2.getOriginalPosition()[i]", "CoinPackedVectorTest.cpp", 230, __PRETTY_FUNCTION__));
>        ((r.getElements()[i] == rC2.getElements()[i]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[i] == rC2.getElements()[i]", "CoinPackedVectorTest.cpp", 231, __PRETTY_FUNCTION__));
>      }
>
>      rhs=rC2;
>    }
>
>    ((rhs.getNumElements()==ne) ? static_cast<void> (0) : __assert_fail ("rhs.getNumElements()==ne", "CoinPackedVectorTest.cpp", 237, __PRETTY_FUNCTION__));
>
>    for ( i=0; i<ne; i++ ) {
>      ((inx[i] == rhs.getIndices()[i]) ? static_cast<void> (0) : __assert_fail ("inx[i] == rhs.getIndices()[i]", "CoinPackedVectorTest.cpp", 240, __PRETTY_FUNCTION__));
>      ((i == rhs.getOriginalPosition()[i]) ? static_cast<void> (0) : __assert_fail ("i == rhs.getOriginalPosition()[i]", "CoinPackedVectorTest.cpp", 241, __PRETTY_FUNCTION__));
>      ((el[i] == rhs.getElements()[i]) ? static_cast<void> (0) : __assert_fail ("el[i] == rhs.getElements()[i]", "CoinPackedVectorTest.cpp", 242, __PRETTY_FUNCTION__));
>    }
>  }
>
>
>  {
>    CoinPackedVector v1,v2;
>    ((v1==v2) ? static_cast<void> (0) : __assert_fail ("v1==v2", "CoinPackedVectorTest.cpp", 249, __PRETTY_FUNCTION__));
>    ((v2==v1) ? static_cast<void> (0) : __assert_fail ("v2==v1", "CoinPackedVectorTest.cpp", 250, __PRETTY_FUNCTION__));
>    ((v1==v1) ? static_cast<void> (0) : __assert_fail ("v1==v1", "CoinPackedVectorTest.cpp", 251, __PRETTY_FUNCTION__));
>    ((!(v1!=v2)) ? static_cast<void> (0) : __assert_fail ("!(v1!=v2)", "CoinPackedVectorTest.cpp", 252, __PRETTY_FUNCTION__));
>    ((v1.isEquivalent(v2)) ? static_cast<void> (0) : __assert_fail ("v1.isEquivalent(v2)", "CoinPackedVectorTest.cpp", 253, __PRETTY_FUNCTION__));
>    ((v2.isEquivalent(v1)) ? static_cast<void> (0) : __assert_fail ("v2.isEquivalent(v1)", "CoinPackedVectorTest.cpp", 254, __PRETTY_FUNCTION__));
>    ((v1.isEquivalent(v1)) ? static_cast<void> (0) : __assert_fail ("v1.isEquivalent(v1)", "CoinPackedVectorTest.cpp", 255, __PRETTY_FUNCTION__));
>
>    v1.setVector( ne, inx, el );
>    ((!(v1==v2)) ? static_cast<void> (0) : __assert_fail ("!(v1==v2)", "CoinPackedVectorTest.cpp", 258, __PRETTY_FUNCTION__));
>    ((v1!=v2) ? static_cast<void> (0) : __assert_fail ("v1!=v2", "CoinPackedVectorTest.cpp", 259, __PRETTY_FUNCTION__));
>    ((!v1.isEquivalent(v2)) ? static_cast<void> (0) : __assert_fail ("!v1.isEquivalent(v2)", "CoinPackedVectorTest.cpp", 260, __PRETTY_FUNCTION__));
>
>    CoinPackedVector v3(v1);
>    ((v3==v1) ? static_cast<void> (0) : __assert_fail ("v3==v1", "CoinPackedVectorTest.cpp", 263, __PRETTY_FUNCTION__));
>    ((v3!=v2) ? static_cast<void> (0) : __assert_fail ("v3!=v2", "CoinPackedVectorTest.cpp", 264, __PRETTY_FUNCTION__));
>    ((v1.isEquivalent(v3)) ? static_cast<void> (0) : __assert_fail ("v1.isEquivalent(v3)", "CoinPackedVectorTest.cpp", 265, __PRETTY_FUNCTION__));
>    ((v3.isEquivalent(v1)) ? static_cast<void> (0) : __assert_fail ("v3.isEquivalent(v1)", "CoinPackedVectorTest.cpp", 266, __PRETTY_FUNCTION__));
>
>    CoinPackedVector v4(v2);
>    ((v4!=v1) ? static_cast<void> (0) : __assert_fail ("v4!=v1", "CoinPackedVectorTest.cpp", 269, __PRETTY_FUNCTION__));
>    ((v4==v2) ? static_cast<void> (0) : __assert_fail ("v4==v2", "CoinPackedVectorTest.cpp", 270, __PRETTY_FUNCTION__));
>  }
>
>  {
>
>    const int ne = 4;
>    int inx[ne] = { 1, 4, 0, 2 };
>    double el[ne] = { 10., 40., 1., 20. };
>    double extSortKey[5] = { -20., 10., 5., 4., 20. };
>    CoinPackedVector r;
>    r.setVector(ne,inx,el);
>
>
>    r.sortIncrIndex();
>    for ( i=1; i<ne; i++ ) ((r.getIndices()[i-1] < r.getIndices()[i]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[i-1] < r.getIndices()[i]", "CoinPackedVectorTest.cpp", 284, __PRETTY_FUNCTION__));
>
>
>    r.sortIncrElement();
>    for ( i=1; i<ne; i++ ) ((r.getElements()[i-1] < r.getElements()[i]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[i-1] < r.getElements()[i]", "CoinPackedVectorTest.cpp", 288, __PRETTY_FUNCTION__));
>
>
>    CoinIncrSolutionOrdered pcSo(extSortKey);
>    r.sort(pcSo);
>    for ( i=1; i<ne; i++ )
>      ((extSortKey[r.getIndices()[i-1]] < extSortKey[r.getIndices()[i]]) ? static_cast<void> (0) : __assert_fail ("extSortKey[r.getIndices()[i-1]] < extSortKey[r.getIndices()[i]]", "CoinPackedVectorTest.cpp", 294, __PRETTY_FUNCTION__));
>
>
>
>    r.sortIncrIndex();
>    for ( i=1; i<ne; i++ ) ((r.getIndices()[i-1] < r.getIndices()[i]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[i-1] < r.getIndices()[i]", "CoinPackedVectorTest.cpp", 299, __PRETTY_FUNCTION__));
>  }
>
>
>  {
>
>    const int ne = 4;
>    int inx[ne] = { 1, 4, 0, 2 };
>    double el[ne] = { 10., 40., 1., 50. };
>    CoinPackedVector r;
>    ((r[1]==0.) ? static_cast<void> (0) : __assert_fail ("r[1]==0.", "CoinPackedVectorTest.cpp", 309, __PRETTY_FUNCTION__));
>
>    r.setVector(ne,inx,el);
>
>    ((r[-1]==0.) ? static_cast<void> (0) : __assert_fail ("r[-1]==0.", "CoinPackedVectorTest.cpp", 313, __PRETTY_FUNCTION__));
>    ((r[ 0]==1.) ? static_cast<void> (0) : __assert_fail ("r[ 0]==1.", "CoinPackedVectorTest.cpp", 314, __PRETTY_FUNCTION__));
>    ((r[ 1]==10.) ? static_cast<void> (0) : __assert_fail ("r[ 1]==10.", "CoinPackedVectorTest.cpp", 315, __PRETTY_FUNCTION__));
>    ((r[ 2]==50.) ? static_cast<void> (0) : __assert_fail ("r[ 2]==50.", "CoinPackedVectorTest.cpp", 316, __PRETTY_FUNCTION__));
>    ((r[ 3]==0.) ? static_cast<void> (0) : __assert_fail ("r[ 3]==0.", "CoinPackedVectorTest.cpp", 317, __PRETTY_FUNCTION__));
>    ((r[ 4]==40.) ? static_cast<void> (0) : __assert_fail ("r[ 4]==40.", "CoinPackedVectorTest.cpp", 318, __PRETTY_FUNCTION__));
>    ((r[ 5]==0.) ? static_cast<void> (0) : __assert_fail ("r[ 5]==0.", "CoinPackedVectorTest.cpp", 319, __PRETTY_FUNCTION__));
>    ((r.isExistingIndex(2)) ? static_cast<void> (0) : __assert_fail ("r.isExistingIndex(2)", "CoinPackedVectorTest.cpp", 320, __PRETTY_FUNCTION__));
>    ((!r.isExistingIndex(3)) ? static_cast<void> (0) : __assert_fail ("!r.isExistingIndex(3)", "CoinPackedVectorTest.cpp", 321, __PRETTY_FUNCTION__));
>
>    r.sortIncrElement();
>
>    ((r[-1]==0.) ? static_cast<void> (0) : __assert_fail ("r[-1]==0.", "CoinPackedVectorTest.cpp", 325, __PRETTY_FUNCTION__));
>    ((r[ 0]==1.) ? static_cast<void> (0) : __assert_fail ("r[ 0]==1.", "CoinPackedVectorTest.cpp", 326, __PRETTY_FUNCTION__));
>    ((r[ 1]==10.) ? static_cast<void> (0) : __assert_fail ("r[ 1]==10.", "CoinPackedVectorTest.cpp", 327, __PRETTY_FUNCTION__));
>    ((r[ 2]==50.) ? static_cast<void> (0) : __assert_fail ("r[ 2]==50.", "CoinPackedVectorTest.cpp", 328, __PRETTY_FUNCTION__));
>    ((r[ 3]==0.) ? static_cast<void> (0) : __assert_fail ("r[ 3]==0.", "CoinPackedVectorTest.cpp", 329, __PRETTY_FUNCTION__));
>    ((r[ 4]==40.) ? static_cast<void> (0) : __assert_fail ("r[ 4]==40.", "CoinPackedVectorTest.cpp", 330, __PRETTY_FUNCTION__));
>    ((r[ 5]==0.) ? static_cast<void> (0) : __assert_fail ("r[ 5]==0.", "CoinPackedVectorTest.cpp", 331, __PRETTY_FUNCTION__));
>    ((!r.isExistingIndex(-1)) ? static_cast<void> (0) : __assert_fail ("!r.isExistingIndex(-1)", "CoinPackedVectorTest.cpp", 332, __PRETTY_FUNCTION__));
>    ((r.isExistingIndex(0)) ? static_cast<void> (0) : __assert_fail ("r.isExistingIndex(0)", "CoinPackedVectorTest.cpp", 333, __PRETTY_FUNCTION__));
>    ((!r.isExistingIndex(3)) ? static_cast<void> (0) : __assert_fail ("!r.isExistingIndex(3)", "CoinPackedVectorTest.cpp", 334, __PRETTY_FUNCTION__));
>    ((r.isExistingIndex(4)) ? static_cast<void> (0) : __assert_fail ("r.isExistingIndex(4)", "CoinPackedVectorTest.cpp", 335, __PRETTY_FUNCTION__));
>    ((!r.isExistingIndex(5)) ? static_cast<void> (0) : __assert_fail ("!r.isExistingIndex(5)", "CoinPackedVectorTest.cpp", 336, __PRETTY_FUNCTION__));
>
>    ((r.getMaxIndex()==4) ? static_cast<void> (0) : __assert_fail ("r.getMaxIndex()==4", "CoinPackedVectorTest.cpp", 338, __PRETTY_FUNCTION__));
>    ((r.getMinIndex()==0) ? static_cast<void> (0) : __assert_fail ("r.getMinIndex()==0", "CoinPackedVectorTest.cpp", 339, __PRETTY_FUNCTION__));
>  }
>
>
>
>  {
>    CoinPackedVector nullVec;
>    ((nullVec.getMaxIndex() == -COIN_INT_MAX) ? static_cast<void> (0) : __assert_fail ("nullVec.getMaxIndex() == -COIN_INT_MAX", "CoinPackedVectorTest.cpp", 346, __PRETTY_FUNCTION__));
>    ((nullVec.getMinIndex() == COIN_INT_MAX) ? static_cast<void> (0) : __assert_fail ("nullVec.getMinIndex() == COIN_INT_MAX", "CoinPackedVectorTest.cpp", 347, __PRETTY_FUNCTION__));
>  }
>
>
>  {
>    const int ne = 4;
>    int inx1[ne] = { 1, 3, 4, 7 };
>    double el1[ne] = { 1.2, 3.4, 5.6, 7.8 };
>    int inx2[ne] = { 7, 4, 3, 1 };
>    double el2[ne] = { 7.8+.5, 5.6+.5, 3.4+.5, 1.2+.5 };
>    CoinPackedVector v1,v2;
>    v1.setVector(ne,inx1,el1);
>    v2.setVector(ne,inx2,el2);
>    ((!v1.isEquivalent(v2)) ? static_cast<void> (0) : __assert_fail ("!v1.isEquivalent(v2)", "CoinPackedVectorTest.cpp", 360, __PRETTY_FUNCTION__));
>    ((v1.isEquivalent(v2,CoinAbsFltEq(.6))) ? static_cast<void> (0) : __assert_fail ("v1.isEquivalent(v2,CoinAbsFltEq(.6))", "CoinPackedVectorTest.cpp", 361, __PRETTY_FUNCTION__));
>    ((v1.isEquivalent(v2,CoinRelFltEq(.6))) ? static_cast<void> (0) : __assert_fail ("v1.isEquivalent(v2,CoinRelFltEq(.6))", "CoinPackedVectorTest.cpp", 362, __PRETTY_FUNCTION__));
>  }
>
>  {
>
>    CoinPackedVector v1,v2;
>    ((v1.capacity()==0) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==0", "CoinPackedVectorTest.cpp", 368, __PRETTY_FUNCTION__));
>    v1.reserve(6);
>    ((v1.capacity()==6) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==6", "CoinPackedVectorTest.cpp", 370, __PRETTY_FUNCTION__));
>    ((v1.getNumElements()==0) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==0", "CoinPackedVectorTest.cpp", 371, __PRETTY_FUNCTION__));
>    v2=v1;
>    ((v2.capacity() == v2.getNumElements()) ? static_cast<void> (0) : __assert_fail ("v2.capacity() == v2.getNumElements()", "CoinPackedVectorTest.cpp", 373, __PRETTY_FUNCTION__));
>    ((v2.getNumElements()==0) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==0", "CoinPackedVectorTest.cpp", 374, __PRETTY_FUNCTION__));
>    ((v2==v1) ? static_cast<void> (0) : __assert_fail ("v2==v1", "CoinPackedVectorTest.cpp", 375, __PRETTY_FUNCTION__));
>    v1.setVector(0,__null,__null);
>    ((v1.capacity()==6) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==6", "CoinPackedVectorTest.cpp", 377, __PRETTY_FUNCTION__));
>    ((v1.getNumElements()==0) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==0", "CoinPackedVectorTest.cpp", 378, __PRETTY_FUNCTION__));
>    ((v2==v1) ? static_cast<void> (0) : __assert_fail ("v2==v1", "CoinPackedVectorTest.cpp", 379, __PRETTY_FUNCTION__));
>    v2=v1;
>    ((v2.capacity() == v2.getNumElements()) ? static_cast<void> (0) : __assert_fail ("v2.capacity() == v2.getNumElements()", "CoinPackedVectorTest.cpp", 381, __PRETTY_FUNCTION__));
>    ((v2.getNumElements()==0) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==0", "CoinPackedVectorTest.cpp", 382, __PRETTY_FUNCTION__));
>    ((v2==v1) ? static_cast<void> (0) : __assert_fail ("v2==v1", "CoinPackedVectorTest.cpp", 383, __PRETTY_FUNCTION__));
>
>    const int ne = 2;
>    int inx[ne] = { 1, 3 };
>    double el[ne] = { 1.2, 3.4 };
>    v1.setVector(ne,inx,el);
>    ((v1.capacity()==6) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==6", "CoinPackedVectorTest.cpp", 389, __PRETTY_FUNCTION__));
>    ((v1.getNumElements()==2) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==2", "CoinPackedVectorTest.cpp", 390, __PRETTY_FUNCTION__));
>    v2=v1;
>    ((v2.capacity()==v2.getNumElements()) ? static_cast<void> (0) : __assert_fail ("v2.capacity()==v2.getNumElements()", "CoinPackedVectorTest.cpp", 392, __PRETTY_FUNCTION__));
>    ((v2.getNumElements()==2) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==2", "CoinPackedVectorTest.cpp", 393, __PRETTY_FUNCTION__));
>    ((v2==v1) ? static_cast<void> (0) : __assert_fail ("v2==v1", "CoinPackedVectorTest.cpp", 394, __PRETTY_FUNCTION__));
>
>    const int ne1 = 5;
>    int inx1[ne1] = { 1, 3, 4, 5, 6 };
>    double el1[ne1] = { 1.2, 3.4, 5., 6., 7. };
>    v1.setVector(ne1,inx1,el1);
>    ((v1.capacity()==6) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==6", "CoinPackedVectorTest.cpp", 400, __PRETTY_FUNCTION__));
>    ((v1.getNumElements()==5) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==5", "CoinPackedVectorTest.cpp", 401, __PRETTY_FUNCTION__));
>    v2=v1;
>    ((v2.capacity()==v2.getNumElements()) ? static_cast<void> (0) : __assert_fail ("v2.capacity()==v2.getNumElements()", "CoinPackedVectorTest.cpp", 403, __PRETTY_FUNCTION__));
>    ((v2.getNumElements()==5) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==5", "CoinPackedVectorTest.cpp", 404, __PRETTY_FUNCTION__));
>    ((v2==v1) ? static_cast<void> (0) : __assert_fail ("v2==v1", "CoinPackedVectorTest.cpp", 405, __PRETTY_FUNCTION__));
>
>    const int ne2 = 8;
>    int inx2[ne2] = { 1, 3, 4, 5, 6, 7, 8, 9 };
>    double el2[ne2] = { 1.2, 3.4, 5., 6., 7., 8., 9., 10. };
>    v1.setVector(ne2,inx2,el2);
>    ((v1.capacity()==8) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==8", "CoinPackedVectorTest.cpp", 411, __PRETTY_FUNCTION__));
>    ((v1.getNumElements()==8) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==8", "CoinPackedVectorTest.cpp", 412, __PRETTY_FUNCTION__));
>    v2=v1;
>    ((v2.capacity()==v2.getNumElements()) ? static_cast<void> (0) : __assert_fail ("v2.capacity()==v2.getNumElements()", "CoinPackedVectorTest.cpp", 414, __PRETTY_FUNCTION__));
>    ((v2.getNumElements()==8) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==8", "CoinPackedVectorTest.cpp", 415, __PRETTY_FUNCTION__));
>    ((v2==v1) ? static_cast<void> (0) : __assert_fail ("v2==v1", "CoinPackedVectorTest.cpp", 416, __PRETTY_FUNCTION__));
>
>    v1.setVector(ne1,inx1,el1);
>    ((v1.capacity()==8) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==8", "CoinPackedVectorTest.cpp", 419, __PRETTY_FUNCTION__));
>    ((v1.getNumElements()==5) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==5", "CoinPackedVectorTest.cpp", 420, __PRETTY_FUNCTION__));
>    v2=v1;
>    ((v2.capacity()==8) ? static_cast<void> (0) : __assert_fail ("v2.capacity()==8", "CoinPackedVectorTest.cpp", 422, __PRETTY_FUNCTION__));
>    ((v2.getNumElements()==5) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==5", "CoinPackedVectorTest.cpp", 423, __PRETTY_FUNCTION__));
>    ((v2==v1) ? static_cast<void> (0) : __assert_fail ("v2==v1", "CoinPackedVectorTest.cpp", 424, __PRETTY_FUNCTION__));
>
>    v1.reserve(7);
>    ((v1.capacity()==8) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==8", "CoinPackedVectorTest.cpp", 427, __PRETTY_FUNCTION__));
>    ((v1.getNumElements()==5) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==5", "CoinPackedVectorTest.cpp", 428, __PRETTY_FUNCTION__));
>    v2=v1;
>    ((v2.capacity()==8) ? static_cast<void> (0) : __assert_fail ("v2.capacity()==8", "CoinPackedVectorTest.cpp", 430, __PRETTY_FUNCTION__));
>    ((v2.getNumElements()==5) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==5", "CoinPackedVectorTest.cpp", 431, __PRETTY_FUNCTION__));
>    ((v2==v1) ? static_cast<void> (0) : __assert_fail ("v2==v1", "CoinPackedVectorTest.cpp", 432, __PRETTY_FUNCTION__));
>
>  }
>
>
>  {
>    CoinPackedVector v1(true);
>    ((v1.getNumElements()==0) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==0", "CoinPackedVectorTest.cpp", 439, __PRETTY_FUNCTION__));
>    ((v1.capacity()==0) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==0", "CoinPackedVectorTest.cpp", 440, __PRETTY_FUNCTION__));
>
>    ((!v1.isExistingIndex(1)) ? static_cast<void> (0) : __assert_fail ("!v1.isExistingIndex(1)", "CoinPackedVectorTest.cpp", 442, __PRETTY_FUNCTION__));
>    v1.insert(1,1.);
>    ((v1.getNumElements()==1) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==1", "CoinPackedVectorTest.cpp", 444, __PRETTY_FUNCTION__));
>    ((v1.capacity()==5) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==5", "CoinPackedVectorTest.cpp", 445, __PRETTY_FUNCTION__));
>    ((v1.getIndices()[0] == 1) ? static_cast<void> (0) : __assert_fail ("v1.getIndices()[0] == 1", "CoinPackedVectorTest.cpp", 446, __PRETTY_FUNCTION__));
>    ((v1.getElements()[0] == 1.) ? static_cast<void> (0) : __assert_fail ("v1.getElements()[0] == 1.", "CoinPackedVectorTest.cpp", 447, __PRETTY_FUNCTION__));
>    ((v1.isExistingIndex(1)) ? static_cast<void> (0) : __assert_fail ("v1.isExistingIndex(1)", "CoinPackedVectorTest.cpp", 448, __PRETTY_FUNCTION__));
>
>    ((!v1.isExistingIndex(10)) ? static_cast<void> (0) : __assert_fail ("!v1.isExistingIndex(10)", "CoinPackedVectorTest.cpp", 450, __PRETTY_FUNCTION__));
>    v1.insert(10,10.);
>    ((v1.getNumElements()==2) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==2", "CoinPackedVectorTest.cpp", 452, __PRETTY_FUNCTION__));
>    ((v1.capacity()==5) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==5", "CoinPackedVectorTest.cpp", 453, __PRETTY_FUNCTION__));
>    ((v1.getIndices()[1] == 10) ? static_cast<void> (0) : __assert_fail ("v1.getIndices()[1] == 10", "CoinPackedVectorTest.cpp", 454, __PRETTY_FUNCTION__));
>    ((v1.getElements()[1] == 10.) ? static_cast<void> (0) : __assert_fail ("v1.getElements()[1] == 10.", "CoinPackedVectorTest.cpp", 455, __PRETTY_FUNCTION__));
>    ((v1.isExistingIndex(1)) ? static_cast<void> (0) : __assert_fail ("v1.isExistingIndex(1)", "CoinPackedVectorTest.cpp", 456, __PRETTY_FUNCTION__));
>    ((v1.isExistingIndex(10)) ? static_cast<void> (0) : __assert_fail ("v1.isExistingIndex(10)", "CoinPackedVectorTest.cpp", 457, __PRETTY_FUNCTION__));
>
>    ((!v1.isExistingIndex(20)) ? static_cast<void> (0) : __assert_fail ("!v1.isExistingIndex(20)", "CoinPackedVectorTest.cpp", 459, __PRETTY_FUNCTION__));
>    v1.insert(20,20.);
>    ((v1.getNumElements()==3) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==3", "CoinPackedVectorTest.cpp", 461, __PRETTY_FUNCTION__));
>    ((v1.capacity()==5) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==5", "CoinPackedVectorTest.cpp", 462, __PRETTY_FUNCTION__));
>    ((v1.getIndices()[2] == 20) ? static_cast<void> (0) : __assert_fail ("v1.getIndices()[2] == 20", "CoinPackedVectorTest.cpp", 463, __PRETTY_FUNCTION__));
>    ((v1.getElements()[2] == 20.) ? static_cast<void> (0) : __assert_fail ("v1.getElements()[2] == 20.", "CoinPackedVectorTest.cpp", 464, __PRETTY_FUNCTION__));
>    ((v1.isExistingIndex(20)) ? static_cast<void> (0) : __assert_fail ("v1.isExistingIndex(20)", "CoinPackedVectorTest.cpp", 465, __PRETTY_FUNCTION__));
>
>    ((!v1.isExistingIndex(30)) ? static_cast<void> (0) : __assert_fail ("!v1.isExistingIndex(30)", "CoinPackedVectorTest.cpp", 467, __PRETTY_FUNCTION__));
>    v1.insert(30,30.);
>    ((v1.getNumElements()==4) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==4", "CoinPackedVectorTest.cpp", 469, __PRETTY_FUNCTION__));
>    ((v1.capacity()==5) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==5", "CoinPackedVectorTest.cpp", 470, __PRETTY_FUNCTION__));
>    ((v1.getIndices()[3] == 30) ? static_cast<void> (0) : __assert_fail ("v1.getIndices()[3] == 30", "CoinPackedVectorTest.cpp", 471, __PRETTY_FUNCTION__));
>    ((v1.getElements()[3] == 30.) ? static_cast<void> (0) : __assert_fail ("v1.getElements()[3] == 30.", "CoinPackedVectorTest.cpp", 472, __PRETTY_FUNCTION__));
>    ((v1.isExistingIndex(30)) ? static_cast<void> (0) : __assert_fail ("v1.isExistingIndex(30)", "CoinPackedVectorTest.cpp", 473, __PRETTY_FUNCTION__));
>
>    ((!v1.isExistingIndex(40)) ? static_cast<void> (0) : __assert_fail ("!v1.isExistingIndex(40)", "CoinPackedVectorTest.cpp", 475, __PRETTY_FUNCTION__));
>    v1.insert(40,40.);
>    ((v1.getNumElements()==5) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==5", "CoinPackedVectorTest.cpp", 477, __PRETTY_FUNCTION__));
>    ((v1.capacity()==5) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==5", "CoinPackedVectorTest.cpp", 478, __PRETTY_FUNCTION__));
>    ((v1.getIndices()[4] == 40) ? static_cast<void> (0) : __assert_fail ("v1.getIndices()[4] == 40", "CoinPackedVectorTest.cpp", 479, __PRETTY_FUNCTION__));
>    ((v1.getElements()[4] == 40.) ? static_cast<void> (0) : __assert_fail ("v1.getElements()[4] == 40.", "CoinPackedVectorTest.cpp", 480, __PRETTY_FUNCTION__));
>    ((v1.isExistingIndex(40)) ? static_cast<void> (0) : __assert_fail ("v1.isExistingIndex(40)", "CoinPackedVectorTest.cpp", 481, __PRETTY_FUNCTION__));
>
>    ((!v1.isExistingIndex(50)) ? static_cast<void> (0) : __assert_fail ("!v1.isExistingIndex(50)", "CoinPackedVectorTest.cpp", 483, __PRETTY_FUNCTION__));
>    v1.insert(50,50.);
>    ((v1.getNumElements()==6) ? static_cast<void> (0) : __assert_fail ("v1.getNumElements()==6", "CoinPackedVectorTest.cpp", 485, __PRETTY_FUNCTION__));
>    ((v1.capacity()==10) ? static_cast<void> (0) : __assert_fail ("v1.capacity()==10", "CoinPackedVectorTest.cpp", 486, __PRETTY_FUNCTION__));
>    ((v1.getIndices()[5] == 50) ? static_cast<void> (0) : __assert_fail ("v1.getIndices()[5] == 50", "CoinPackedVectorTest.cpp", 487, __PRETTY_FUNCTION__));
>    ((v1.getElements()[5] == 50.) ? static_cast<void> (0) : __assert_fail ("v1.getElements()[5] == 50.", "CoinPackedVectorTest.cpp", 488, __PRETTY_FUNCTION__));
>    ((v1.isExistingIndex(50)) ? static_cast<void> (0) : __assert_fail ("v1.isExistingIndex(50)", "CoinPackedVectorTest.cpp", 489, __PRETTY_FUNCTION__));
>
>    CoinPackedVector v2;
>    const int ne1 = 3;
>    int inx1[ne1] = { 1, 3, 4 };
>    double el1[ne1] = { 1.2, 3.4, 5. };
>    v2.setVector(ne1,inx1,el1);
>    ((v2.getNumElements()==3) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==3", "CoinPackedVectorTest.cpp", 496, __PRETTY_FUNCTION__));
>    ((v2.capacity()==3) ? static_cast<void> (0) : __assert_fail ("v2.capacity()==3", "CoinPackedVectorTest.cpp", 497, __PRETTY_FUNCTION__));
>
>  }
>
>  {
>
>    CoinPackedVector v2;
>    const int ne1 = 3;
>    int inx1[ne1] = { 1, 3, 4 };
>    v2.setConstant(ne1,inx1,3.14);
>    ((v2.getNumElements()==3) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==3", "CoinPackedVectorTest.cpp", 507, __PRETTY_FUNCTION__));
>    ((v2.capacity()==3) ? static_cast<void> (0) : __assert_fail ("v2.capacity()==3", "CoinPackedVectorTest.cpp", 508, __PRETTY_FUNCTION__));
>    ((v2.getIndices()[0]==1) ? static_cast<void> (0) : __assert_fail ("v2.getIndices()[0]==1", "CoinPackedVectorTest.cpp", 509, __PRETTY_FUNCTION__));
>    ((v2.getElements()[0]==3.14) ? static_cast<void> (0) : __assert_fail ("v2.getElements()[0]==3.14", "CoinPackedVectorTest.cpp", 510, __PRETTY_FUNCTION__));
>    ((v2.getIndices()[1]==3) ? static_cast<void> (0) : __assert_fail ("v2.getIndices()[1]==3", "CoinPackedVectorTest.cpp", 511, __PRETTY_FUNCTION__));
>    ((v2.getElements()[1]==3.14) ? static_cast<void> (0) : __assert_fail ("v2.getElements()[1]==3.14", "CoinPackedVectorTest.cpp", 512, __PRETTY_FUNCTION__));
>    ((v2.getIndices()[2]==4) ? static_cast<void> (0) : __assert_fail ("v2.getIndices()[2]==4", "CoinPackedVectorTest.cpp", 513, __PRETTY_FUNCTION__));
>    ((v2.getElements()[2]==3.14) ? static_cast<void> (0) : __assert_fail ("v2.getElements()[2]==3.14", "CoinPackedVectorTest.cpp", 514, __PRETTY_FUNCTION__));
>
>    ((v2[3] == 3.14) ? static_cast<void> (0) : __assert_fail ("v2[3] == 3.14", "CoinPackedVectorTest.cpp", 516, __PRETTY_FUNCTION__));
>
>    CoinPackedVector v2X(ne1,inx1,3.14);
>    ((v2 == v2X) ? static_cast<void> (0) : __assert_fail ("v2 == v2X", "CoinPackedVectorTest.cpp", 519, __PRETTY_FUNCTION__));
># 543 "CoinPackedVectorTest.cpp"
>  }
>
>  {
>
>    CoinPackedVector v2;
>    const int ne2 = 3;
>    double el2[ne2] = { 1., 3., 4. };
>    v2.setFull(ne2,el2);
>    ((v2.getNumElements()==3) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==3", "CoinPackedVectorTest.cpp", 551, __PRETTY_FUNCTION__));
>    ((v2.capacity()==3) ? static_cast<void> (0) : __assert_fail ("v2.capacity()==3", "CoinPackedVectorTest.cpp", 552, __PRETTY_FUNCTION__));
>    ((v2.getIndices()[0]==0) ? static_cast<void> (0) : __assert_fail ("v2.getIndices()[0]==0", "CoinPackedVectorTest.cpp", 553, __PRETTY_FUNCTION__));
>    ((v2.getElements()[0]==1.) ? static_cast<void> (0) : __assert_fail ("v2.getElements()[0]==1.", "CoinPackedVectorTest.cpp", 554, __PRETTY_FUNCTION__));
>    ((v2.getIndices()[1]==1) ? static_cast<void> (0) : __assert_fail ("v2.getIndices()[1]==1", "CoinPackedVectorTest.cpp", 555, __PRETTY_FUNCTION__));
>    ((v2.getElements()[1]==3.) ? static_cast<void> (0) : __assert_fail ("v2.getElements()[1]==3.", "CoinPackedVectorTest.cpp", 556, __PRETTY_FUNCTION__));
>    ((v2.getIndices()[2]==2) ? static_cast<void> (0) : __assert_fail ("v2.getIndices()[2]==2", "CoinPackedVectorTest.cpp", 557, __PRETTY_FUNCTION__));
>    ((v2.getElements()[2]==4.) ? static_cast<void> (0) : __assert_fail ("v2.getElements()[2]==4.", "CoinPackedVectorTest.cpp", 558, __PRETTY_FUNCTION__));
>
>    ((v2[1] == 3.) ? static_cast<void> (0) : __assert_fail ("v2[1] == 3.", "CoinPackedVectorTest.cpp", 560, __PRETTY_FUNCTION__));
>
>    CoinPackedVector v2X(ne2,el2);
>    ((v2 == v2X) ? static_cast<void> (0) : __assert_fail ("v2 == v2X", "CoinPackedVectorTest.cpp", 563, __PRETTY_FUNCTION__));
>
>    v2.setFull(0,el2);
>    ((v2[2] == 0.) ? static_cast<void> (0) : __assert_fail ("v2[2] == 0.", "CoinPackedVectorTest.cpp", 566, __PRETTY_FUNCTION__));
>
>
>    el2[1]=0.0;
>    v2.setFullNonZero(ne2,el2);
>    ((v2.getNumElements()==2) ? static_cast<void> (0) : __assert_fail ("v2.getNumElements()==2", "CoinPackedVectorTest.cpp", 571, __PRETTY_FUNCTION__));
>    ((v2.capacity()==3) ? static_cast<void> (0) : __assert_fail ("v2.capacity()==3", "CoinPackedVectorTest.cpp", 572, __PRETTY_FUNCTION__));
>    ((v2.getIndices()[0]==0) ? static_cast<void> (0) : __assert_fail ("v2.getIndices()[0]==0", "CoinPackedVectorTest.cpp", 573, __PRETTY_FUNCTION__));
>    ((v2.getElements()[0]==1.) ? static_cast<void> (0) : __assert_fail ("v2.getElements()[0]==1.", "CoinPackedVectorTest.cpp", 574, __PRETTY_FUNCTION__));
>    ((v2.getIndices()[1]==2) ? static_cast<void> (0) : __assert_fail ("v2.getIndices()[1]==2", "CoinPackedVectorTest.cpp", 575, __PRETTY_FUNCTION__));
>    ((v2.getElements()[1]==4.) ? static_cast<void> (0) : __assert_fail ("v2.getElements()[1]==4.", "CoinPackedVectorTest.cpp", 576, __PRETTY_FUNCTION__));
>
>    ((v2[1] == 0.) ? static_cast<void> (0) : __assert_fail ("v2[1] == 0.", "CoinPackedVectorTest.cpp", 578, __PRETTY_FUNCTION__));
>
>    CoinPackedVector v2Y(ne2,el2);
>    ((v2 != v2Y) ? static_cast<void> (0) : __assert_fail ("v2 != v2Y", "CoinPackedVectorTest.cpp", 581, __PRETTY_FUNCTION__));
>    ((v2 != v2X) ? static_cast<void> (0) : __assert_fail ("v2 != v2X", "CoinPackedVectorTest.cpp", 582, __PRETTY_FUNCTION__));
>
>  }
># 600 "CoinPackedVectorTest.cpp"
>  {
>    const int ne1 = 5;
>    int inx1[ne1] = { 1, 3, 4, 7, 5 };
>    double el1[ne1] = { 1., 5., 6., 2., 9. };
>    const int ne2 = 4;
>    int inx2[ne2] = { 7, 4, 2, 1 };
>    double el2[ne2] = { 7., 4., 2., 1. };
>
>    CoinPackedVector v1;
>    CoinPackedVector v2;
>    CoinPackedVector r ;
>    CoinPackedVector rV ;
>
>    v1.setVector(ne1,inx1,el1);
>
>    rV.setVector(ne1,inx1,el1) ;
>    r = v1 + v2 ;
>    ((r.isEquivalent(rV)) ? static_cast<void> (0) : __assert_fail ("r.isEquivalent(rV)", "CoinPackedVectorTest.cpp", 617, __PRETTY_FUNCTION__)) ;
>    r = v2 + v1 ;
>    ((r.isEquivalent(rV)) ? static_cast<void> (0) : __assert_fail ("r.isEquivalent(rV)", "CoinPackedVectorTest.cpp", 619, __PRETTY_FUNCTION__)) ;
>
>    v2.setVector(ne2,inx2,el2);
>    r = v1 + v2 ;
>    const int ner = 6;
>    int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
>    double elr[ner] = { 1.+1., 0.+2., 5.+0., 6.+4., 9.+0., 2.+7. };
>    rV.setVector(ner,inxr,elr);
>    ((r.isEquivalent(rV)) ? static_cast<void> (0) : __assert_fail ("r.isEquivalent(rV)", "CoinPackedVectorTest.cpp", 627, __PRETTY_FUNCTION__));
>
>  }
>
>
>
>  {
>    const int ne1 = 5;
>    int inx1[ne1] = { 1, 3, 4, 7, 5 };
>    double el1[ne1] = { 1., 5., 6., 2., 9. };
>    const int ne2 = 4;
>    int inx2[ne2] = { 7, 4, 2, 1 };
>    double el2[ne2] = { 7., 4., 2., 1. };
>    CoinPackedVector v1;
>    v1.setVector(ne1,inx1,el1);
>    CoinPackedVector v2;
>    v2.setVector(ne2,inx2,el2);
>    CoinPackedVector r = v1 - v2;
>
>    const int ner = 6;
>    int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
>    double elr[ner] = { 1.-1., 0.-2., 5.-0., 6.-4., 9.-0., 2.-7. };
>    CoinPackedVector rV;
>    rV.setVector(ner,inxr,elr);
>    ((r.isEquivalent(rV)) ? static_cast<void> (0) : __assert_fail ("r.isEquivalent(rV)", "CoinPackedVectorTest.cpp", 651, __PRETTY_FUNCTION__));
>  }
>
>
>
>  {
>    const int ne1 = 5;
>    int inx1[ne1] = { 1, 3, 4, 7, 5 };
>    double el1[ne1] = { 1., 5., 6., 2., 9. };
>    const int ne2 = 4;
>    int inx2[ne2] = { 7, 4, 2, 1 };
>    double el2[ne2] = { 7., 4., 2., 1. };
>    CoinPackedVector v1;
>    v1.setVector(ne1,inx1,el1);
>    CoinPackedVector v2;
>    v2.setVector(ne2,inx2,el2);
>    CoinPackedVector r = v1 * v2;
>
>    const int ner = 6;
>    int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
>    double elr[ner] = { 1.*1., 0.*2., 5.*0., 6.*4., 9.*0., 2.*7. };
>    CoinPackedVector rV;
>    rV.setVector(ner,inxr,elr);
>    ((r.isEquivalent(rV)) ? static_cast<void> (0) : __assert_fail ("r.isEquivalent(rV)", "CoinPackedVectorTest.cpp", 674, __PRETTY_FUNCTION__));
>  }
>
>
>
>
>  {
>    const int ne1 = 3;
>    int inx1[ne1] = { 1, 4, 7 };
>    double el1[ne1] = { 1., 6., 2. };
>    const int ne2 = 4;
>    int inx2[ne2] = { 7, 4, 2, 1 };
>    double el2[ne2] = { 7., 4., 2., 1. };
>
>
>    double one = 1.0 ;
>    double zero = 0.0 ;
>    double infty = one/zero ;
>
>
>
>
>    CoinPackedVector v1;
>    CoinPackedVector v2;
>    CoinPackedVector r ;
>    CoinPackedVector rV;
>
>    v1.setVector(ne1,inx1,el1) ;
>    rV.setConstant(ne1,inx1,0) ;
>    r = v2 / v1;
>    ((r.isEquivalent(rV)) ? static_cast<void> (0) : __assert_fail ("r.isEquivalent(rV)", "CoinPackedVectorTest.cpp", 704, __PRETTY_FUNCTION__)) ;
>    rV.setConstant(ne1,inx1,infty) ;
>    r = v1 / v2;
>    ((r.isEquivalent(rV)) ? static_cast<void> (0) : __assert_fail ("r.isEquivalent(rV)", "CoinPackedVectorTest.cpp", 707, __PRETTY_FUNCTION__)) ;
>
>    r.isEquivalent(rV) ;
>
>    v2.setVector(ne2,inx2,el2);
>    r = v1 / v2;
>
>    const int ner = 4;
>    int inxr[ner] = { 1, 2, 4, 7 };
>    double elr[ner] = { 1./1., 0./2., 6./4., 2./7. };
>    rV.setVector(ner,inxr,elr);
>    ((r.isEquivalent(rV)) ? static_cast<void> (0) : __assert_fail ("r.isEquivalent(rV)", "CoinPackedVectorTest.cpp", 718, __PRETTY_FUNCTION__));
>  }
>
>
>  {
>    CoinPackedVector s;
>    ((s.sum() == 0) ? static_cast<void> (0) : __assert_fail ("s.sum() == 0", "CoinPackedVectorTest.cpp", 724, __PRETTY_FUNCTION__));
>
>    s.insert(25,45.);
>    ((s.sum()==45.) ? static_cast<void> (0) : __assert_fail ("s.sum()==45.", "CoinPackedVectorTest.cpp", 727, __PRETTY_FUNCTION__));
>
>    const int ne1 = 5;
>    int inx1[ne1] = { 10, 3, 4, 7, 5 };
>    double el1[ne1] = { 1., 5., 6., 2., 9. };
>    s.setVector(ne1,inx1,el1);
>
>    ((s.sum()==1.+5.+6.+2.+9.) ? static_cast<void> (0) : __assert_fail ("s.sum()==1.+5.+6.+2.+9.", "CoinPackedVectorTest.cpp", 734, __PRETTY_FUNCTION__));
>  }
>
>
>  {
>
>    const int ne1 = 2;
>    int inx1[ne1] = { 1, 4 };
>    double el1[ne1] = { 1., 6. };
>    CoinPackedVector v1(ne1,inx1,el1);
>
>
>    const int ne2 = 3;
>    int inx2[ne2] = { 1, 2, 4 };
>    double el2[ne2] = { 1., 7., 4.};
>    CoinPackedVector v2(ne2,inx2,el2);
>
>
>    CoinPackedVector ratio = v1 / v2;
>
>
>    ratio.sortIncrElement();
>
>
>    ((ratio.getElements()[0] == 0.0/7.0) ? static_cast<void> (0) : __assert_fail ("ratio.getElements()[0] == 0.0/7.0", "CoinPackedVectorTest.cpp", 758, __PRETTY_FUNCTION__));
>    ((ratio.getElements()[1] == 1.0/1.0) ? static_cast<void> (0) : __assert_fail ("ratio.getElements()[1] == 1.0/1.0", "CoinPackedVectorTest.cpp", 759, __PRETTY_FUNCTION__));
>    ((ratio.getElements()[2] == 6.0/4.0) ? static_cast<void> (0) : __assert_fail ("ratio.getElements()[2] == 6.0/4.0", "CoinPackedVectorTest.cpp", 760, __PRETTY_FUNCTION__));
>
>
>    ((v1[ ratio.getIndices()[0] ] == 0.0) ? static_cast<void> (0) : __assert_fail ("v1[ ratio.getIndices()[0] ] == 0.0", "CoinPackedVectorTest.cpp", 763, __PRETTY_FUNCTION__));
>    ((v1[ ratio.getIndices()[1] ] == 1.0) ? static_cast<void> (0) : __assert_fail ("v1[ ratio.getIndices()[1] ] == 1.0", "CoinPackedVectorTest.cpp", 764, __PRETTY_FUNCTION__));
>    ((v1[ ratio.getIndices()[2] ] == 6.0) ? static_cast<void> (0) : __assert_fail ("v1[ ratio.getIndices()[2] ] == 6.0", "CoinPackedVectorTest.cpp", 765, __PRETTY_FUNCTION__));
>
>
>    ((v2[ ratio.getIndices()[0] ] == 7.0) ? static_cast<void> (0) : __assert_fail ("v2[ ratio.getIndices()[0] ] == 7.0", "CoinPackedVectorTest.cpp", 768, __PRETTY_FUNCTION__));
>    ((v2[ ratio.getIndices()[1] ] == 1.0) ? static_cast<void> (0) : __assert_fail ("v2[ ratio.getIndices()[1] ] == 1.0", "CoinPackedVectorTest.cpp", 769, __PRETTY_FUNCTION__));
>    ((v2[ ratio.getIndices()[2] ] == 4.0) ? static_cast<void> (0) : __assert_fail ("v2[ ratio.getIndices()[2] ] == 4.0", "CoinPackedVectorTest.cpp", 770, __PRETTY_FUNCTION__));
>  }
>
>
>  {
>    const int ne = 4;
>    int inx[ne] = { 1, 4, 0, 2 };
>    double el[ne] = { 10., 40., 1., 50. };
>    CoinPackedVector std(ne,inx,el);
>    CoinShallowPackedVector * spvP = new CoinShallowPackedVector(ne,inx,el);
>    CoinPackedVector pv(*spvP);
>    ((pv == std) ? static_cast<void> (0) : __assert_fail ("pv == std", "CoinPackedVectorTest.cpp", 781, __PRETTY_FUNCTION__));
>    ((pv.isEquivalent(std)) ? static_cast<void> (0) : __assert_fail ("pv.isEquivalent(std)", "CoinPackedVectorTest.cpp", 782, __PRETTY_FUNCTION__));
>    delete spvP;
>    ((pv == std) ? static_cast<void> (0) : __assert_fail ("pv == std", "CoinPackedVectorTest.cpp", 784, __PRETTY_FUNCTION__));
>    ((pv.isEquivalent(std)) ? static_cast<void> (0) : __assert_fail ("pv.isEquivalent(std)", "CoinPackedVectorTest.cpp", 785, __PRETTY_FUNCTION__));
>    pv.sortIncrElement();
>    ((pv != std) ? static_cast<void> (0) : __assert_fail ("pv != std", "CoinPackedVectorTest.cpp", 787, __PRETTY_FUNCTION__));
>    ((pv.isEquivalent(std)) ? static_cast<void> (0) : __assert_fail ("pv.isEquivalent(std)", "CoinPackedVectorTest.cpp", 788, __PRETTY_FUNCTION__));
>  }
>
>
>  {
>    const int ne = 4;
>    int inx[ne] = { 1, 4, 0, 2 };
>    double el[ne] = { 10., 40., 1., 50. };
>    CoinPackedVector std(ne,inx,el);
>    CoinShallowPackedVector * spvP = new CoinShallowPackedVector(ne,inx,el);
>    CoinPackedVector pv;
>    pv = *spvP;
>    ((pv == std) ? static_cast<void> (0) : __assert_fail ("pv == std", "CoinPackedVectorTest.cpp", 800, __PRETTY_FUNCTION__));
>    ((pv.isEquivalent(std)) ? static_cast<void> (0) : __assert_fail ("pv.isEquivalent(std)", "CoinPackedVectorTest.cpp", 801, __PRETTY_FUNCTION__));
>    delete spvP;
>    ((pv == std) ? static_cast<void> (0) : __assert_fail ("pv == std", "CoinPackedVectorTest.cpp", 803, __PRETTY_FUNCTION__));
>    ((pv.isEquivalent(std)) ? static_cast<void> (0) : __assert_fail ("pv.isEquivalent(std)", "CoinPackedVectorTest.cpp", 804, __PRETTY_FUNCTION__));
>    pv.sortIncrElement();
>    ((pv != std) ? static_cast<void> (0) : __assert_fail ("pv != std", "CoinPackedVectorTest.cpp", 806, __PRETTY_FUNCTION__));
>    ((pv.isEquivalent(std)) ? static_cast<void> (0) : __assert_fail ("pv.isEquivalent(std)", "CoinPackedVectorTest.cpp", 807, __PRETTY_FUNCTION__));
>  }
>
>  {
>
>
>    const int ne = 4;
>    int inx[ne] = { 1, 4, 0, 2 };
>    double el[ne] = { 10., 40., 1., 50. };
>    CoinPackedVector r(ne,inx,el);
>
>    ((r.getIndices()[0]== 1) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[0]== 1", "CoinPackedVectorTest.cpp", 818, __PRETTY_FUNCTION__));
>    ((r.getElements()[0]==10.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[0]==10.", "CoinPackedVectorTest.cpp", 819, __PRETTY_FUNCTION__));
>    ((r.getIndices()[1]== 4) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[1]== 4", "CoinPackedVectorTest.cpp", 820, __PRETTY_FUNCTION__));
>    ((r.getElements()[1]==40.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[1]==40.", "CoinPackedVectorTest.cpp", 821, __PRETTY_FUNCTION__));
>    ((r.getIndices()[2]== 0) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[2]== 0", "CoinPackedVectorTest.cpp", 822, __PRETTY_FUNCTION__));
>    ((r.getElements()[2]== 1.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[2]== 1.", "CoinPackedVectorTest.cpp", 823, __PRETTY_FUNCTION__));
>    ((r.getIndices()[3]== 2) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[3]== 2", "CoinPackedVectorTest.cpp", 824, __PRETTY_FUNCTION__));
>    ((r.getElements()[3]==50.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[3]==50.", "CoinPackedVectorTest.cpp", 825, __PRETTY_FUNCTION__));
>
>    ((r.getOriginalPosition()[0]==0) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[0]==0", "CoinPackedVectorTest.cpp", 827, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[1]==1) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[1]==1", "CoinPackedVectorTest.cpp", 828, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[2]==2) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[2]==2", "CoinPackedVectorTest.cpp", 829, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[3]==3) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[3]==3", "CoinPackedVectorTest.cpp", 830, __PRETTY_FUNCTION__));
>
>    ((r[ 0]==1.) ? static_cast<void> (0) : __assert_fail ("r[ 0]==1.", "CoinPackedVectorTest.cpp", 832, __PRETTY_FUNCTION__));
>    ((r[ 1]==10.) ? static_cast<void> (0) : __assert_fail ("r[ 1]==10.", "CoinPackedVectorTest.cpp", 833, __PRETTY_FUNCTION__));
>    ((r[ 2]==50.) ? static_cast<void> (0) : __assert_fail ("r[ 2]==50.", "CoinPackedVectorTest.cpp", 834, __PRETTY_FUNCTION__));
>    ((r[ 3]==0.) ? static_cast<void> (0) : __assert_fail ("r[ 3]==0.", "CoinPackedVectorTest.cpp", 835, __PRETTY_FUNCTION__));
>    ((r[ 4]==40.) ? static_cast<void> (0) : __assert_fail ("r[ 4]==40.", "CoinPackedVectorTest.cpp", 836, __PRETTY_FUNCTION__));
>
>    r.sortIncrElement();
>
>    ((r.getIndices()[0]== 0) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[0]== 0", "CoinPackedVectorTest.cpp", 840, __PRETTY_FUNCTION__));
>    ((r.getElements()[0]== 1.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[0]== 1.", "CoinPackedVectorTest.cpp", 841, __PRETTY_FUNCTION__));
>    ((r.getIndices()[1]== 1) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[1]== 1", "CoinPackedVectorTest.cpp", 842, __PRETTY_FUNCTION__));
>    ((r.getElements()[1]==10.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[1]==10.", "CoinPackedVectorTest.cpp", 843, __PRETTY_FUNCTION__));
>    ((r.getIndices()[2]== 4) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[2]== 4", "CoinPackedVectorTest.cpp", 844, __PRETTY_FUNCTION__));
>    ((r.getElements()[2]==40.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[2]==40.", "CoinPackedVectorTest.cpp", 845, __PRETTY_FUNCTION__));
>    ((r.getIndices()[3]== 2) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[3]== 2", "CoinPackedVectorTest.cpp", 846, __PRETTY_FUNCTION__));
>    ((r.getElements()[3]==50.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[3]==50.", "CoinPackedVectorTest.cpp", 847, __PRETTY_FUNCTION__));
>
>    ((r.getOriginalPosition()[0]==2) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[0]==2", "CoinPackedVectorTest.cpp", 849, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[1]==0) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[1]==0", "CoinPackedVectorTest.cpp", 850, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[2]==1) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[2]==1", "CoinPackedVectorTest.cpp", 851, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[3]==3) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[3]==3", "CoinPackedVectorTest.cpp", 852, __PRETTY_FUNCTION__));
>
>    ((r[ 0]==1.) ? static_cast<void> (0) : __assert_fail ("r[ 0]==1.", "CoinPackedVectorTest.cpp", 854, __PRETTY_FUNCTION__));
>    ((r[ 1]==10.) ? static_cast<void> (0) : __assert_fail ("r[ 1]==10.", "CoinPackedVectorTest.cpp", 855, __PRETTY_FUNCTION__));
>    ((r[ 2]==50.) ? static_cast<void> (0) : __assert_fail ("r[ 2]==50.", "CoinPackedVectorTest.cpp", 856, __PRETTY_FUNCTION__));
>    ((r[ 3]==0.) ? static_cast<void> (0) : __assert_fail ("r[ 3]==0.", "CoinPackedVectorTest.cpp", 857, __PRETTY_FUNCTION__));
>    ((r[ 4]==40.) ? static_cast<void> (0) : __assert_fail ("r[ 4]==40.", "CoinPackedVectorTest.cpp", 858, __PRETTY_FUNCTION__));
>
>    r.sortOriginalOrder();
>
>    ((r.getIndices()[0]== 1) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[0]== 1", "CoinPackedVectorTest.cpp", 862, __PRETTY_FUNCTION__));
>    ((r.getElements()[0]==10.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[0]==10.", "CoinPackedVectorTest.cpp", 863, __PRETTY_FUNCTION__));
>    ((r.getIndices()[1]== 4) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[1]== 4", "CoinPackedVectorTest.cpp", 864, __PRETTY_FUNCTION__));
>    ((r.getElements()[1]==40.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[1]==40.", "CoinPackedVectorTest.cpp", 865, __PRETTY_FUNCTION__));
>    ((r.getIndices()[2]== 0) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[2]== 0", "CoinPackedVectorTest.cpp", 866, __PRETTY_FUNCTION__));
>    ((r.getElements()[2]== 1.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[2]== 1.", "CoinPackedVectorTest.cpp", 867, __PRETTY_FUNCTION__));
>    ((r.getIndices()[3]== 2) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[3]== 2", "CoinPackedVectorTest.cpp", 868, __PRETTY_FUNCTION__));
>    ((r.getElements()[3]==50.) ? static_cast<void> (0) : __assert_fail ("r.getElements()[3]==50.", "CoinPackedVectorTest.cpp", 869, __PRETTY_FUNCTION__));
>
>    CoinPackedVector r1;
>    r1=r;
>    ((r==r1) ? static_cast<void> (0) : __assert_fail ("r==r1", "CoinPackedVectorTest.cpp", 873, __PRETTY_FUNCTION__));
>    ((r.isEquivalent(r1)) ? static_cast<void> (0) : __assert_fail ("r.isEquivalent(r1)", "CoinPackedVectorTest.cpp", 874, __PRETTY_FUNCTION__));
>    r.sortIncrElement();
>    ((r!=r1) ? static_cast<void> (0) : __assert_fail ("r!=r1", "CoinPackedVectorTest.cpp", 876, __PRETTY_FUNCTION__));
>    ((r.isEquivalent(r1)) ? static_cast<void> (0) : __assert_fail ("r.isEquivalent(r1)", "CoinPackedVectorTest.cpp", 877, __PRETTY_FUNCTION__));
>
>    CoinPackedVector add = r + r1;
>    ((add[0] == 1.+ 1.) ? static_cast<void> (0) : __assert_fail ("add[0] == 1.+ 1.", "CoinPackedVectorTest.cpp", 880, __PRETTY_FUNCTION__));
>    ((add[1] == 10.+10.) ? static_cast<void> (0) : __assert_fail ("add[1] == 10.+10.", "CoinPackedVectorTest.cpp", 881, __PRETTY_FUNCTION__));
>    ((add[2] == 50.+50.) ? static_cast<void> (0) : __assert_fail ("add[2] == 50.+50.", "CoinPackedVectorTest.cpp", 882, __PRETTY_FUNCTION__));
>    ((add[3] == 0.+ 0.) ? static_cast<void> (0) : __assert_fail ("add[3] == 0.+ 0.", "CoinPackedVectorTest.cpp", 883, __PRETTY_FUNCTION__));
>    ((add[4] == 40.+40.) ? static_cast<void> (0) : __assert_fail ("add[4] == 40.+40.", "CoinPackedVectorTest.cpp", 884, __PRETTY_FUNCTION__));
>
>    ((r.sum() == 10.+40.+1.+50.) ? static_cast<void> (0) : __assert_fail ("r.sum() == 10.+40.+1.+50.", "CoinPackedVectorTest.cpp", 886, __PRETTY_FUNCTION__));
>  }
>
>  {
>
>    const int ne = 4;
>    int inx[ne] = { 1, -4, 0, 2 };
>    double el[ne] = { 10., 40., 1., 50. };
>    CoinPackedVector r(ne,inx,el);
>
>    ((r.findIndex(2) == 3) ? static_cast<void> (0) : __assert_fail ("r.findIndex(2) == 3", "CoinPackedVectorTest.cpp", 896, __PRETTY_FUNCTION__));
>    ((r.findIndex(0) == 2) ? static_cast<void> (0) : __assert_fail ("r.findIndex(0) == 2", "CoinPackedVectorTest.cpp", 897, __PRETTY_FUNCTION__));
>    ((r.findIndex(-4) == 1) ? static_cast<void> (0) : __assert_fail ("r.findIndex(-4) == 1", "CoinPackedVectorTest.cpp", 898, __PRETTY_FUNCTION__));
>    ((r.findIndex(1) == 0) ? static_cast<void> (0) : __assert_fail ("r.findIndex(1) == 0", "CoinPackedVectorTest.cpp", 899, __PRETTY_FUNCTION__));
>    ((r.findIndex(3) == -1) ? static_cast<void> (0) : __assert_fail ("r.findIndex(3) == -1", "CoinPackedVectorTest.cpp", 900, __PRETTY_FUNCTION__));
>  }
># 938 "CoinPackedVectorTest.cpp"
>  { const int neo = ne;
>    int *inxo = new int[neo];
>    double *elo = new double[neo];
>
>    for (i = 0 ; i < neo ; i++) inxo[i] = inx[i] ;
>    for (i = 0 ; i < neo ; i++) elo[i] = el[i] ;
>
>    CoinPackedVector r(neo,neo,inxo,elo);
>    ((inxo == __null) ? static_cast<void> (0) : __assert_fail ("inxo == __null", "CoinPackedVectorTest.cpp", 946, __PRETTY_FUNCTION__)) ;
>    ((elo == __null) ? static_cast<void> (0) : __assert_fail ("elo == __null", "CoinPackedVectorTest.cpp", 947, __PRETTY_FUNCTION__)) ;
>
>
>    ((r.getNumElements()==ne) ? static_cast<void> (0) : __assert_fail ("r.getNumElements()==ne", "CoinPackedVectorTest.cpp", 950, __PRETTY_FUNCTION__));
>    for ( i=0; i<ne; i++ ) {
>      ((r.getIndices()[i] == inx[i]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[i] == inx[i]", "CoinPackedVectorTest.cpp", 952, __PRETTY_FUNCTION__));
>      ((r.getOriginalPosition()[i] == i) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[i] == i", "CoinPackedVectorTest.cpp", 953, __PRETTY_FUNCTION__));
>      ((r.getElements()[i] == el[i]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[i] == el[i]", "CoinPackedVectorTest.cpp", 954, __PRETTY_FUNCTION__));
>    }
>    ((r.getMaxIndex()==7) ? static_cast<void> (0) : __assert_fail ("r.getMaxIndex()==7", "CoinPackedVectorTest.cpp", 956, __PRETTY_FUNCTION__));
>    ((r.getMinIndex()==1) ? static_cast<void> (0) : __assert_fail ("r.getMinIndex()==1", "CoinPackedVectorTest.cpp", 957, __PRETTY_FUNCTION__));
>
>
>    const int ne2 = 5;
>    int inx2[ne2] = { 2, 4, 8, 14, 3 };
>    double el2[ne2] = { 2.2, 4.4, 6.6, 8.8, 3.3 };
>
>    r.setVector(ne2,inx2,el2);
>
>    ((r.getNumElements()==ne2) ? static_cast<void> (0) : __assert_fail ("r.getNumElements()==ne2", "CoinPackedVectorTest.cpp", 966, __PRETTY_FUNCTION__));
>
>    ((r.getIndices()[0]==inx2[0]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[0]==inx2[0]", "CoinPackedVectorTest.cpp", 968, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[0]==0) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[0]==0", "CoinPackedVectorTest.cpp", 969, __PRETTY_FUNCTION__));
>    ((r.getElements()[0]==el2[0]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[0]==el2[0]", "CoinPackedVectorTest.cpp", 970, __PRETTY_FUNCTION__));
>
>    ((r.getIndices()[1]==inx2[1]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[1]==inx2[1]", "CoinPackedVectorTest.cpp", 972, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[1]==1) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[1]==1", "CoinPackedVectorTest.cpp", 973, __PRETTY_FUNCTION__));
>    ((r.getElements()[1]==el2[1]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[1]==el2[1]", "CoinPackedVectorTest.cpp", 974, __PRETTY_FUNCTION__));
>
>    ((r.getIndices()[2]==inx2[2]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[2]==inx2[2]", "CoinPackedVectorTest.cpp", 976, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[2]==2) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[2]==2", "CoinPackedVectorTest.cpp", 977, __PRETTY_FUNCTION__));
>    ((r.getElements()[2]==el2[2]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[2]==el2[2]", "CoinPackedVectorTest.cpp", 978, __PRETTY_FUNCTION__));
>
>    ((r.getIndices()[3]==inx2[3]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[3]==inx2[3]", "CoinPackedVectorTest.cpp", 980, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[3]==3) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[3]==3", "CoinPackedVectorTest.cpp", 981, __PRETTY_FUNCTION__));
>    ((r.getElements()[3]==el2[3]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[3]==el2[3]", "CoinPackedVectorTest.cpp", 982, __PRETTY_FUNCTION__));
>
>    ((r.getIndices()[4]==inx2[4]) ? static_cast<void> (0) : __assert_fail ("r.getIndices()[4]==inx2[4]", "CoinPackedVectorTest.cpp", 984, __PRETTY_FUNCTION__));
>    ((r.getOriginalPosition()[4]==4) ? static_cast<void> (0) : __assert_fail ("r.getOriginalPosition()[4]==4", "CoinPackedVectorTest.cpp", 985, __PRETTY_FUNCTION__));
>    ((r.getElements()[4]==el2[4]) ? static_cast<void> (0) : __assert_fail ("r.getElements()[4]==el2[4]", "CoinPackedVectorTest.cpp", 986, __PRETTY_FUNCTION__));
>
>    ((r.getMaxIndex()==14) ? static_cast<void> (0) : __assert_fail ("r.getMaxIndex()==14", "CoinPackedVectorTest.cpp", 988, __PRETTY_FUNCTION__));
>    ((r.getMinIndex()==2) ? static_cast<void> (0) : __assert_fail ("r.getMinIndex()==2", "CoinPackedVectorTest.cpp", 989, __PRETTY_FUNCTION__));
>    ((r.getMaxIndex()==14) ? static_cast<void> (0) : __assert_fail ("r.getMaxIndex()==14", "CoinPackedVectorTest.cpp", 990, __PRETTY_FUNCTION__));
>    ((r.getMinIndex()==2) ? static_cast<void> (0) : __assert_fail ("r.getMinIndex()==2", "CoinPackedVectorTest.cpp", 991, __PRETTY_FUNCTION__));
>    {
>      bool errorThrown = false;
>      try {
>        r.duplicateIndex();
>      }
>      catch (CoinError e) {
>        errorThrown = true;
>      }
>      ((!errorThrown) ? static_cast<void> (0) : __assert_fail ("!errorThrown", "CoinPackedVectorTest.cpp", 1000, __PRETTY_FUNCTION__));
>    }
>
>    CoinPackedVector r1(ne2,inx2,el2,true);
>    ((r == r1) ? static_cast<void> (0) : __assert_fail ("r == r1", "CoinPackedVectorTest.cpp", 1004, __PRETTY_FUNCTION__));
>
>
>
>    {
>      const int ne3 = 4;
>      int inx3[ne3] = { 2, 4, 2, 3 };
>      double el3[ne3] = { 2.2, 4.4, 8.8, 6.6 };
>      bool errorThrown = false;
>      try {
> r.setVector(ne3,inx3,el3,true);
>      }
>      catch (CoinError e) {
>  errorThrown = true;
>      }
>      ((errorThrown) ? static_cast<void> (0) : __assert_fail ("errorThrown", "CoinPackedVectorTest.cpp", 1019, __PRETTY_FUNCTION__));
>
>      errorThrown = false;
>      try {
>  r.duplicateIndex();
>      }
>      catch (CoinError e) {
>  errorThrown = true;
>      }
>      ((errorThrown) ? static_cast<void> (0) : __assert_fail ("errorThrown", "CoinPackedVectorTest.cpp", 1028, __PRETTY_FUNCTION__));
>    }
>
>
>
>
>    r.setVector(ne2,inx2,el2);
>    bool incr=true;
>    for ( i=1; i<ne2; i++ )
>       if ( r.getElements()[i-1]>r.getElements()[i] )
>   incr=false;
>    ((!incr) ? static_cast<void> (0) : __assert_fail ("!incr", "CoinPackedVectorTest.cpp", 1039, __PRETTY_FUNCTION__));
>    r.sortIncrElement();
>    incr = true;
>    for ( i=1; i<ne2; i++ )
>       if ( r.getElements()[i-1]>r.getElements()[i] )
>   incr=false;
>    ((incr) ? static_cast<void> (0) : __assert_fail ("incr", "CoinPackedVectorTest.cpp", 1045, __PRETTY_FUNCTION__));
>
>  }
>
>}

Actions: View

Attachments on bug 909569: 695473