Language: C++

#include<iostream>
#include<math.h>
#include<algorithm>
#include<stdint.h>
#include<vector>
#include<deque>
#include<string>
#include<time.h>
#include<list>
#include<random>
#include<bitset>
using namespace std;

using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;


//最大公約数
template<typename T>
constexpr T gcd(T a, T b)
{
	if (a % b == 0)
	{
		return(b);
	}
	else
	{
		return(gcd(b, a % b));
	}
}

//最小公倍数
template<typename T>
constexpr T lcm(T a, T b)
{
	return a * b / gcd(a, b);
}

//素因数pの数
template<typename T>
constexpr uint32_t prime_factor_count(T a, uint32_t p) {
	uint32_t c = 0;
	T aa = a;
	while (true)
	{
		if (aa % p != 0) return c;

		aa /= p;
		++c;
	}
}

//素因数分解
vector<pair<long long, int>> factorize(long long n) {
	vector<pair<long long, int>> res;
	for (long long i = 2; i * i <= n; ++i) {
		if (n % i != 0) continue;
		res.emplace_back(i, 0);
		while (n % i == 0) {
			n /= i;
			res.back().second++;
		}
	}
	if (n != 1) res.emplace_back(n, 1);
	return res;
}


template<typename T>
constexpr  uint64_t min_index(const T* arr, size_t start_index, size_t end_index) {
	if (sizeof(arr) <= sizeof(T) * end_index || start_index > end_index) throw std::invalid_argument();
	size_t ret = 0;
	for (int i = max((int)start_index, 1); i <= end_index; ++i) {
		if (arr[ret] > arr[i]) ret = i;
	}
	return ret;
}
template<typename T>
constexpr  uint64_t max_index(const T* arr, size_t start_index, size_t end_index) {
	if (sizeof(arr) <= sizeof(T) * end_index || start_index > end_index) throw std::invalid_argument();
	size_t ret = 0;
	for (int i = max((int)start_index, 1); i <= end_index; ++i) {
		if (arr[ret] < arr[i]) ret = i;
	}
	return ret;
}
template<typename T>
constexpr  uint64_t min_index(const T* arr, size_t start_index, size_t end_index, bool(*comp)(const T&, const T&)) {
	if (sizeof(arr) <= sizeof(T) * end_index || start_index > end_index) throw std::invalid_argument();
	size_t ret = 0;
	for (int i = max((int)start_index, 1); i <= end_index; ++i) {
		if (comp(arr[ret], arr[i])) ret = i;
	}
	return ret;
}
template<typename T>
constexpr  uint64_t max_index(const T* arr, size_t start_index, size_t end_index, bool(*comp)(const T&, const T&)) {
	if (sizeof(arr) <= sizeof(T) * end_index || start_index > end_index) throw std::invalid_argument();
	size_t ret = 0;
	for (int i = max((int)start_index, 1); i <= end_index; ++i) {
		if (comp(arr[ret], arr[i])) ret = i;
	}
	return ret;
}


//10のn乗
template<typename T>
constexpr  T pow10(int32_t n) {
	T ret = 1;
	for (int32_t i = 0; i < n; ++i) {
		ret *= 10;
	}
	return ret;
}


//桁数。０なら０を返す
constexpr  int32_t digits(uint64_t v) {
	if (v >= pow10<uint64_t>(10)) {
		if (v >= pow10<uint64_t>(15)) {
			if (v >= pow10<uint64_t>(17)) {
				if (v >= pow10<uint64_t>(19)) return 20;
				if (v >= pow10<uint64_t>(18)) return 19;
				return 18;
			}
			if (v >= pow10<uint64_t>(16)) return 17;
			return 16;
		}
		if (v >= pow10<uint64_t>(13)) {
			if (v >= pow10<uint64_t>(14)) return 15;
			return 14;
		}
		if (v >= pow10<uint64_t>(12)) return 13;
		if (v >= pow10<uint64_t>(11)) return 12;
		return 11;
	}
	if (v >= pow10<uint64_t>(5)) {
		if (v >= pow10<uint64_t>(7)) {
			if (v >= pow10<uint64_t>(9)) return 10;
			if (v >= pow10<uint64_t>(8)) return 9;
			return 8;
		}
		if (v >= pow10<uint64_t>(6)) return 7;
		return 6;
	}
	if (v >= pow10<uint64_t>(3)) {
		if (v >= pow10<uint64_t>(4)) return 5;
		return 4;
	}
	if (v >= pow10<uint64_t>(2)) return 3;
	if (v >= pow10<uint64_t>(1)) return 2;
	if (v >= pow10<uint64_t>(0)) return 1;
	return 0;
}


