CodeEff/ECCO huggingface dataset:
# Original solution
def floor_sum(n, m, a, b):
    res = 0
    while True:
        res += (n - 1) * n * (a // m) // 2
        a %= m
        res += n * (b // m)
        b %= m
        y_max = (a * n + b) // m
        if y_max == 0: break
        x_max = y_max * m - b
        res += (n - (x_max + a - 1) // a) * y_max
        n, m, a, b = y_max, a, m, -x_max % a
    return res

import sys
input = sys.stdin.buffer.readline

T = int(eval(input()))
res = [None] * T

for i in range(T):
    n, m, a, b = list(map(int, input().split()))
    res[i] = str(floor_sum(n, m, a, b))

print(('\n'.join(res)))

# Optimized solution
def floor_sum(n, m, a, b):
    res = 0
    while True:
        if a >= m:
            res += (n - 1) * n * (a // m) // 2
            a %= m
        if b >= m:
            res += n * (b // m)
            b %= m
        y_max = (a * n + b) // m
        if y_max == 0: break
        x_max = b - y_max * m
        res += (n + x_max // a) * y_max
        n, m, a, b = y_max, a, m, x_max % a
    return res

import sys
input = sys.stdin.buffer.readline

T = int(eval(input()))
res = [None] * T

for i in range(T):
    n, m, a, b = list(map(int, input().split()))
    res[i] = str(floor_sum(n, m, a, b))

print(('\n'.join(res)))
# Original solution
def floor_sum(n, m, a, b):
    res = 0
    while True:
        if a >= m:
            res += (n - 1) * n * (a // m) // 2
            a %= m
        if b >= m:
            res += n * (b // m)
            b %= m
        y_max = (a * n + b) // m
        if y_max == 0: break
        x_max = b - y_max * m
        res += (n + x_max // a) * y_max
        n, m, a, b = y_max, a, m, x_max % a
    return res

import sys
input = sys.stdin.buffer.readline

T = int(eval(input()))
res = [None] * T

for i in range(T):
    n, m, a, b = list(map(int, input().split()))
    res[i] = str(floor_sum(n, m, a, b))

print(('\n'.join(res)))

# Optimized solution
def floor_sum(n, m, a, b):
    res = 0
    while True:
        if a >= m:
            res += (n - 1) * n * (a // m) // 2
            a %= m
        if b >= m:
            res += n * (b // m)
            b %= m
        y_max = (a * n + b) // m
        if y_max == 0: break
        x_max = b - y_max * m
        res += (n + x_max // a) * y_max
        n, m, a, b = y_max, a, m, x_max % a
    return res

import sys
input = sys.stdin.buffer.readline

T = int(eval(input()))
res = [''] * T

for i in range(T):
    n, m, a, b = list(map(int, input().split()))
    res[i] = str(floor_sum(n, m, a, b))

print(('\n'.join(res)))
# Original solution
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))


def floor_sum(n,m,a,b):  # sum((A*i+B)//M for i in range(N))
    res = 0
    res += (a//m)*n*(n-1)//2 + (b//m)*n
    a %= m
    b %= m
    y_max = (a*n+b)//m
    if y_max == 0:
        return res
    x_max = m*y_max-b
    res += (n+(-x_max)//a)*y_max
    res += floor_sum(y_max,a,m,(x_max+a-1)//a*a-x_max)
    return res


T = I()
for i in range(T):
    n,m,a,b = MI()
    print((floor_sum(n,m,a,b)))


# Optimized solution
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))


def floor_sum(n,m,a,b):  # sum((A*i+B)//M for i in range(N))
    res = 0
    if a >= m:
        res += (a//m)*n*(n-1)//2
        a %= m
    if b >= m:
        res += (b//m)*n
        b %= m
    y_max = (a*n+b)//m
    if y_max == 0:
        return res
    x_max = m*y_max-b
    res += (n+(-x_max)//a)*y_max
    res += floor_sum(y_max,a,m,(x_max+a-1)//a*a-x_max)
    return res


T = I()
for i in range(T):
    n,m,a,b = MI()
    print((floor_sum(n,m,a,b)))
# Original solution
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)
INF = 10 ** 9 + 1  # sys.maxsize # float("inf")
MOD = 10 ** 9 + 7


def floor_sum_1(n, m, a, b):
    ret = 0
    if a >= m:
        ret += (n - 1) * n * (a // m) // 2
        a %= m
    if b >= m:
        ret += n * (b // m)
        b %= m
    y_max = (a * n + b) // m
    x_max = y_max * m - b
    if y_max == 0:
        return ret
    ret += (n - (x_max + a - 1) // a) * y_max
    ret += floor_sum(y_max, a, m, (a - x_max % a) % a)
    return ret


def floor_sum(n, m, a, b):
    ret = 0
    while True:
        if a >= m:
            ret += (a // m) * (n - 1) * n // 2
            a %= m
        if b >= m:
            ret += n * (b // m)
            b %= m
        if a * n + b < m:
            return ret
        y_max = (a * n + b) // m
        x_max = y_max * m - b
        ret += (n - (x_max + a - 1) // a) * y_max
        n = y_max
        m, a, b = a, m, -x_max % a


def debug(*x):
    print(*x, file=sys.stderr)


def solve(SOLVE_PARAMS):
    pass


def main():
    # parse input
    T = int(input())
    for _t in range(T):
        N, M, A, B = map(int, input().split())
        print(floor_sum(N, M, A, B))


# tests
T1 = """
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
3
13
0
314095480
499999999500000000
"""


def _test():
    import doctest
    doctest.testmod()
    g = globals()
    for k in sorted(g):
        if k.startswith("TEST_"):
            doctest.run_docstring_examples(g[k], g, name=k)


def as_input(s):
    "use in test, use given string as input file"
    import io
    f = io.StringIO(s.strip())
    g = globals()
    g["input"] = lambda: bytes(f.readline(), "ascii")
    g["read"] = lambda: bytes(f.read(), "ascii")


input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read

if sys.argv[-1] == "-t":
    print("testing")
    _test()
    sys.exit()

main()


# Optimized solution
#!/usr/bin/env python3
import sys

def floor_sum(n, m, a, b):
    ret = 0
    while True:
        if a >= m:
            ret += (a // m) * (n - 1) * n // 2
            a %= m
        if b >= m:
            ret += n * (b // m)
            b %= m
        if a * n + b < m:
            return ret
        y_max = (a * n + b) // m
        x_max = y_max * m - b
        ret += (n - (x_max + a - 1) // a) * y_max
        n = y_max
        m, a, b = a, m, -x_max % a


input = sys.stdin.buffer.readline

T = int(eval(input()))
for _t in range(T):
    N, M, A, B = list(map(int, input().split()))
    print((floor_sum(N, M, A, B)))
# Original solution
def floor_sum(n, m, a, b):
    res = 0
    if b >= m:
        res += n * (b // m)
        b %= m
    while True:
        if a >= m:
            res += (n - 1) * n * (a // m) // 2
            a %= m
        y_max = (a * n + b) // m
        if y_max == 0: break
        x_max = b - y_max * m
        res += (n + x_max // a) * y_max
        n, m, a, b = y_max, a, m, x_max % a
    return res


import sys
input = sys.stdin.readline

for i in range(int(eval(input()))):
    n, m, a, b = list(map(int, input().split()))
    print((floor_sum(n, m, a, b)))

# Optimized solution
# 一番早いのを写経したものを弄ってアルゴリズム勉強のための試し打ち中

def floor_sum(n, m, a, b):
    res = 0
    if b >= m:
        res += n * (b // m)
        b %= m
    while True:
        if a >= m:
            res += (n - 1) * n * (a // m) // 2
            a %= m
        y_max = (a * n + b) // m
        if y_max == 0: break
        x_max = b - y_max * m
        res += (n + x_max // a) * y_max
        n, m, a, b = y_max, a, m, x_max % a
    return res


import sys
input = sys.stdin.buffer.readline

T = int(eval(input()))
res = [''] * T

for i in range(T):
    n, m, a, b = list(map(int, input().split()))
    res[i] = str(floor_sum(n, m, a, b))

print(('\n'.join(res)))
# Original solution
def floor_sum(n, m, a, b):
    res = 0
    while True:
        res += a//m * n * (n-1) // 2
        a %= m
        res += b//m * n
        b %= m
        Y = (a*n+b) // m
        X = Y*m-b
        if Y == 0:
            return res
        res += (n+(-X//a)) * Y
        n, m, a, b = Y, a, m, -X%a

import sys
input = sys.stdin.buffer.readline
t = int(eval(input()))
for _ in range(t):
    n, m, a, b = list(map(int, input().split()))
    print((floor_sum(n, m, a, b)))

# Optimized solution
def floor_sum(n, m, a, b):
    res = 0
    while True:
        if a >= m:
            res += a//m * n * (n-1) // 2
            a %= m
        if b >= m:
            res += b//m * n
            b %= m
        Y = (a*n+b) // m
        X = Y*m-b
        if Y == 0:
            return res
        res += (n+(-X//a)) * Y
        n, m, a, b = Y, a, m, -X%a

import sys
input = sys.stdin.buffer.readline
t = int(eval(input()))
for _ in range(t):
    n, m, a, b = list(map(int, input().split()))
    print((floor_sum(n, m, a, b)))
# Original solution
def floor_sum(n, m, a, b):
    res = 0
    while True:
        if a >= m:
            res += a//m * n * (n-1) // 2
            a %= m
        if b >= m:
            res += b//m * n
            b %= m
        Y = (a*n+b) // m
        X = Y*m-b
        if Y == 0:
            return res
        res += (n+(-X//a)) * Y
        n, m, a, b = Y, a, m, -X%a

import sys
input = sys.stdin.buffer.readline
t = int(eval(input()))
for _ in range(t):
    n, m, a, b = list(map(int, input().split()))
    print((floor_sum(n, m, a, b)))

# Optimized solution
def floor_sum(n, m, a, b):
    res = 0
    while True:
        if a >= m:
            res += a//m * n * (n-1) // 2
            a %= m
        if b >= m:
            res += b//m * n
            b %= m
        Y = (a*n+b) // m
        X = Y*m-b
        if Y == 0:
            return res
        res += (n-(X+a-1)//a) * Y
        n, m, a, b = Y, a, m, -X%a

import sys
input = sys.stdin.buffer.readline
t = int(eval(input()))
for _ in range(t):
    n, m, a, b = list(map(int, input().split()))
    print((floor_sum(n, m, a, b)))
# Original solution
def floor_sum(n,m,a,b):
  r=0
  x,y,z=0,0,0
  while 1:
    if b>=m:
      x=b//m
    else:
      x=0
    if a>=m:
      y=a//m
    else:
      y=0
    r+=x*n
    b-=x*m
    r+=(y*n*(n-1))>>1
    a-=y*m
    x=(a*n+b)//m
    if x==0:
      break
    y=b-x*m
    z=y//a
    r+=(n+z)*x
    a,b,n,m=m,y-z*a,x,a
  return r

for i in range(int(eval(input()))):
  print((floor_sum(*list(map(int,input().split())))))

# Optimized solution
import sys
S=sys.stdin.readlines()
def floor_sum(n,m,a,b):
  r=0
  x,y,z=0,0,0
  while 1:
    if b>=m:
      x=b//m
    else:
      x=0
    if a>=m:
      y=a//m
    else:
      y=0
    r+=x*n
    b-=x*m
    r+=(y*n*(n-1))>>1
    a-=y*m
    x=(a*n+b)//m
    if x==0:
      break
    y=b-x*m
    z=y//a
    r+=(n+z)*x
    a,b,n,m=m,y-z*a,x,a
  return r

for i in range(int(S[0])):
  print((floor_sum(*list(map(int,S[i+1].split())))))
# Original solution
def floor_sum(n,m,a,b):
    ans = n*(b//m)
    b %= m
    while True:
        ans += (n-1)*n*(a//m)//2
        a %= m
        if a*n+b < m:
            return ans
        y_max = (a*n + b)//m
        b -= y_max*m #now we have x_max = -(b//a)
        ans += (n + b//a)*y_max
        n = y_max
        b %= a
        m,a = a,m

import sys
readline = sys.stdin.buffer.readline
read = sys.stdin.read

T = int(readline())
for _ in range(T):
    n,m,a,b = list(map(int,readline().split()))
    print((floor_sum(n,m,a,b)))


# Optimized solution
# coding: utf-8
# Your code here!

def floor_sum(n,m,a,b):
    res = 0
    while True:
        res += ((n-1)*n*(a//m)>>1) + (b//m)*n
        a %= m
        b %= m
        if a*n+b <= m:
            return res
        Y = (a*n+b)//m
        n,m,a,b = Y,a,m, a*n + b - m*Y

import sys
input = sys.stdin.buffer.readline
T = int(eval(input()))
for _ in range(T):
    n,m,a,b = list(map(int,input().split()))
    print((floor_sum(n,m,a,b)))
# Original solution
def floor_sum(n, m, a, b):
    """ sum( (a*i + b)//m ), i = 0..n-1 を返す"""
    ans = 0
    if a >= m:
        ans += n * (n - 1) * (a // m) // 2
        a %= m
    if b >= m:
        ans += n * (b // m)
        b %= m
    y_max = (a * n + b) // m
    x_max = y_max * m - b
    if y_max == 0:
        return ans
    ans += (n - (x_max + a - 1) // a) * y_max
    ans += floor_sum(y_max, a, m, (a - x_max % a) % a)
    return ans


if __name__ == "__main__":
    import sys
    input = sys.stdin.buffer.readline
    sys.setrecursionlimit(10 ** 7)

    T = int(eval(input()))
    for _ in range(T):
        ans = floor_sum(*list(map(int, input().split())))
        print(ans)

# Optimized solution
def floor_sum(n, m, a, b):
    """ sum( (a*i + b) // m ), i = 0..n-1 を返す"""
    ans = 0
    while True:
        if a >= m:
            ans += n * (n - 1) * (a // m) // 2
            a %= m
        if b >= m:
            ans += n * (b // m)
            b %= m
        y_max = (a * n + b) // m
        x_max = y_max * m - b
        if y_max == 0:
            break
        ans += (n - (x_max + a - 1) // a) * y_max
        n, m, a, b = y_max, a, m, (a - x_max % a) % a
    return ans


if __name__ == "__main__":
    import sys
    input = sys.stdin.buffer.readline
    sys.setrecursionlimit(10 ** 7)

    T = int(eval(input()))
    for _ in range(T):
        ans = floor_sum(*list(map(int, input().split())))
        print(ans)
# Original solution
a, b, c = list(map(int, input().split()))

# from math import sqrt
import decimal

a2 = decimal.Decimal(a)
b2 = decimal.Decimal(b)
c2 = decimal.Decimal(c)

a2 = a2.sqrt()
b2 = b2.sqrt()
c2 = c2.sqrt()


# if sqrt(a) + sqrt(b) < sqrt(c):
#     print('Yes')
# else:
#     print('No')

if a2 + b2 < c2:
    print('Yes')
else:
    print('No')

# Optimized solution
a, b, c = list(map(int, input().split()))

if c - a - b > 0 and 4 * a * b < (c - a - b) ** 2:
    print('Yes')
else:
    print('No')
# Original solution
import math
from decimal import Decimal
a, b, c = list(map(int, input().split()))
A = Decimal(str(a))**Decimal('0.5')
B = Decimal(str(b))**Decimal('0.5')
C = Decimal(str(c))**Decimal('0.5')
if A + B < C:
    print('Yes')
else:
    print('No')

# Optimized solution
a, b, c = list(map(int, input().split()))

#import numpy as np
import math
#abc_sq = np.sqrt(abc)
d = c - a - b
if 4*a*b < d**2 and d > 0:
    print('Yes')
else:
    print('No')
# Original solution
from decimal import *
getcontext().prec = 100000
a,b,c=list(map(int,input().split()))
if Decimal(a).sqrt()+Decimal(b).sqrt()<Decimal(c).sqrt():
  print('Yes')
else:
  print('No')

# Optimized solution
import math
a,b,c=list(map(int,input().split()))
if 4*a*b<(c-a-b)*(c-a-b) and c>a+b:
  print('Yes')
else:
  print('No')
# Original solution
a, b, c = list(map(int, input().split()))

if c-a-b>0 and 4*a*b<(c-a-b)**2:
    print('Yes')
else:
    print('No')

# Optimized solution
a, b, c = list(map(int, input().split()))

if c-a-b>=0 and 4*a*b<(c-a-b)**2:
    print('Yes')
else:
    print('No')
# Original solution
a, b, c = list(map(int, input().split()))

l = a * b * 4
r = c - a - b
if r < 0 or l >= r ** 2:
    print("No")
else:
    print("Yes")


# Optimized solution

A, B, C = list(map(int, input().split()))

x = A * B * 4
y = (C - A - B) ** 2
if x < y and C - A - B > 0:
    print("Yes")
else:
    print("No")
# Original solution
from decimal import Decimal, getcontext

getcontext().prec = 100000

a, b, c = list(map(Decimal, input().split()))
print(('Yes' if a.sqrt() + b.sqrt() < c.sqrt() else 'No'))

# Optimized solution
from decimal import Decimal, getcontext

getcontext().prec = 28

a, b, c = list(map(Decimal, input().split()))
print(('Yes' if a.sqrt() + b.sqrt() < c.sqrt() else 'No'))
# Original solution
from decimal import Decimal, getcontext

getcontext().prec = 50

a, b, c = list(map(Decimal, input().split()))
print(('Yes' if a.sqrt() + b.sqrt() < c.sqrt() else 'No'))


# Optimized solution
a, b, c = list(map(int, input().split()))

if c - a - b <= 0:
    print('No')

elif 4 * a * b < (c - a - b) ** 2:
    print('Yes')

else:
    print('No')
# Original solution
from decimal import *
A, B, C = list(map(int,input().split()))
a = Decimal(A)
b = Decimal(B)
c = Decimal(C)
if a.sqrt() + b.sqrt() < c.sqrt():
  print("Yes")
else:
  print("No")

# Optimized solution
a, b, c = list(map(int, input().split()))
if 4*a*b < pow(c-a-b, 2) and c-a-b > 0:
  print("Yes")
else:
  print("No")
# Original solution
a, b, c = list(map(float, input().split()))

from decimal import *
getcontext().prec = 50
A = Decimal(a).sqrt()
B = Decimal(b).sqrt()
C = Decimal(c).sqrt()

print(('Yes' if A+B<C else 'No'))

# Optimized solution
a, b, c = list(map(int, input().split()))

if c - a - b <= 0:
    print('No')
else:
    if 4*a*b < (c - a - b)**2:
        print('Yes')
    else:
        print('No')
# Original solution
from decimal import *
import math
a,b,c = list(map(int,input().split()))
asq = Decimal(a).sqrt()
bsq = Decimal(b).sqrt()
csq = Decimal(c).sqrt()
 
if asq + bsq < csq:
    print('Yes')
else:
    print('No')

# Optimized solution
from decimal import *
a, b, c = list(map(int, input().split()))

a = Decimal(a).sqrt()
b = Decimal(b).sqrt()
c = Decimal(c).sqrt()

import math

if a + b < c:
  print('Yes')
else:
  print('No')
# Original solution
from decimal import Decimal
import math
a,b,c = list(map(int,input().split()))
d = c - a - b
if d >0 and pow(d,2) > 4 * a * b:
    print('Yes')
else:print('No')

# Optimized solution
a,b,c = list(map(int,input().split()))
d = c - a - b
if d >0 and pow(d,2) > 4 * a * b:
    print('Yes')
else:print('No')
# Original solution
import math
a,b,c = list(map(int, input().split()))
x=a**2+b**2+c**2+2*a*b-2*b*c-2*a*c
y=4*a*b

if c-b-a>0 and x-y>0 :
    print("Yes")
else:
    print("No")

# Optimized solution
def Judgement(x,y,z):
    if z-x-y>0 and (z-x-y)**2-4*x*y>0:
        return 0
    else:
        return 1

a,b,c=list(map(int,input().split()))
ans=Judgement(a,b,c)
if ans==0:
    print("Yes")
else:
    print("No")
# Original solution
from decimal import Decimal
a, b, c = list(map(int, input().split()))


def f(x):
    return Decimal(Decimal(x)**2 + s) / (2 * Decimal(x))


s = a * b   # √s
x = 2   # 初期値（0以外の値）
for i in range(10**4):
    x = f(x)

l = 2 * x + a + b

if l < c:
    print("Yes")
else:
    print("No")


# Optimized solution
from decimal import Decimal
a, b, c = list(map(int, input().split()))


def f(x):
    return Decimal(Decimal(x)**2 + s) / (2 * Decimal(x))


s = a * b   # √s
x = 2   # 初期値（0以外の値）
while True:
    newX = f(x)
    if abs(newX - x) < 1e-7:
        x = newX
        break
    x = newX

l = 2 * x + a + b

if l < c:
    print("Yes")
else:
    print("No")
# Original solution

a, b, c = list(map(int, input().split()))

s = c - a - b

if s < 0:
    ans = 'No'
else:
    if 4*a*b < s**2:
        ans = 'Yes'
    else:
        ans = 'No'

print(ans)


# Optimized solution

def main():
    a, b, c = list(map(int, input().split()))
    if 4*a*b < pow(c - (a + b), 2):
        ans = 'Yes'
    else:
        ans = 'No'
    if c - (a + b) <= 0:
        ans = 'No'
    print(ans)


if __name__ == "__main__":
    main()
# Original solution
def mi():return list(map(str,input().split()))
from decimal import *

a,b,c=mi()
getcontext().prec=1500
a=Decimal(a)**Decimal("0.50")
b=Decimal(b)**Decimal("0.50")
c=Decimal(c)**Decimal("0.50")

if c>a+b:
    print("Yes")
else:
    print("No")




# Optimized solution
a,b,c=list(map(int,input().split()))

d=c-a-b
if d<0:print("No");exit()

if 4*a*b<d**2:
  print("Yes")
else:
  print("No")
# Original solution
from math import sqrt
from decimal import *

getcontext().prec = 40000

a, b, c = list(map(int, input().split()))

tmp = 2 * sqrt(Decimal(a)) * sqrt(Decimal(b))
print(("Yes" if Decimal(a).sqrt() + Decimal(b).sqrt() < Decimal(c).sqrt() else "No"))


# Optimized solution
from math import sqrt
from decimal import *


a, b, c = list(map(int, input().split()))

tmp = 2 * sqrt(Decimal(a)) * sqrt(Decimal(b))
print(("Yes" if Decimal(a).sqrt() + Decimal(b).sqrt() < Decimal(c).sqrt() else "No"))
# Original solution
from decimal import Decimal
A,B,C=list(map(int,input().split()))
if (C-A-B)<0:
  print("No")
else:  
  if Decimal(4*A*B)<Decimal((C-A-B)**2):
    print("Yes")
  else:
    print("No")

# Optimized solution
A,B,C=list(map(int,input().split()))
if (C-A-B)<0:
  print("No")
else:  
  if 4*A*B<(C-A-B)**2:
    print("Yes")
  else:
    print("No")
# Original solution
import decimal
a,b,c=(decimal.Decimal(x) for x in input().split())

if a.sqrt() + b.sqrt() < c.sqrt():
    print("Yes")
else:
    print("No")


# Optimized solution
import decimal
decimal.getcontext().prec = 28
a,b,c=(decimal.Decimal(x) for x in input().split())
if a.sqrt() + b.sqrt() < c.sqrt():
    print("Yes")
else:
    print("No")
# Original solution
from decimal import *

a,b,c=list(map(int,input().split()))
a,b,c=Decimal(a),Decimal(b),Decimal(c)
if c**Decimal(0.5)>a**Decimal(0.5)+b**Decimal(0.5):
  print('Yes')
else:
  print('No')

# Optimized solution
a,b,c=list(map(int,input().split()))
if 4*a*b<(c-a-b)**2 and a+b<c:
  print('Yes')
else:
  print('No')
# Original solution
from decimal import *

def main():
    a, b, c = list(map(int, input().split()))

    ad = Decimal(a).sqrt()
    bd = Decimal(b).sqrt()
    cd = Decimal(c).sqrt()

    if ad + bd < cd:
        is_big = True
    else:
        is_big = False

    print(('Yes' if is_big else 'No'))

if __name__ == '__main__':
    main()


# Optimized solution
def main():
    a, b, c = list(map(int, input().split()))

    if c - a - b <= 0:
        print('No')
        exit()

    if 4 * a * b < pow(c - a - b, 2):
        is_big = True
    else:
        is_big = False

    print(('Yes' if is_big else 'No'))

if __name__ == '__main__':
    main()
# Original solution
from decimal import *

a, b, c = list(map(int, input().split()))
if Decimal(a).sqrt() + Decimal(b).sqrt() < Decimal(c).sqrt():
    print("Yes")
else:
    print("No")


# Optimized solution
a, b, c = list(map(int,input().split()))

f = c - a - b
if f > 0 and f ** 2 > 4 * a * b:
    print('Yes')
else:
    print('No')
# Original solution


from decimal import Decimal
from decimal import *
a, b, c = list(map(str, input().split()))

getcontext().prec = 500

a = Decimal(a)
b = Decimal(b)
c = Decimal(c)

if a**Decimal("0.5")  + b**Decimal("0.5") < c**Decimal("0.5"):
    print("Yes")
else:
    print("No")


# Optimized solution


from decimal import Decimal
from decimal import *
a, b, c = list(map(str, input().split()))

#getcontext().prec = 1000

a = Decimal(a)
b = Decimal(b)
c = Decimal(c)

if a**Decimal("0.5")  + b**Decimal("0.5") < c**Decimal("0.5"):
    print("Yes")
else:
    print("No")
# Original solution
import math
from decimal import Decimal
a,b,c = [int(x) for x in input().split()]

if (Decimal(a).sqrt() + Decimal(b).sqrt()) < Decimal(c).sqrt():
    print("Yes")
else:
    print("No")


# Optimized solution
a,b,c = [int(x) for x in input().split()]

if c - a - b < 0:
    print("No")
elif 4 * a * b < (c - a - b) ** 2:
    print("Yes")
else:
    print("No")
# Original solution
from decimal import *
import math

getcontext().prec = 28

a, b, c = list(map(int, input().split()))
a = Decimal(a)
b = Decimal(b)
c = Decimal(c)

a = Decimal.sqrt(a)
b = Decimal.sqrt(b)
c = Decimal.sqrt(c)

if a + b < c:
    print("Yes")
else:
    print("No")


# Optimized solution
from decimal import *
import math

getcontext().prec = 50

a, b, c = list(map(int, input().split()))
a = Decimal(a)
b = Decimal(b)
c = Decimal(c)

a = Decimal.sqrt(a)
b = Decimal.sqrt(b)
c = Decimal.sqrt(c)

if a + b < c:
    print("Yes")
else:
    print("No")
# Original solution
from decimal import *
getcontext().prec=1000
a,b,c=list(map(int,input().split()))
A=Decimal(a)**Decimal("0.5")
B=Decimal(b)**Decimal("0.5")
C=Decimal(c)**Decimal("0.5")
D= Decimal(10) ** (-100)
if A+B+D<C:
    print("Yes")
else:
    print("No")

# Optimized solution
a,b,c=list(map(int,input().split()))
x=a**2 + b**2 + c**2 - 2*a*b - 2*a*c - 2*b*c
if x>0 and a+b-c<0:
    print("Yes")
else:
    print("No")
# Original solution

from decimal import Decimal
a, b, c = list(map(int, input().split()))
if Decimal(a).sqrt() + Decimal(b).sqrt() < Decimal(c).sqrt():
    print('Yes')
else:
    print('No')

# Optimized solution
a, b, c = list(map(int, input().split()))

if 4 * a * b < (c - a - b) ** 2 and c - a - b > 0:
    print('Yes')
else:
    print('No')
# Original solution
from math import sqrt
from decimal import *

a, b, c = list(map(int, input().split()))
getcontext().prec = 100000
if (Decimal(a).sqrt() + Decimal(b).sqrt() < Decimal(c).sqrt()): print('Yes')
else: print('No')


# Optimized solution
from math import sqrt
a, b, c = list(map(int, input().split()))
l = (a ** 2) + (b ** 2) + (c ** 2)
r = 2 * (a * b + b * c + c * a)

if (c-a-b > 0 and l > r): print('Yes')
elif(sqrt(c) == sqrt(a) + sqrt(b)): print('No')
else: print('No')