Language: C++

#include <bits/stdc++.h>

using namespace std;

#define countof(a) (sizeof(a)/sizeof(*a))

#define vi vector<int>
#define vvi vector<vector<int> >
#define vpi vector<pi >
#define pi pair<int,int>
#define fi first
#define se second
#define all(n) n.begin(), n.end()

#define FROMTO(var, from, to) for (register int var = (from), var##down = ((int)(to)) < ((int)(from));var##down ? (var >= (int)(to)) : (var <= (int)(to));var##down ? var-- : var++)
#define UPTO(var, from, to)   for (register int var = (from); var <= ((int)to); var++)
#define DOWNTO(var, from, to) for (register int var = (from); var >= ((int)to); var--)
#define FOR(var, to)          UPTO(var, 0, (to)-1)
#define DOWN(var, from)       DOWNTO(var, (from)-1, 0) 

#define INIT(var, val) FOR(i,countof(var)) var[i] = val
#define INPUT(var) FOR(i,countof(var)) cin >> var[i]
#define INPUT1(var) FOR(i,countof(var)) cin >> var[i], var[i]--

#define SORT(v) qsort(v,countof(v),sizeof(*v),int_less)
#define SORTT(v) qsort(v,countof(v),sizeof(*v),int_greater)
#define QSORT(v,b) qsort(v,countof(v),sizeof(*v),b)

#define MOD 1000000007
#define INF ((1 << 30)-1)
#define LINF ((1LL << 62)-1)

typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;

/* ------------------------ */
/* BEGIN EXTERNAL LIBRARIES */
/* ------------------------ */

template<int mod>
struct ModInt{
    int x;
    ModInt():x(0){}
    ModInt(long long y):x(y>=0?y%mod:(mod-(-y)%mod)%mod){}
    ModInt &operator+=(const ModInt &p){
        if((x+=p.x)>=mod)x-=mod;
        return *this;
    }
    ModInt &operator-=(const ModInt &p){
        if((x+=mod-p.x)>=mod)x-=mod;
        return *this;
    }
    ModInt &operator*=(const ModInt &p){
        x=(int)(1LL*x*p.x%mod);
        return *this;
    }
    ModInt &operator/=(const ModInt &p){
        *this*=p.inverse();
        return *this;
    }
    ModInt operator-()const{return ModInt(-x);}
    ModInt operator+(const ModInt &p)const{return ModInt(*this)+=p;}
    ModInt operator-(const ModInt &p)const{return ModInt(*this)-=p;}
    ModInt operator*(const ModInt &p)const{return ModInt(*this)*=p;}
    ModInt operator/(const ModInt &p)const{return ModInt(*this)/=p;}
    bool operator==(const ModInt &p)const{return x==p.x;}
    bool operator!=(const ModInt &p)const{return x!=p.x;}
    operator int() const { return x; }                           // added by QCFium
    ModInt operator=(const int p) {x = p; return ModInt(*this);} // added by QCFium
    ModInt inverse()const{
        int a=x,b=mod,u=1,v=0,t;
        while(b>0){
            t=a/b;
            a-=t*b;
            swap(a,b);
            u-=t*v;
            swap(u,v);
        }
        return ModInt(u);
    }
    friend ostream &operator<<(ostream &os,const ModInt<mod> &p){
        return os<<p.x;
    }
    friend istream &operator>>(istream &is,ModInt<mod> &a){
        long long x;
        is>>x;
        a=ModInt<mod>(x);
        return (is);
    }
};
typedef ModInt<MOD> mint;

struct UnionFind{
    vi data;
    UnionFind(int size):data(size,-1){}
    bool unite(int x,int y) {
        x=root(x);y=root(y);
        if(x!=y){
            if(data[y]<data[x])swap(x,y);
            data[x]+=data[y];data[y]=x;
        }
        return x!=y;
    }
    bool find(int x,int y) {
        return root(x)==root(y);
    }
    int root(int x) {
        return data[x]<0?x:data[x]=root(data[x]);
    }
    int size(int x) {
        return -data[root(x)];
    }
    // added by QCFium
    bool united() {
        int comroot = -1;
        FOR(i,data.size()) {
            if (comroot != -1 && root(i) != comroot) return false;
            comroot = root(i);
        }
        return true;
    }
};

/* ---------------------- */
/* END EXTERNAL LIBRARIES */
/* ---------------------- */