//桁数。０なら０を返す
constexpr  int32_t digits(int64_t v) {
	if (v < 0) v *= -1;

	if (v >= pow10<int64_t>(10)) {
		if (v >= pow10<int64_t>(15)) {
			if (v >= pow10<int64_t>(17)) {
				if (v >= pow10<int64_t>(18)) return 19;
				return 18;
			}
			if (v >= pow10<int64_t>(16)) return 17;
			return 16;
		}
		if (v >= pow10<int64_t>(13)) {
			if (v >= pow10<int64_t>(14)) return 15;
			return 14;
		}
		if (v >= pow10<int64_t>(12)) return 13;
		if (v >= pow10<int64_t>(11)) return 12;
		return 11;
	}
	if (v >= pow10<int64_t>(5)) {
		if (v >= pow10<int64_t>(7)) {
			if (v >= pow10<int64_t>(9)) return 10;
			if (v >= pow10<int64_t>(8)) return 9;
			return 8;
		}
		if (v >= pow10<int64_t>(6)) return 7;
		return 6;
	}
	if (v >= pow10<int64_t>(3)) {
		if (v >= pow10<int64_t>(4)) return 5;
		return 4;
	}
	if (v >= pow10<int64_t>(2)) return 3;
	if (v >= pow10<int64_t>(1)) return 2;
	if (v >= pow10<int64_t>(0)) return 1;
	return 0;
}


//桁数。０なら０を返す
constexpr  int32_t digits(uint32_t v) {
	if (v >= pow10<uint32_t>(5)) {
		if (v >= pow10<uint32_t>(7)) {
			if (v >= pow10<uint32_t>(9)) return 10;
			if (v >= pow10<uint32_t>(8)) return 9;
			return 8;
		}
		if (v >= pow10<uint32_t>(6)) return 7;
		return 6;
	}
	if (v >= pow10<uint32_t>(3)) {
		if (v >= pow10<uint32_t>(4)) return 5;
		return 4;
	}
	if (v >= pow10<uint32_t>(2)) return 3;
	if (v >= pow10<uint32_t>(1)) return 2;
	if (v >= pow10<uint32_t>(0)) return 1;
	return 0;
}


//桁数。０なら０を返す
constexpr  int32_t digits(int32_t v) {
	if (v < 0) v *= -1;

	if (v >= pow10<int32_t>(5)) {
		if (v >= pow10<int32_t>(7)) {
			if (v >= pow10<int32_t>(9)) return 10;
			if (v >= pow10<int32_t>(8)) return 9;
			return 8;
		}
		if (v >= pow10<int32_t>(6)) return 7;
		return 6;
	}
	if (v >= pow10<int32_t>(3)) {
		if (v >= pow10<int32_t>(4)) return 5;
		return 4;
	}
	if (v >= pow10<int32_t>(2)) return 3;
	if (v >= pow10<int32_t>(1)) return 2;
	if (v >= pow10<int32_t>(0)) return 1;
	return 0;
}


//桁数。０なら０を返す
constexpr  int32_t digits(uint16_t v) {
	if (v >= pow10<uint16_t>(3)) {
		if (v >= pow10<uint16_t>(4)) return 5;
		return 4;
	}
	if (v >= pow10<uint16_t>(2)) return 3;
	if (v >= pow10<uint16_t>(1)) return 2;
	if (v >= pow10<uint16_t>(0)) return 1;
	return 0;
}


//桁数。０なら０を返す
constexpr  int32_t digits(int16_t v) {
	if (v < 0) v *= -1;

	if (v >= pow10<int16_t>(3)) {
		if (v >= pow10<int16_t>(4)) return 5;
		return 4;
	}
	if (v >= pow10<int16_t>(2)) return 3;
	if (v >= pow10<int16_t>(1)) return 2;
	if (v >= pow10<int16_t>(0)) return 1;
	return 0;
}


