#include<iostream>
#include<vector>
#include<set>
#include<algorithm>
#include<queue>
#include<functional>
#include<numeric>
#include<limits>
#include<map>
#include<bitset>
#include<array>
#include<boost/multi_array.hpp>
#include<boost/operators.hpp>

namespace math
{
	template<class T>constexpr T pow(T val, std::uint64_t p)
	{
		return p == 0 ? T(1) :
			p == 1 ? val :
			p == 2 ? val*val :
			p % 2 == 0 ? pow(pow(val, p / 2), 2) :
			pow(pow(val, p / 2), 2)*val;
	}
	template<class T,class U>constexpr int ilog(T val, U base)
	{
		T v(1);
		for (int i{};;++i)
		{
			if (val <= v)
			{
				return i;
			}
			v *= base;
		}
	}

	template<std::uint64_t Mod>class mod_number:
		private boost::equality_comparable<mod_number<Mod>>,
		private boost::addable<mod_number<Mod>>,
		private boost::subtractable<mod_number<Mod>>,
		private boost::multipliable<mod_number<Mod>>,
		private boost::dividable<mod_number<Mod>>
	{
		std::uint64_t value;
	public:
		mod_number(std::uint64_t v = 0) :value(v%Mod)
		{

		}
		mod_number(int v) :value(v%Mod)
		{

		}
		mod_number(std::int64_t v) :value(v%Mod)
		{

		}
		mod_number(std::uint32_t v) :value(v%Mod)
		{

		}

		bool operator==(mod_number const& rhs)
		{
			return value == rhs.value;
		}

		auto& operator+=(mod_number const& rhs)
		{
			value += rhs.value;
			value %= Mod;
			return *this;
		}

		auto& operator-=(mod_number const& rhs)
		{
			value += Mod - rhs.value;
			value %= Mod;
			return *this;
		}

		auto& operator*=(mod_number const& rhs)
		{
			value *= rhs.value;
			value %= Mod;
			return *this;
		}

		auto& operator/=(mod_number const& rhs)
		{
			return operator*=(pow(rhs, Mod - 2));
		}
	};
}
namespace container
{
	template<class T, std::size_t Size = 1 << 13>class addtree
	{
		std::array<T, 2 * Size - 1> data;
		T get(std::size_t left, std::size_t right, std::size_t i, std::size_t l, std::size_t r)
		{
			if (r <= left || right <= l)
				return T();
			if (left <= l&&r <= right)
			{
				return data[i];
			}
			else
			{
				return 
					get(left, right, 2 * i + 1, l, (l + r) / 2) +
					get(left, right, 2 * i + 2, (l + r) / 2, r);
			}
		}
	public:
		addtree() :data{}
		{

		}
		void change(T const& val, std::size_t index)
		{
			T from = data[index + Size - 1];
			for (std::size_t i = 1, c = math::ilog(Size, 2);i <= Size;(i <<= 1), --c)
			{
				data[i + (index >> c) - 1] -= from;
				data[i + (index >> c) - 1] += val;
			}
		}
		auto begin()const
		{
			return std::next(data.begin(), Size - 1);
		}
		auto end()const
		{
			return data.end();
		}
		T get(std::size_t left, std::size_t right)
		{
			return left > right ? T() : get(left, right + 1, 0, 0, Size);
		}
	};
	/*template<class T, std::size_t Size = 1 << 13>class minmaxtree
	{
		std::array<std::pair<T, T>, 2 * Size - 1> data;
		T min(std::size_t left, std::size_t right, std::size_t i, std::size_t l, std::size_t r)
		{
			if (r <= left || right <= l)
				return std::numeric_limits<T>::max();
			if (left <= l&&r <= right)
			{
				return data[i].first;
			}
			else
			{
				return std::min(
					get(left, right, 2 * i + 1, l, (l + r) / 2),
					get(left, right, 2 * i + 2, (l + r) / 2, r));
			}
		}
		T max(std::size_t left, std::size_t right, std::size_t i, std::size_t l, std::size_t r)
		{
			if (r <= left || right <= l)
				return std::numeric_limits<T>::min();
			if (left <= l&&r <= right)
			{
				return data[i].second;
			}
			else
			{
				return std::max(
					get(left, right, 2 * i + 1, l, (l + r) / 2),
					get(left, right, 2 * i + 2, (l + r) / 2, r));
			}
		}
		std::size_t change(T const& val, std::size_t index, std::size_t shift)
		{
			if (shift == Size)
			{
				val[shift + index] = val;
			}
			else
			{
				auto s = change(val, index, shift << 1);
				val[shift + s - 1].first = std::min(val[2 * shift + 2 * s], val[2 * shift + 2 * s + 1]);
				val[shift + s - 1].second = std::max(val[2 * shift + 2 * s], val[2 * shift + 2 * s + 1]);
			}
			return index >> 1;
		}
	public:
		addtree() :data{}
		{

		}
		void change(T const& val, std::size_t index)
		{
			data[index + Size - 1] = val;
			
		}
		auto begin()const
		{
			return std::next(data.begin(), Size - 1);
		}
		auto end()const
		{
			return data.end();
		}
		T min(std::size_t left, std::size_t right)const
		{
			return left > right ? std::numeric_limits<T>::max() : min(left, right + 1, 0, 0, Size);
		}
		T max(std::size_t left, std::size_t right)const
		{
			return left > right ? std::numeric_limits<T>::min() : min(left, right + 1, 0, 0, Size);
		}

	};*/
}

void Main();
int main()
{
	std::ios::sync_with_stdio(false);
	Main();
}
int gcd(int x, int y)
{
	if (y > x)
	{
		return gcd(x, y);
	}
	if (y == 0)
	{
		return x;
	}
	return gcd(y, x%y);
}
//ここから頑張る

void Main()
{
	std::int64_t N;
	std::cin >> N;
	std::vector<std::int64_t> stone(N);
	std::int64_t sum{};
	for (auto& v : stone)
	{
		std::cin >> v;
		sum += v;
	}
	if (sum % (N*(N + 1) / 2) != 0)
	{
		std::cout << "NO" << std::endl;
		return;
	}
	std::int64_t count = sum / (N*(N + 1) / 2);
	std::vector<std::int64_t> check(N);
	for (int i{};i < N;++i)
	{
		auto c = stone[(i + N - 1) % N] - stone[i] + count;
		if (c < 0 || c%N != 0)
		{
			std::cout << "NO" << std::endl;
			return;
		}
		check[i] = c / N;
	}
	std::int64_t s = check[0];
	for (int i = 1;i < N;++i)
	{
		s += check[i] * (N - i + 1);
	}
	if (s != stone[0])
	{
		std::cout << "NO" << std::endl;
	}
	else
	{
		std::cout << "YES" << std::endl;
	}
}

Measured memory_bytes: 1792