int mpow(s64 num, s64 times) { // O(log(times))
    mint next = num%MOD;
	mint res = 1;
	while (times) {
		if (times%2)
            res *= next;
		next *= next;
		times /= 2;
	}
	return res;
}

struct Comb {
    vector<vector<s64> > data;
    Comb(int n) { // O(n^2)
        data = vector<vector<s64> >(n+1,vector<s64>(n+1,1));
        UPTO(i,1,n) {
            FOR(j,i+1) {
                if (!j || j == i) data[i][j] = 1;
                else data[i][j] = data[i-1][j-1] + data[i-1][j];
            }
        }
    }
    
    s64 ncr(int n, int r) {
        return data[n][r];
    }
};

struct MComb {
    vector<mint> fact;
    vector<mint> inversed;
    MComb(int n) { // O(n+log(mod))
        fact = vector<mint>(n+1,1);
        UPTO(i,1,n) fact[i] = fact[i-1]*mint(i);
        inversed = vector<mint>(n+1);
        inversed[n] = mpow(fact[n], MOD-2);
        DOWN(i,n) inversed[i]=inversed[i+1]*mint(i+1);
    }
    
    int ncr(int n, int r) {
        return fact[n] * inversed[r] * inversed[n-r];
    }
    
    int npr(int n, int r) {
        return fact[n] * inversed[n-r];
    }
    
    int nhr(int n, int r) {
        assert(n+r-1 < (int)fact.size());
        return ncr(n+r-1, r);
    }
};

template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator+(set<Key>& a, set<Key>& b) {
    set<Key> c = a;
    for (auto i : b) 
        c.insert(i);
    return c;
}
template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator+=(set<Key>& a, set<Key>& b) {
    for (auto& i : b)
        a.insert(i);
    return a;
}

template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator*(set<Key>& a, set<Key>& b) {
    set<Key> c;
    for (auto& i : a)
        if (b.count(i)) c.insert(i);
    return c;
}
template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator*=(set<Key>& a, set<Key>& b) {
    set<Key> c;
    for (auto& i : a)
        if (b.count(i)) c.insert(i);
        
    return a = c;
}

template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator-(set<Key>& a, set<Key>& b) {
    set<Key> c;
    for (auto& i : a)
        if (!b.count(i)) c.insert(i);
        
    return c;
}
template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator-=(set<Key>& a, set<Key>& b) {
    set<Key> c;
    for (auto& i : a)
        if (!b.count(i)) c.insert(i);
        
    return a = c;
}

static inline int ri() {
  int a;
  scanf("%d", &a);
  return a;
}

int int_less(const void *a, const void *b) {
  return (*((const int*)a) - *((const int*)b));
}
int int_greater(const void *a, const void *b) {
  return (*((const int*)b) - *((const int*)a));
}

int main() {
	int n = ri();
	puts(n == 5 || n == 7 || n == 3 ? "YES" : "NO");
    return 0;
}
​#include <bits/stdc++.h>

using namespace std;

#define countof(a) (sizeof(a)/sizeof(*a))

#define vi vector<int>
#define vvi vector<vector<int> >
#define vpi vector<pi >
#define pi pair<int,int>
#define fi first
#define se second
#define all(n) n.begin(), n.end()

#define FROMTO(var, from, to) for (register int var = (from), var##down = ((int)(to)) < ((int)(from));var##down ? (var >= (int)(to)) : (var <= (int)(to));var##down ? var-- : var++)
#define UPTO(var, from, to)   for (register int var = (from); var <= ((int)to); var++)
#define DOWNTO(var, from, to) for (register int var = (from); var >= ((int)to); var--)
#define FOR(var, to)          UPTO(var, 0, (to)-1)
#define DOWN(var, from)       DOWNTO(var, (from)-1, 0) 

#define INIT(var, val) FOR(i,countof(var)) var[i] = val
#define INPUT(var) FOR(i,countof(var)) cin >> var[i]
#define INPUT1(var) FOR(i,countof(var)) cin >> var[i], var[i]--

#define SORT(v) qsort(v,countof(v),sizeof(*v),int_less)
#define SORTT(v) qsort(v,countof(v),sizeof(*v),int_greater)
#define QSORT(v,b) qsort(v,countof(v),sizeof(*v),b)

#define MOD 1000000007
#define INF ((1 << 30)-1)
#define LINF ((1LL << 62)-1)

typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;

/* ------------------------ */
/* BEGIN EXTERNAL LIBRARIES */
/* ------------------------ */