//桁数。０なら０を返す
constexpr  int32_t digits(uint8_t v) {
	if (v >= pow10<uint8_t>(2)) return 3;
	if (v >= pow10<uint8_t>(1)) return 2;
	if (v >= pow10<uint8_t>(0)) return 1;
	return 0;
}


//桁数。０なら０を返す
constexpr  int32_t digits(int8_t v) {
	if (v < 0) v *= -1;

	if (v >= pow10<int8_t>(2)) return 3;
	if (v >= pow10<int8_t>(1)) return 2;
	if (v >= pow10<int8_t>(0)) return 1;
	return 0;
}

//「ｎ+１」桁目の数を返す。
template<typename T>
constexpr  int32_t digit(const T& value, int32_t n) {

	return (value / pow10<T>(n)) % 10;
}


const int			BIGINT10_DIGIT_PER_REGISTER = 9;
const long long		BIGINT10_MAXVALUE_PER_REGISTER = pow10<long long>(BIGINT10_DIGIT_PER_REGISTER) - 1;

class bigint_base10 {
public:
	void		from_str(std::string str);
	void		from_str(const char* str);

	bigint_base10();
	bigint_base10(long long value);
	bigint_base10(unsigned long long value);
	bigint_base10(const bigint_base10& source);
	bigint_base10(const char* str);
	bigint_base10(std::string str);
	bigint_base10(bigint_base10&&) = default;
	~bigint_base10() = default;

	const bigint_base10& operator=	(const bigint_base10& source);

	bool   operator==	(const bigint_base10& source) const;
	bool   operator!=	(const bigint_base10& source) const;
	bool   operator<	(const bigint_base10& source) const;
	bool   operator>	(const bigint_base10& source) const;
	bool   operator<=	(const bigint_base10& source) const;
	bool   operator>=	(const bigint_base10& source) const;
	void   operator++	();
	void   operator--	();

	const bigint_base10& operator+	(const bigint_base10& source) const;
	const bigint_base10& operator-	(const bigint_base10& source) const;
	const bigint_base10& operator*	(const bigint_base10& source) const;
	void   operator+=	(const bigint_base10& source);
	void   operator-=	(const bigint_base10& source);
	void   operator*=	(const bigint_base10& source);

	std::vector<long long> registers;
	mutable bool  		   plus;
};

//桁数
int	digits(const bigint_base10& v) {
	return digits(v.registers.back()) + (BIGINT10_DIGIT_PER_REGISTER * (v.registers.size() - 1));
}

bool bigint_base10_iszero(const bigint_base10& v) {
	return digits(v) == 1 && v.registers[0] == 0;
}

void bigint_base10_tozero(bigint_base10& v) {
	v.registers.clear();
	v.plus = true;
	v.registers.push_back(0);
}

void bigint_base10_copy(bigint_base10& target, const bigint_base10& source) {
	target.plus = source.plus;
	target.registers = source.registers;
}

std::string	to_string(const bigint_base10& v) {
	std::string ret;
	for (long long i : v.registers) {
		ret = ::to_string(i) + ret;
	}
	if (!v.plus && !bigint_base10_iszero(v)) ret = "-" + ret;
	return ret;
}

void bigint_base10::from_str(std::string str) {
	registers.clear();
	plus = str[0] != '-';

	if (str.empty() || (!plus && str.size() == 1)) {
		bigint_base10_tozero(*this);
		return;
	}

	if (!plus) str.erase(0, 1);

	bool loop_end = false;
	int i = 0;
	while (!loop_end) {
		int start = str.size() - BIGINT10_DIGIT_PER_REGISTER - (i * BIGINT10_DIGIT_PER_REGISTER);
		int count = start < 0 ? count = str.size() % BIGINT10_DIGIT_PER_REGISTER : BIGINT10_DIGIT_PER_REGISTER;

		if (start <= 0) {
			loop_end = true;
			start = 0;
			if (count == 0) count = BIGINT10_DIGIT_PER_REGISTER;
		}

		std::string s = str.substr(start, count);
		registers.push_back(stoi(s));

		++i;
	}
}
void	bigint_base10::from_str(const char* str) {
	std::string s(str);
	from_str(s);
}

