Language: C++

#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define FOR(i,start,end) for(int i=start;i<=end;i++)
const int INF = 1001001001;
typedef long long ll;
const ll MOD=1000000007;
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class T>auto MAX(const T& a) { return *max_element(a.begin(),a.end()); }
template<class T>auto MIN(const T& a) { return *min_element(a.begin(),a.end()); }
template<class T, class U>U SUM(const T& a, const U& v) { return accumulate(a.begin(),a.end(), v); }
template<class T, class U>U COUNT(const T& a, const U& v) { return count(a.begin(),a.end(), v); }
template<class T, class U>int LOWER(const T& a, const U& v) { return lower_bound(a.begin(),a.end(), v) - a.begin(); }
template<class T, class U>int UPPER(const T& a, const U& v) { return upper_bound(a.begin(),a.end(), v) - a.begin(); }
int GCD(int a, int b) { return b ? GCD(b, a%b) : a; }
int LCM(int a, int b) { int g = GCD(a, b); return a / g * b; }

int main(void){
    // Your code here!
    long double a,b,c; cin >> a >> b >> c;
    a = sqrt(a);
    b = sqrt(b);
    c = sqrt(c);
    if (a + b < c ) cout << "Yes" << endl;
    else cout << "No" << endl;
}
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define FOR(i,start,end) for(int i=start;i<=end;i++)
const int INF = 1001001001;
typedef long long ll;
const ll MOD=1000000007;
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class T>auto MAX(const T& a) { return *max_element(a.begin(),a.end()); }
template<class T>auto MIN(const T& a) { return *min_element(a.begin(),a.end()); }
template<class T, class U>U SUM(const T& a, const U& v) { return accumulate(a.begin(),a.end(), v); }
template<class T, class U>U COUNT(const T& a, const U& v) { return count(a.begin(),a.end(), v); }
template<class T, class U>int LOWER(const T& a, const U& v) { return lower_bound(a.begin(),a.end(), v) - a.begin(); }
template<class T, class U>int UPPER(const T& a, const U& v) { return upper_bound(a.begin(),a.end(), v) - a.begin(); }
int GCD(int a, int b) { return b ? GCD(b, a%b) : a; }
int LCM(int a, int b) { int g = GCD(a, b); return a / g * b; }

int main(void){
    // Your code here!
    long double a,b,c; cin >> a >> b >> c;
    a = sqrt(a);
    b = sqrt(b);
    c = sqrt(c);
    if (a + b < c ) cout << "Yes" << endl;
    else cout << "No" << endl;
}


Compiler output:
a.cc:31:11: error: redefinition of 'const int INF'
   31 | const int INF = 1001001001;
      |           ^~~
a.cc:4:11: note: 'const int INF' previously defined here
    4 | const int INF = 1001001001;
      |           ^~~
a.cc:33:10: error: redefinition of 'const ll MOD'
   33 | const ll MOD=1000000007;
      |          ^~~
a.cc:6:10: note: 'const ll MOD' previously defined here
    6 | const ll MOD=1000000007;
      |          ^~~
a.cc:35:31: error: redefinition of 'template<class T> bool chmax(T&, T)'
   35 | template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
      |                               ^~~~~
a.cc:8:31: note: 'template<class T> bool chmax(T&, T)' previously declared here
    8 | template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
      |                               ^~~~~
a.cc:36:31: error: redefinition of 'template<class T> bool chmin(T&, T)'
   36 | template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
      |                               ^~~~~
a.cc:9:31: note: 'template<class T> bool chmin(T&, T)' previously declared here
    9 | template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
      |                               ^~~~~
a.cc:37:23: error: redefinition of 'template<class T> auto MAX(const T&)'
   37 | template<class T>auto MAX(const T& a) { return *max_element(a.begin(),a.end()); }
      |                       ^~~
a.cc:10:23: note: 'template<class T> auto MAX(const T&)' previously declared here
   10 | template<class T>auto MAX(const T& a) { return *max_element(a.begin(),a.end()); }
      |                       ^~~
a.cc:38:23: error: redefinition of 'template<class T> auto MIN(const T&)'
   38 | template<class T>auto MIN(const T& a) { return *min_element(a.begin(),a.end()); }
      |                       ^~~
a.cc:11:23: note: 'template<class T> auto MIN(const T&)' previously declared here
   11 | template<class T>auto MIN(const T& a) { return *min_element(a.begin(),a.end()); }
      |                       ^~~
a.cc:39:29: error: redefinition of 'template<class T, class U> U SUM(const T&, const U&)'
   39 | template<class T, class U>U SUM(const T& a, const U& v) { return accumulate(a.begin(),a.end(), v); }
      |                             ^~~
a.cc:12:29: note: 'template<class T, class U> U SUM(const T&, const U&)' previously declared here
   12 | template<class T, class U>U SUM(const T& a, const U& v) { return accumulate(a.begin(),a.end(), v); }
      |                             ^~~
a.cc:40:29: error: redefinition of 'template<class T, class U> U COUNT(const T&, const U&)'
   40 | template<class T, class U>U COUNT(const T& a, const U& v) { return count(a.begin(),a.end(), v); }
      |                             ^~~~~
a.cc:13:29: note: 'template<class T, class U> U COUNT(const T&, const U&)' previously declared here
   13 | template<class T, class U>U COUNT(const T& a, const U& v) { return count(a.begin(),a.end(), v); }
      |                             ^~~~~
a.cc:41:31: error: redefinition of 'template<class T, class U> int LOWER(const T&, const U&)'
   41 | template<class T, class U>int LOWER(const T& a, const U& v) { return lower_bound(a.begin(),a.end(), v) - a.begin(); }
      |                               ^~~~~
a.cc:14:31: note: 'template<class T, class U> int LOWER(const T&, const U&)' previously declared here
   14 | template<class T, class U>int LOWER(const T& a, const U& v) { return lower_bound(a.begin(),a.end(), v) - a.begin(); }
      |                               ^~~~~
a.cc:42:31: error: redefinition of 'template<class T, class U> int UPPER(const T&, const U&)'
   42 | template<class T, class U>int UPPER(const T& a, const U& v) { return upper_bound(a.begin(),a.end(), v) - a.begin(); }
      |                               ^~~~~
a.cc:15:31: note: 'template<class T, class U> int UPPER(const T&, const U&)' previously declared here
   15 | template<class T, class U>int UPPER(const T& a, const U& v) { return upper_bound(a.begin(),a.end(), v) - a.begin(); }
      |                               ^~~~~
a.cc:43:5: error: redefinition of 'int GCD(int, int)'
   43 | int GCD(int a, int b) { return b ? GCD(b, a%b) : a; }
      |     ^~~
a.cc:16:5: note: 'int GCD(int, int)' previously defined here
   16 | int GCD(int a, int b) { return b ? GCD(b, a%b) : a; }
      |     ^~~
a.cc:44:5: error: redefinition of 'int LCM(int, int)'
   44 | int LCM(int a, int b) { int g = GCD(a, b); return a / g * b; }
      |     ^~~
a.cc:17:5: note: 'int LCM(int, int)' previously defined here
   17 | int LCM(int a, int b) { int g = GCD(a, b); return a / g * b; }
      |     ^~~
a.cc:46:5: error: redefinition of 'int main()'
   46 | int main(void){
      |     ^~~~
a.cc:19:5: note: 'int main()' previously defined here
   19 | int main(void){
      |     ^~~~