//Generated at 2020-03-16 00:17:49 UTC+8
//Created by Alphagocc
#include<bits/stdc++.h>
#ifdef USE_PBDS
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/priority_queue.hpp>
#endif
#define FORCE_INLINE __inline__ __attribute__((always_inline))
class IO
{
static const int bufSize=1<<18;char inBuf[bufSize],outBuf[bufSize];char*ip1=inBuf,*ip2=inBuf;int goodReadBit=0,op1=-1,op2=bufSize-1;
template <typename T>FORCE_INLINE void __RI(T&x){int ch=gc(),neg=1;x=0;for(;!(isdigit(ch)||ch=='-'||ch==EOF);ch=gc());if(ch==EOF){goodReadBit=0;return;}if(ch=='-')neg=-1,ch=gc();for(;isdigit(ch);ch=gc())x=x * 10 +(ch - 48) * neg;}
template <typename T>FORCE_INLINE void __RC(T&x){unsigned char ch;while(isspace(ch=gc()));x=ch;}
FORCE_INLINE void __RS(std::string&x){char ch;x.clear();for(ch=gc();isspace(ch);ch=gc());if(ch==EOF){goodReadBit=0;return;}for(;!isspace(ch);ch=gc())x.push_back(ch);}
public:
FORCE_INLINE int gc(){return ip1==ip2 &&(ip2 =(ip1=inBuf)+fread(inBuf,1,bufSize,stdin),ip1==ip2)? EOF: *ip1++;}
FORCE_INLINE void R(char&x){__RC(x);}FORCE_INLINE void R(unsigned char&x){__RC(x);}FORCE_INLINE void R(std::string&x){__RS(x);}
template <typename T1,typename T2>FORCE_INLINE void R(std::pair<T1,T2>&x){R(x.first),R(x.second);}template <typename T>FORCE_INLINE void R(std::vector<T>&x){for(auto it=x.begin();it != x.end();++it)R(*it);}
template <typename T,typename...Args>FORCE_INLINE void RA(T*a,int n){for(int i=0;i < n;++i)R(a[i]);}template <typename T,typename...Args>FORCE_INLINE void R(T&x,Args&...args){R(x),R(args...);}
template <typename T,typename...Args>FORCE_INLINE void RA(T*a,int n,Args...args){for(int i=0;i < n;++i)RA(a[i],args...);}template <typename T>FORCE_INLINE void R(T&x){static_assert(std::is_integral<T>::value,"Unsupported types");if(std::is_integral<T>::value)__RI(x);}
private:
char space;template <typename T>FORCE_INLINE void __WI(T x){static char buf[64];static int len=-1;if(x >= 0){do{buf[++len]=x % 10+48,x /= 10;} while(x);} else{pc('-');do{buf[++len]=-(x%10)+48,x/=10;}while(x);}while(len>=0){pc(buf[len]),--len;}}
public:
FORCE_INLINE void pc(const char&x){if(op1==op2)flush();outBuf[++op1]=x;}
FORCE_INLINE void flush(){fwrite(outBuf,1,op1+1,stdout),op1=-1;}FORCE_INLINE void W(const char&x){pc(x);}FORCE_INLINE void W(const char* x){while(*x!='\0')pc(*(x++));}FORCE_INLINE void W(const std::string&x){W(x.c_str());}
template <typename T>FORCE_INLINE void W(const std::vector<T>&x){for(auto it=x.begin();it != x.end();it++)WS(*it);WL();}FORCE_INLINE void WL(){W('\n');}
template <typename T>FORCE_INLINE void WL(const T&x){W(x),W('\n');}FORCE_INLINE void WS(){W(' ');}
template <typename T>FORCE_INLINE void WS(const T&x){W(x),W(space);}
template <typename T>FORCE_INLINE void WA(T* a,int n){for(int i=0;i < n;i++)WS(a[i]);WL();}
template <typename T,typename...Args>FORCE_INLINE void W(const T&x,const Args&...args){W(x),W(space),W(args...);}
template <typename...Args>FORCE_INLINE void WL(const Args&...args){W(args...),W('\n');}
template <typename T,typename...Args>FORCE_INLINE void WA(T* a,int n,Args...args){for(int i=0;i < n;i++)WA(a[i],args...);}
template <typename T>FORCE_INLINE void W(const T&x){static_assert(std::is_integral<T>::value,"Unsupported types");if(std::is_integral<T>::value)__WI(x);}
template <typename T>FORCE_INLINE IO&operator>>(T&x){R(x);return(*this);}
template <typename T>FORCE_INLINE IO&operator<<(const T&x){W(x);return(*this);}IO(){space=' ';}
} io;
namespace Alphagocc{decltype(std::chrono::high_resolution_clock::now()) tStart;};void TimeBegin(){Alphagocc::tStart=std::chrono::high_resolution_clock::now();}long long TimeEnd(){return(std::chrono::high_resolution_clock::now() - Alphagocc::tStart).count();} // namespace Alphagocc
using namespace std;
#define REP(i,x,y) for(int i=x;i < y;i++)
const int8_t INFC=0x3f;
const int16_t INFS=0x3f3f;
const int32_t INF=0x3f3f3f3f;
const int64_t INFL=0x3f3f3f3f3f3f3f3fLL;