template<int mod>
struct ModInt{
    int x;
    ModInt():x(0){}
    ModInt(long long y):x(y>=0?y%mod:(mod-(-y)%mod)%mod){}
    ModInt &operator+=(const ModInt &p){
        if((x+=p.x)>=mod)x-=mod;
        return *this;
    }
    ModInt &operator-=(const ModInt &p){
        if((x+=mod-p.x)>=mod)x-=mod;
        return *this;
    }
    ModInt &operator*=(const ModInt &p){
        x=(int)(1LL*x*p.x%mod);
        return *this;
    }
    ModInt &operator/=(const ModInt &p){
        *this*=p.inverse();
        return *this;
    }
    ModInt operator-()const{return ModInt(-x);}
    ModInt operator+(const ModInt &p)const{return ModInt(*this)+=p;}
    ModInt operator-(const ModInt &p)const{return ModInt(*this)-=p;}
    ModInt operator*(const ModInt &p)const{return ModInt(*this)*=p;}
    ModInt operator/(const ModInt &p)const{return ModInt(*this)/=p;}
    bool operator==(const ModInt &p)const{return x==p.x;}
    bool operator!=(const ModInt &p)const{return x!=p.x;}
    operator int() const { return x; }                           // added by QCFium
    ModInt operator=(const int p) {x = p; return ModInt(*this);} // added by QCFium
    ModInt inverse()const{
        int a=x,b=mod,u=1,v=0,t;
        while(b>0){
            t=a/b;
            a-=t*b;
            swap(a,b);
            u-=t*v;
            swap(u,v);
        }
        return ModInt(u);
    }
    friend ostream &operator<<(ostream &os,const ModInt<mod> &p){
        return os<<p.x;
    }
    friend istream &operator>>(istream &is,ModInt<mod> &a){
        long long x;
        is>>x;
        a=ModInt<mod>(x);
        return (is);
    }
};
typedef ModInt<MOD> mint;

struct UnionFind{
    vi data;
    UnionFind(int size):data(size,-1){}
    bool unite(int x,int y) {
        x=root(x);y=root(y);
        if(x!=y){
            if(data[y]<data[x])swap(x,y);
            data[x]+=data[y];data[y]=x;
        }
        return x!=y;
    }
    bool find(int x,int y) {
        return root(x)==root(y);
    }
    int root(int x) {
        return data[x]<0?x:data[x]=root(data[x]);
    }
    int size(int x) {
        return -data[root(x)];
    }
    // added by QCFium
    bool united() {
        int comroot = -1;
        FOR(i,data.size()) {
            if (comroot != -1 && root(i) != comroot) return false;
            comroot = root(i);
        }
        return true;
    }
};

/* ---------------------- */
/* END EXTERNAL LIBRARIES */
/* ---------------------- */

int mpow(s64 num, s64 times) { // O(log(times))
    mint next = num%MOD;
	mint res = 1;
	while (times) {
		if (times%2)
            res *= next;
		next *= next;
		times /= 2;
	}
	return res;
}

struct Comb {
    vector<vector<s64> > data;
    Comb(int n) { // O(n^2)
        data = vector<vector<s64> >(n+1,vector<s64>(n+1,1));
        UPTO(i,1,n) {
            FOR(j,i+1) {
                if (!j || j == i) data[i][j] = 1;
                else data[i][j] = data[i-1][j-1] + data[i-1][j];
            }
        }
    }
    
    s64 ncr(int n, int r) {
        return data[n][r];
    }
};

struct MComb {
    vector<mint> fact;
    vector<mint> inversed;
    MComb(int n) { // O(n+log(mod))
        fact = vector<mint>(n+1,1);
        UPTO(i,1,n) fact[i] = fact[i-1]*mint(i);
        inversed = vector<mint>(n+1);
        inversed[n] = mpow(fact[n], MOD-2);
        DOWN(i,n) inversed[i]=inversed[i+1]*mint(i+1);
    }
    
    int ncr(int n, int r) {
        return fact[n] * inversed[r] * inversed[n-r];
    }
    
    int npr(int n, int r) {
        return fact[n] * inversed[n-r];
    }
    
    int nhr(int n, int r) {
        assert(n+r-1 < (int)fact.size());
        return ncr(n+r-1, r);
    }
};

template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator+(set<Key>& a, set<Key>& b) {
    set<Key> c = a;
    for (auto i : b) 
        c.insert(i);
    return c;
}
template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator+=(set<Key>& a, set<Key>& b) {
    for (auto& i : b)
        a.insert(i);
    return a;
}