bigint_base10::bigint_base10() :plus(true) {
	bigint_base10_tozero(*this);
}
bigint_base10::bigint_base10(long long value) : plus(value >= 0) {
	registers.push_back(value >= 0 ? value : -value);
}
bigint_base10::bigint_base10(unsigned long long value) : plus(true) {
	registers.push_back(value);
}
bigint_base10::bigint_base10(const bigint_base10& source) : plus(true) {
	bigint_base10_copy(*this, source);
}
bigint_base10::bigint_base10(std::string str) : plus(true) {
	from_str(str);
}
bigint_base10::bigint_base10(const char* str) : plus(true) {
	from_str(str);
}
const bigint_base10& bigint_base10::operator=	(const bigint_base10& source) {
	bigint_base10_copy(*this, source);
	return *this;
}
bool   bigint_base10::operator==	(const bigint_base10& source) const {
	if (plus != source.plus || registers.size() != source.registers.size()) return false;

	for (int i = 0; i < registers.size(); ++i) {
		if (registers[i] != source.registers[i]) return false;
	}
	return true;
}
bool   bigint_base10::operator!=	(const bigint_base10& source) const {
	return !operator==(source);
}
bool   bigint_base10::operator<	(const bigint_base10& source) const {
	if (plus) {
		if (source.plus)
		{
			int mysize = registers.size();
			int opsize = source.registers.size();
			if (mysize < opsize) return true;
			if (mysize > opsize) return false;

			for (int i = mysize - 1; i >= 0; --i) {
				if (registers[i] < source.registers[i]) return true;
				else if (registers[i] > source.registers[i]) return false;
			}

			return false;
		}
		else return false;
	}
	else {
		if (source.plus) return true;
		else {
			source.plus = true;
			plus = true;
			bool ret = source.operator<(*this);
			source.plus = false;
			plus = false;

			return ret;
		}
	}
}
bool   bigint_base10::operator>	(const bigint_base10& source) const {
	return source.operator<(*this);
}
bool   bigint_base10::operator<=	(const bigint_base10& source) const {
	if (plus) {
		if (source.plus)
		{
			int mysize = registers.size();
			int opsize = source.registers.size();
			if (mysize < opsize) return true;
			if (mysize > opsize) return false;

			for (int i = mysize - 1; i >= 0; --i) {
				if (registers[i] < source.registers[i]) return true;
				else if (registers[i] > source.registers[i]) return false;
			}

			return true;
		}
		else return false;
	}
	else {
		if (source.plus) return true;
		else {
			source.plus = true;
			plus = true;
			bool ret = source.operator<=(*this);
			source.plus = false;
			plus = false;

			return ret;
		}
	}
}
bool   bigint_base10::operator>=	(const bigint_base10& source) const {
	return source.operator<=(*this);
}
void   bigint_base10::operator++	() {
	operator+=(unsigned long long(1));
}
void   bigint_base10::operator--	() {
	operator-=(unsigned long long(1));
}
const bigint_base10& bigint_base10::operator+	(const bigint_base10& source) const {
	bigint_base10 ret(*this);

	if (ret.plus == source.plus) {
		int mysize = ret.registers.size();
		int opsize = source.registers.size();
		int loop_size = ::min(mysize, opsize);

		unsigned long long up = 0;
		int i = 0;
		for (; i < loop_size || up > 0; ++i) {
			unsigned long long add_result
				= ((i < mysize) ? ret.registers[i] : 0)
				+ ((i < loop_size) ? source.registers[i] : 0)
				+ up;

			if (BIGINT10_MAXVALUE_PER_REGISTER < add_result) {
				up = add_result / (BIGINT10_MAXVALUE_PER_REGISTER + 1);
				add_result -= up * (BIGINT10_MAXVALUE_PER_REGISTER + 1);
			}
			else up = 0;

			if (i < ret.registers.size()) {
				ret.registers[i] = add_result;
			}
			else {
				ret.registers.push_back(add_result);
			}
		}
	}
	else {
		source.plus = !source.plus;
		ret.operator-=(source);
		source.plus = !source.plus;

		bool absbig;
		if (ret.plus) absbig = ret.operator>=(source);
		else absbig = ret.operator<=(source);
		ret.plus = absbig == plus;
	}

	return ret;
}
const bigint_base10& bigint_base10::operator-	(const bigint_base10& source) const {
	bigint_base10 ret(*this);

	if (ret.plus == source.plus) {
		int mysize = ret.registers.size();
		int opsize = source.registers.size();
		int loop_size = ::min(mysize, opsize);

		bool absbig;
		if (ret.plus) absbig = ret.operator>=(source);
		else absbig = ret.operator<=(source);

		if (absbig) {
			ret.plus = true;

			for (int i = opsize - 1; i >= 0; --i) {
				if (ret.registers[i] < source.registers[i]) {
					for (int j = i + 1; true; ++j) {
						if (ret.registers[j] == 0) ret.registers[j] = BIGINT10_MAXVALUE_PER_REGISTER;
						else {
							ret.registers[j]--;
							break;
						}
					}
					ret.registers[i] += BIGINT10_MAXVALUE_PER_REGISTER + 1 - source.registers[i];
				}
				else {
					ret.registers[i] -= source.registers[i];
				}
			}
		}
		else {
			ret = source - ret;
			ret.plus = false;
		}
	}
	else {
		source.plus = !source.plus;
		ret.operator+=(source);
		source.plus = !source.plus;

		ret.plus = plus;
	}

	int c = 0;
	for (int i = ret.registers.size() - 1; i > 0; --i) {
		if (ret.registers[i] == 0) ++c;
	}

	ret.registers.resize(ret.registers.size() - c);

	return ret;
}
const bigint_base10& bigint_base10::operator*	(const bigint_base10& source) const {
	vector<unsigned long long> ups(registers.size() + source.registers.size());
	ups[0] = 0;

	int mysize = registers.size();
	int opsize = source.registers.size();
	int m = ::min(mysize - 1, opsize - 1);
	int M = ::max(mysize - 1, opsize - 1);

	bigint_base10 ret;
	ret.registers.clear();
	ret.plus = plus == source.plus;

	for (int s = 0; s < ups.size() - 1; ++s) {
		ups[s + 1] = 0;
		unsigned long long result = ups[s];

		if (s <= M) {
			int e = ::min(s, m);
			if (mysize <= opsize) {
				for (int k = 0; k <= e; ++k) {
					result += registers[k] * source.registers[s - k];

					if (result > BIGINT10_MAXVALUE_PER_REGISTER) {
						unsigned long long up = result / (BIGINT10_MAXVALUE_PER_REGISTER + 1);
						ups[s + 1] += up;
						result -= up * (BIGINT10_MAXVALUE_PER_REGISTER + 1);
					}
				}
			}
			else {
				for (int k = 0; k <= e; ++k) {
					result += registers[s - k] * source.registers[k];

					if (result > BIGINT10_MAXVALUE_PER_REGISTER) {
						unsigned long long up = result / (BIGINT10_MAXVALUE_PER_REGISTER + 1);
						ups[s + 1] += up;
						result -= up * (BIGINT10_MAXVALUE_PER_REGISTER + 1);
					}
				}
			}
		}
		else {
			if (mysize <= opsize) {
				for (int k = s + 1 - mysize; k < mysize; ++k) {
					result += registers[k] * source.registers[s - k];

					if (result > BIGINT10_MAXVALUE_PER_REGISTER) {
						unsigned long long up = result / (BIGINT10_MAXVALUE_PER_REGISTER + 1);
						ups[s + 1] += up;
						result -= up * (BIGINT10_MAXVALUE_PER_REGISTER + 1);
					}
				}
			}
			else {
				for (int k = s + 1 - opsize; k < opsize; ++k) {
					result += registers[s - k] * source.registers[k];

					if (result > BIGINT10_MAXVALUE_PER_REGISTER) {
						unsigned long long up = result / (BIGINT10_MAXVALUE_PER_REGISTER + 1);
						ups[s + 1] += up;
						result -= up * (BIGINT10_MAXVALUE_PER_REGISTER + 1);
					}
				}
			}
		}

		ret.registers.push_back(result);
	}

	if (ups.back() > 0) {
		ret.registers.push_back(ups.back());
	}

	return ret;
}
void   bigint_base10::operator+=	(const bigint_base10& source) {
	operator=(operator+(source));
}
void   bigint_base10::operator-=	(const bigint_base10& source) {
	operator=(operator-(source));
}
void   bigint_base10::operator*=	(const bigint_base10& source) {
	operator=(operator*(source));
}


