/*
	ベクトルクラス(ETの始まり)
*/
#include <iostream>
#include <algorithm>

class VaddV;
class VaddV_addV;

class Vect {
public:
	enum {
		N = 4
	};
private:
	int p_[N];
public:
#ifdef DEBUG
	Vect()
	{
		if (debug) puts("cstr");
	}

	Vect(const Vect& rhs)
	{
		puts("copy cstr");
		std::copy(rhs.p_, rhs.p_ + N, p_);
	}
	Vect& operator=(const Vect& rhs)
	{
		if (debug) puts("copy");
		std::copy(rhs.p_, rhs.p_ + N, p_);
		return *this;
	}
#endif
	int& operator[](int i) { return p_[i]; }
	int operator[](int i) const { return p_[i]; }

	friend std::ostream& operator<<(std::ostream& os, const Vect& v)
	{
		os << '{';
		for (int i = 0; i < N; i++) {
			os << v.p_[i];
			if (i < v.N - 1) os << ',';
		}
		os << '}';
		return os;
	}

	static void add(const Vect& rhs, const Vect& lhs, Vect& dest)
	{
		for (int i = 0; i < N; i++) {
			dest.p_[i] = rhs.p_[i] + lhs.p_[i];
		}
	}
	static void add(const Vect& rhs, Vect& dest)
	{
		for (int i = 0; i < N; i++) {
			dest.p_[i] += rhs.p_[i];
		}
	}

/////////////////////////////////////////////////////////////

	Vect& operator=(const VaddV& rhs);
	Vect& operator=(const VaddV_addV& rhs);
};

class VaddV {
	const Vect& lhs_;
	const Vect& rhs_;
public:
	VaddV(const Vect& lhs, const Vect& rhs)
		: lhs_(lhs)
		, rhs_(rhs)
	{
	}
	void eval(Vect& dest) const
	{
		Vect::add(lhs_, rhs_, dest);
	}
};

VaddV operator+(const Vect& lhs, const Vect& rhs)
{
	return VaddV(lhs, rhs);
}

class VaddV_addV {
	const VaddV& lhs_;
	const Vect& rhs_;
public:
	VaddV_addV(const VaddV& lhs, const Vect& rhs)
		: lhs_(lhs)
		, rhs_(rhs)
	{
	}
	void eval(Vect& dest) const
	{
//		lhs_.eval(dest);
		dest = lhs_;
		Vect::add(rhs_, dest);
	}
};

VaddV_addV operator+(const VaddV& lhs, const Vect& rhs)
{
	return VaddV_addV(lhs, rhs);
}

Vect& Vect::operator=(const VaddV_addV& rhs)
{
	rhs.eval(*this);
	return *this;
}

Vect& Vect::operator=(const VaddV& rhs)
{
	rhs.eval(*this);
	return *this;
}