template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator*(set<Key>& a, set<Key>& b) {
    set<Key> c;
    for (auto& i : a)
        if (b.count(i)) c.insert(i);
    return c;
}
template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator*=(set<Key>& a, set<Key>& b) {
    set<Key> c;
    for (auto& i : a)
        if (b.count(i)) c.insert(i);
        
    return a = c;
}

template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator-(set<Key>& a, set<Key>& b) {
    set<Key> c;
    for (auto& i : a)
        if (!b.count(i)) c.insert(i);
        
    return c;
}
template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
set<Key> operator-=(set<Key>& a, set<Key>& b) {
    set<Key> c;
    for (auto& i : a)
        if (!b.count(i)) c.insert(i);
        
    return a = c;
}

static inline int ri() {
  int a;
  scanf("%d", &a);
  return a;
}

int int_less(const void *a, const void *b) {
  return (*((const int*)a) - *((const int*)b));
}
int int_greater(const void *a, const void *b) {
  return (*((const int*)b) - *((const int*)a));
}

int main() {
	int n = ri();
	puts(n == 5 || n == 7 || n == 3 ? "YES" : "NO");
    return 0;
}


Compiler output:
a.cc:253:1: error: stray '#' in program
  253 | ​#include <bits/stdc++.h>
      | ^
