template<typename T>
struct RGB
{
  T R;
  T G;
  T B;
  
  RGB() {}
  RGB(T R, T G, T B)
  {
    this->R = R;
    this->G = G;
    this->B = B;
  }
};

template<typename T>
RGB<T> operator+(const RGB<T>& a, const RGB<T>& b)
{
  RGB<T> result;
  result.R = a.R + b.R;
  result.G = a.G + b.G;
  result.B = a.B + b.B;
  return result;
}


#if 0
//this one causes no segfault
template<typename U, typename T>
struct alpha : public U
{
  T A; //alpha channel
  
  alpha() {}
  alpha(const U& in) { opaque() = in; }
  void operator=(const U& in) { opaque() = in; }

  private:
  U& opaque() { return *this; }
};

#else
//this one causes segfault
template<typename U, typename T>
struct alpha : public U
{
  T A; //alpha channel

  alpha() {}
  alpha(const U& in) { *this = in; }
  void operator=(const U& in) { *this = in; }
};

#endif

int main()
{
  RGB<int> a(128, 128, 128);
  RGB<int> b(64, 64, 64);
  RGB<int> c = a + b;
  
  alpha<RGB<int>, int> aa;
  alpha<RGB<int>, int> bb;
  alpha<RGB<int>, int> cc;
  
  aa = a;
  bb = b;
  cc = a + b;

  return 0;
}