template <typename T> class A
{
public:
    T
        x,
        y;

    A(T=T(), T=T());
    A(const A<T>&);
    virtual ~A(void);

    A<T>& operator = (const A<T>&);
};

template <typename T> A<T>::A(T aX, T aY) : x(aX), y(aY)
{}

template <typename T> A<T>::A(const A<T> &a) : x(a.x), y(a.y)
{}

template <typename T> A<T>::~A(void)
{}

template <typename T> A<T> &  A<T>::operator = (const A<T> &a)
{
    if (this != &a)
    {
        x = a.x;
        y = a.y;
    }

    return *this;
}

template <typename T> class B : public A<T>
{
public:
    T
        z;

    B(T=T(), T=T(), T=T());
    B(const B<T>&);
    virtual ~B(void);

    B<T>& operator = (const B<T>&);
};

template <typename T> B<T>::B(T aX, T aY, T aZ) : A<T>(aX, aY), z(aZ)
{}

template <typename T> B<T>::B(const B<T> &a) : A<T>(a.x, a.y), z(a.z)
{}

template <typename T> B<T>::~B(void)
{}

template <typename T> B<T> &  B<T>::operator = (const B<T> &b)
{
    if(this != &b)
    {
        this->x = b.x; // x = b.x
        this->y = b.y; // y = b.y
        z = b.z;
    }

    return *this;
}