template< class T >
  class Vector
  {
    public : 
    Vector() ;
    Vector(const Vector< T > &) ;
    Vector(const T &) ;
    inline T &operator[](const int ) ;
    inline T operator[](const int ) const ;
    template< class INDABLE_t0h, class IELT_t0h, class NELT_t0h >
      inline void um_map_1u(T (*argmapfun)(const int &, const T &, const IELT_t0h &, const NELT_t0h &), const INDABLE_t0h &INDABLE_iav0h, const NELT_t0h &NELT_nev0h) ;
    inline void operator+=(const Vector< T > &) ;
    inline void operator+=(const T &) ;
    inline void operator-=(const Vector< T > &) ;
    inline void operator-=(const T &) ;
    inline void operator*=(const Vector< T > &) ;
    inline void operator*=(const T &) ;
    inline void operator/=(const Vector< T > &) ;
    inline void operator/=(const T &) ;
    ;
    private : 
    T data[VSIZE];
  };

template< class T >
  inline Vector< T > operator+(const Vector< T > &y_0, const Vector< T > &z_0) 
  {
    Vector< T > a_1 = y_0;
    (a_1 . operator+=)(z_0);
    return a_1;
  }

template< class T >
  inline Vector< T > operator+(const Vector< T > &b_1, const T &c_1) 
  {
    Vector< T > d_1 = b_1;
    (d_1 . operator+=)(c_1);
    return d_1;
  }

template< class T >
  inline Vector< T > operator-(const Vector< T > &e_1, const Vector< T > &f_1) 
  {
    Vector< T > g_1 = e_1;
    (g_1 . operator-=)(f_1);
    return g_1;
  }

template< class T >
  inline Vector< T > operator-(const Vector< T > &h_1, const T &i_1) 
  {
    Vector< T > j_1 = h_1;
    (j_1 . operator-=)(i_1);
    return j_1;
  }

template< class T >
  inline Vector< T > operator*(const Vector< T > &k_1, const Vector< T > &l_1) 
  {
    Vector< T > m_1 = k_1;
    (m_1 . operator*=)(l_1);
    return m_1;
  }

template< class T >
  inline Vector< T > operator*(const Vector< T > &n_1, const T &o_1) 
  {
    Vector< T > p_1 = n_1;
    (p_1 . operator*=)(o_1);
    return p_1;
  }

template< class T >
  inline Vector< T > operator/(const Vector< T > &q_1, const Vector< T > &r_1) 
  {
    Vector< T > s_1 = q_1;
    (s_1 . operator/=)(r_1);
    return s_1;
  }

template< class T >
  inline Vector< T > operator/(const Vector< T > &t_1, const T &u_1) 
  {
    Vector< T > v_1 = t_1;
    (v_1 . operator/=)(u_1);
    return v_1;
  }

template< class T >
  Vector< T >::Vector() 
  {
    
  }

template< class T >
  inline Vector< T >::Vector(const Vector< T > &v) 
  {
    for (int i = 0;(i < VSIZE);(i ++))
      (data[i] = (v . data)[i]);
  }

template< class T >
  inline Vector< T >::Vector(const T &e) 
  {
    for (int i = 0;(i < VSIZE);(i ++))
      (data[i] = e);
  }

template< class T >
  inline T &Vector< T >::operator[](const int i) 
  {
    return data[i];
  }

template< class T >
  inline T Vector< T >::operator[](const int i) const 
  {
    return data[i];
  }

template< class T >
  template< class INDABLE_t0h, class IELT_t0h, class NELT_t0h >
    inline void Vector< T >::um_map_1u(T (*argmapfun)(const int &, const T &, const IELT_t0h &, const NELT_t0h &), const INDABLE_t0h &INDABLE_iav0h, const NELT_t0h &NELT_nev0h) 
    {
      for (int i = 0;(i < VSIZE);(i ++))
        (data[i] = argmapfun(i, data[i], INDABLE_iav0h[i], NELT_nev0h));
    }

template< class T >
  inline void Vector< T >::operator+=(const T &e) 
  {
    for (int i = 0;(i < VSIZE);(i ++))
      (data[i] += e);
  }

template< class T >
  inline void Vector< T >::operator-=(const T &e) 
  {
    for (int i = 0;(i < VSIZE);(i ++))
      (data[i] -= e);
  }

template< class T >
  inline void Vector< T >::operator*=(const T &e) 
  {
    for (int i = 0;(i < VSIZE);(i ++))
      (data[i] *= e);
  }

template< class T >
  inline void Vector< T >::operator/=(const T &e) 
  {
    for (int i = 0;(i < VSIZE);(i ++))
      (data[i] /= e);
  }

template< class T >
  inline void Vector< T >::operator+=(const Vector< T > &a) 
  {
    for (int i = 0;(i < VSIZE);(i ++))
      (data[i] += a[i]);
  }

template< class T >
  inline void Vector< T >::operator-=(const Vector< T > &a) 
  {
    for (int i = 0;(i < VSIZE);(i ++))
      (data[i] -= a[i]);
  }

template< class T >
  inline void Vector< T >::operator*=(const Vector< T > &a) 
  {
    for (int i = 0;(i < VSIZE);(i ++))
      (data[i] *= a[i]);
  }

template< class T >
  inline void Vector< T >::operator/=(const Vector< T > &a) 
  {
    for (int i = 0;(i < VSIZE);(i ++))
      (data[i] /= a[i]);
  }