int main() {
	ull _a, _b, _c;
	cin >> _a >> _b >> _c;
	auto a = bigint_base10(_a);
	auto b = bigint_base10(_b);
	auto c = bigint_base10(_c);
	if (bigint_base10(4ull) * a * b < (c * c) - (bigint_base10(2ull) * c * (a + b)) + ((a + b) * (a + b))) {
		cout << "Yes" << endl;
	}
	else {
		cout << "No" << endl;
	}
    return 0;
}

Compiler output:
a.cc: In function 'int digits(const bigint_base10&)':
a.cc:342:22: error: call of overloaded 'digits(const __gnu_cxx::__alloc_traits<std::allocator<long long int>, long long int>::value_type&)' is ambiguous
  342 |         return digits(v.registers.back()) + (BIGINT10_DIGIT_PER_REGISTER * (v.registers.size() - 1));
      |                ~~~~~~^~~~~~~~~~~~~~~~~~~~
a.cc:120:20: note: candidate: 'constexpr int32_t digits(uint64_t)'
  120 | constexpr  int32_t digits(uint64_t v) {
      |                    ^~~~~~
a.cc:160:20: note: candidate: 'constexpr int32_t digits(int64_t)'
  160 | constexpr  int32_t digits(int64_t v) {
      |                    ^~~~~~
a.cc:201:20: note: candidate: 'constexpr int32_t digits(uint32_t)'
  201 | constexpr  int32_t digits(uint32_t v) {
      |                    ^~~~~~
a.cc:223:20: note: candidate: 'constexpr int32_t digits(int32_t)'
  223 | constexpr  int32_t digits(int32_t v) {
      |                    ^~~~~~
a.cc:247:20: note: candidate: 'constexpr int32_t digits(uint16_t)'
  247 | constexpr  int32_t digits(uint16_t v) {
      |                    ^~~~~~
a.cc:260:20: note: candidate: 'constexpr int32_t digits(int16_t)'
  260 | constexpr  int32_t digits(int16_t v) {
      |                    ^~~~~~
a.cc:275:20: note: candidate: 'constexpr int32_t digits(uint8_t)'
  275 | constexpr  int32_t digits(uint8_t v) {
      |                    ^~~~~~
a.cc:284:20: note: candidate: 'constexpr int32_t digits(int8_t)'
  284 | constexpr  int32_t digits(int8_t v) {
      |                    ^~~~~~
a.cc:341:9: note: candidate: 'int digits(const bigint_base10&)'
  341 | int     digits(const bigint_base10& v) {
      |         ^~~~~~
a.cc: In member function 'void bigint_base10::operator++()':
a.cc:505:20: error: expected primary-expression before 'unsigned'
  505 |         operator+=(unsigned long long(1));
      |                    ^~~~~~~~
a.cc: In member function 'void bigint_base10::operator--()':
a.cc:508:20: error: expected primary-expression before 'unsigned'
  508 |         operator-=(unsigned long long(1));
      |                    ^~~~~~~~
a.cc: In member function 'const bigint_base10& bigint_base10::operator+(const bigint_base10&) const':
a.cc:551:16: warning: reference to local variable 'ret' returned [-Wreturn-local-addr]
  551 |         return ret;
      |                ^~~
a.cc:511:23: note: declared here
  511 |         bigint_base10 ret(*this);
      |                       ^~~
a.cc: In member function 'const bigint_base10& bigint_base10::operator-(const bigint_base10&) const':
a.cc:604:16: warning: reference to local variable 'ret' returned [-Wreturn-local-addr]
  604 |         return ret;
      |                ^~~
a.cc:554:23: note: declared here
  554 |         bigint_base10 ret(*this);
      |                       ^~~
a.cc: In member function 'const bigint_base10& bigint_base10::operator*(const bigint_base10&) const':
a.cc:680:16: warning: reference to local variable 'ret' returned [-Wreturn-local-addr]
  680 |         return ret;
      |                ^~~
a.cc:615:23: note: declared here
  615 |         bigint_base10 ret;
      |                       ^~~