a.cc: In member function 'bool UnionFind::united()':
a.cc:122:13: warning: ISO C++17 does not allow 'register' storage class specifier [-Wregister]
  122 |         FOR(i,data.size()) {
      |             ^
a.cc:16:49: note: in definition of macro 'UPTO'
   16 | #define UPTO(var, from, to)   for (register int var = (from); var <= ((int)to); var++)
      |                                                 ^~~
a.cc:122:9: note: in expansion of macro 'FOR'
  122 |         FOR(i,data.size()) {
      |         ^~~
a.cc: In constructor 'Comb::Comb(int)':
a.cc:150:14: warning: ISO C++17 does not allow 'register' storage class specifier [-Wregister]
  150 |         UPTO(i,1,n) {
      |              ^
a.cc:16:49: note: in definition of macro 'UPTO'
   16 | #define UPTO(var, from, to)   for (register int var = (from); var <= ((int)to); var++)
      |                                                 ^~~
a.cc:151:17: warning: ISO C++17 does not allow 'register' storage class specifier [-Wregister]
  151 |             FOR(j,i+1) {
      |                 ^
a.cc:16:49: note: in definition of macro 'UPTO'
   16 | #define UPTO(var, from, to)   for (register int var = (from); var <= ((int)to); var++)
      |                                                 ^~~
a.cc:151:13: note: in expansion of macro 'FOR'
  151 |             FOR(j,i+1) {
      |             ^~~
a.cc: In constructor 'MComb::MComb(int)':
a.cc:168:14: warning: ISO C++17 does not allow 'register' storage class specifier [-Wregister]
  168 |         UPTO(i,1,n) fact[i] = fact[i-1]*mint(i);
      |              ^
a.cc:16:49: note: in definition of macro 'UPTO'
   16 | #define UPTO(var, from, to)   for (register int var = (from); var <= ((int)to); var++)
      |                                                 ^~~
a.cc:171:14: warning: ISO C++17 does not allow 'register' storage class specifier [-Wregister]
  171 |         DOWN(i,n) inversed[i]=inversed[i+1]*mint(i+1);
      |              ^
a.cc:17:49: note: in definition of macro 'DOWNTO'
   17 | #define DOWNTO(var, from, to) for (register int var = (from); var >= ((int)to); var--)
      |                                                 ^~~
a.cc:171:9: note: in expansion of macro 'DOWN'
  171 |         DOWN(i,n) inversed[i]=inversed[i+1]*mint(i+1);
      |         ^~~~
a.cc: At global scope:
a.cc:253:1: error: '​' does not name a type
  253 | ​#include <bits/stdc++.h>
      |  
a.cc:299:8: error: redefinition of 'struct ModInt<mod>'
  299 | struct ModInt{
      |        ^~~~~~
a.cc:47:8: note: previous definition of 'struct ModInt<mod>'
   47 | struct ModInt{
      |        ^~~~~~
a.cc:351:8: error: redefinition of 'struct UnionFind'
  351 | struct UnionFind{
      |        ^~~~~~~~~
a.cc:99:8: note: previous definition of 'struct UnionFind'
   99 | struct UnionFind{
      |        ^~~~~~~~~
a.cc:386:5: error: redefinition of 'int mpow(s64, s64)'
  386 | int mpow(s64 num, s64 times) { // O(log(times))
      |     ^~~~
a.cc:134:5: note: 'int mpow(s64, s64)' previously defined here
  134 | int mpow(s64 num, s64 times) { // O(log(times))
      |     ^~~~
a.cc:398:8: error: redefinition of 'struct Comb'
  398 | struct Comb {
      |        ^~~~
a.cc:146:8: note: previous definition of 'struct Comb'
  146 | struct Comb {
      |        ^~~~
a.cc:415:8: error: redefinition of 'struct MComb'
  415 | struct MComb {
      |        ^~~~~
a.cc:163:8: note: previous definition of 'struct MComb'
  163 | struct MComb {
      |        ^~~~~
a.cc:441:10: error: redefinition of 'template<class Key, class Compare, class Allocator> std::set<Key> operator+(std::set<Key>&, std::set<Key>&)'
  441 | set<Key> operator+(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:189:10: note: 'template<class Key, class Compare, class Allocator> std::set<Key> operator+(std::set<Key>&, std::set<Key>&)' previously declared here
  189 | set<Key> operator+(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:448:10: error: redefinition of 'template<class Key, class Compare, class Allocator> std::set<Key> operator+=(std::set<Key>&, std::set<Key>&)'
  448 | set<Key> operator+=(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:196:10: note: 'template<class Key, class Compare, class Allocator> std::set<Key> operator+=(std::set<Key>&, std::set<Key>&)' previously declared here
  196 | set<Key> operator+=(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:455:10: error: redefinition of 'template<class Key, class Compare, class Allocator> std::set<Key> operator*(std::set<Key>&, std::set<Key>&)'
  455 | set<Key> operator*(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:203:10: note: 'template<class Key, class Compare, class Allocator> std::set<Key> operator*(std::set<Key>&, std::set<Key>&)' previously declared here
  203 | set<Key> operator*(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:462:10: error: redefinition of 'template<class Key, class Compare, class Allocator> std::set<Key> operator*=(std::set<Key>&, std::set<Key>&)'
  462 | set<Key> operator*=(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:210:10: note: 'template<class Key, class Compare, class Allocator> std::set<Key> operator*=(std::set<Key>&, std::set<Key>&)' previously declared here
  210 | set<Key> operator*=(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:471:10: error: redefinition of 'template<class Key, class Compare, class Allocator> std::set<Key> operator-(std::set<Key>&, std::set<Key>&)'
  471 | set<Key> operator-(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:219:10: note: 'template<class Key, class Compare, class Allocator> std::set<Key> operator-(std::set<Key>&, std::set<Key>&)' previously declared here
  219 | set<Key> operator-(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:479:10: error: redefinition of 'template<class Key, class Compare, class Allocator> std::set<Key> operator-=(std::set<Key>&, std::set<Key>&)'
  479 | set<Key> operator-=(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:227:10: note: 'template<class Key, class Compare, class Allocator> std::set<Key> operator-=(std::set<Key>&, std::set<Key>&)' previously declared here
  227 | set<Key> operator-=(set<Key>& a, set<Key>& b) {
      |          ^~~~~~~~
a.cc:487:19: error: redefinition of 'int ri()'
  487 | static inline int ri() {
      |                   ^~
a.cc:235:19: note: 'int ri()' previously defined here
  235 | static inline int ri() {
      |                   ^~
a.cc:493:5: error: redefinition of 'int int_less(const void*, const void*)'
  493 | int int_less(const void *a, const void *b) {
      |     ^~~~~~~~
a.cc:241:5: note: 'int int_less(const void*, const void*)' previously defined here
  241 | int int_less(const void *a, const void *b) {
      |     ^~~~~~~~
a.cc:496:5: error: redefinition of 'int int_greater(const void*, const void*)'
  496 | int int_greater(const void *a, const void *b) {
      |     ^~~~~~~~~~~
a.cc:244:5: note: 'int int_greater(const void*, const void*)' previously defined here
  244 | int int_greater(const void *a, const void *b) {
      |     ^~~~~~~~~~~
a.cc:500:5: error: redefinition of 'int main()'
  500 | int main() {
      |     ^~~~
a.cc:248:5: note: 'int main()' previously defined here
  248 | int main() {
      |     ^~~~