typedef union {
    __float128 value;

    struct
#ifdef __MINGW32__
        /* On mingw targets the ms-bitfields option is active by default.
           Therefore enforce gnu-bitfield style.  */
        __attribute__((gcc_struct))
#endif
    {
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        unsigned negative : 1;
        unsigned exponent : 15;
        unsigned mantissa0 : 16;
        unsigned mantissa1 : 32;
        unsigned mantissa2 : 32;
        unsigned mantissa3 : 32;
#else
        unsigned mantissa3 : 32;
        unsigned mantissa2 : 32;
        unsigned mantissa1 : 32;
        unsigned mantissa0 : 16;
        unsigned exponent : 15;
        unsigned negative : 1;
#endif
    } ieee;

    struct
    {
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        uint64_t high;
        uint64_t low;
#else
        uint64_t low;
        uint64_t high;
#endif
    } words64;

    struct
    {
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        uint32_t w0;
        uint32_t w1;
        uint32_t w2;
        uint32_t w3;
#else
        uint32_t w3;
        uint32_t w2;
        uint32_t w1;
        uint32_t w0;
#endif
    } words32;

    struct
#ifdef __MINGW32__
        /* Make sure we are using gnu-style bitfield handling.  */
        __attribute__((gcc_struct))
#endif
    {
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        unsigned negative : 1;
        unsigned exponent : 15;
        unsigned quiet_nan : 1;
        unsigned mantissa0 : 15;
        unsigned mantissa1 : 32;
        unsigned mantissa2 : 32;
        unsigned mantissa3 : 32;
#else
        unsigned mantissa3 : 32;
        unsigned mantissa2 : 32;
        unsigned mantissa1 : 32;
        unsigned mantissa0 : 15;
        unsigned quiet_nan : 1;
        unsigned exponent : 15;
        unsigned negative : 1;
#endif
    } ieee_nan;

} ieee854_float128;
#define GET_FLT128_WORDS64(ix0, ix1, d)                                        \
    do {                                                                       \
        ieee854_float128 u;                                                    \
        u.value = (d);                                                         \
        (ix0) = u.words64.high;                                                \
        (ix1) = u.words64.low;                                                 \
    } while (0)
int isinfq(__float128 x)
{
    int64_t hx, lx;
    GET_FLT128_WORDS64(hx, lx, x);
    lx |= (hx & 0x7fffffffffffffffLL) ^ 0x7fff000000000000LL;
    lx |= -lx;
    return ~(lx >> 63) & (hx >> 62);
}
int isnanq(__float128 x)
{
    int64_t hx, lx;
    GET_FLT128_WORDS64(hx, lx, x);
    hx &= 0x7fffffffffffffffLL;
    hx |= (uint64_t)(lx | (-lx)) >> 63;
    hx = 0x7fff000000000000LL - hx;
    return (int)((uint64_t)hx >> 63);
}
__float128 sqrtq(const __float128 x)
{
    __float128 y;
    int exp;

    if (isnanq(x) || (isinfq(x) && x > 0)) return x;

    if (x == 0) return x;

    if (x < 0) {
        /* Return NaN with invalid signal.  */
        return (x - x) / (x - x);
    }
    {
        long double xl = (long double)x;
        if (xl <= LDBL_MAX && xl >= LDBL_MIN) {
            /* Use long double result as starting point.  */
            y = (__float128)sqrtl(xl);

            /* One Newton iteration.  */
            y -= 0.5 * (y - x / y);
            return y;
        }
    }
}
namespace Alphagocc
{
int MAIN()
{
    int a, b, c;
    io >> a >> b >> c;
    __float128 m = 1LL * a * b;
    __float128 x = sqrtq(m) * 2;
    io.WL(__float128(a) + x + __float128(b) < __float128(c) ? "Yes" : "No");
    io.flush();
    return 0;
}
} // namespace Alphagocc
int main() { return Alphagocc::MAIN(); }

Measured memory_bytes: 256