stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<stdlib.h>

using namespace std;

const int N=1e4+50;

const int INF=0x3f3f3f;

char s[N];

int vis[N];

int main()

{

    scanf("%s",s);

    int len=strlen(s);

    for(int i=0;i<len;i++)

    {

        vis[(int)s[i]]++;

    }

    for(int i=97;i<=122;i++)

    {

        if(vis[i]%2!=0)

        {

            printf("No\n");

            return 0;

        }

    }

    printf("Yes\n");

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.253612260777039x):
#include <stdio.h>



int main()

{

	char w[1000];

	scanf("%s", w);

	int alp[26];

	for(int i=0; i<26; i++){

		alp[i]=0;

	}

	for(int i=0; w[i]!='\0'; i++){

		for(int j=97; j<123; j++){

			if(w[i]==j)

				alp[j-97]++;

		}

	}

	for(int i=0; i<26; i++){

		if(alp[i]%2!=0){

			printf("No\n");	return 0;

		}

	}



	printf("Yes\n");



	return 0;

}
// Slower C++ solution:
#include <iostream>

#include <cstring>

#include <cstdlib>

#include <cmath>

#include <algorithm>

#include <functional>

#include <vector>

#include <queue>

#include <stack>

#include <map>

#include <set>

#include <bitset>

#include <cassert>

#include <exception>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

typedef vector<int> vi;

typedef vector<ll> vll;

typedef vector<string> vs;

typedef pair<int,int> P;

#define rep(i,a,n) for(ll i = (a);i < (n);i++)

#define per(i,a,n) for(ll i = (a);i > (n);i--)

#define lep(i,a,n) for(ll i = (a);i <= (n);i++)

#define pel(i,a,n) for(ll i = (a);i >= (n);i--)

#define clr(a,b) memset((a),(b),sizeof(a))

#define pb push_back

#define mp make_pair

#define all(c) (c).begin(),(c).end()

#define sz size()

#define print(X) cout << (X) << endl

const ll INF = 1e+9+7;

ll n,m,l;

string s,t;

ll d[100000],dp[100][100];



int main(){

  cin >> s;

  clr(d,0);

  rep(i,0,s.sz)d[s[i]-'a']++;

  s = "Yes";

  rep(i,0,26){

    if(d[i] % 2 != 0)s = "No";

  }

  print(s);

  return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.818035641680936x):
#include <iostream>

#include <cstring>

#include <cstdlib>

#include <cmath>

#include <algorithm>

#include <functional>

#include <vector>

#include <queue>

#include <stack>

#include <map>

#include <set>

#include <bitset>

#include <cassert>

#include <exception>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

typedef pair<ll,ll> P;

typedef vector<int> vi;

typedef vector<ll> vll;

typedef vector<string> vs;

typedef vector<P> vp;

#define rep(i,a,n) for(ll i = (a);i < (n);i++)

#define per(i,a,n) for(ll i = (a);i > (n);i--)

#define lep(i,a,n) for(ll i = (a);i <= (n);i++)

#define pel(i,a,n) for(ll i = (a);i >= (n);i--)

#define clr(a,b) memset((a),(b),sizeof(a))

#define pb push_back

#define mp make_pair

#define all(c) (c).begin(),(c).end()

#define sz size()

#define print(X) cout << (X) << endl

const ll INF = 1e+9+7;

ll n,m,l;

string s,t;

ll d[200010],dp[500][500];



int main(){

  cin >> s;

  rep(i,0,s.sz)d[s[i]-'a']++;

  l = 0;

  rep(i,0,26)if(d[i] % 2 != 0)l++;

  if(l != 0)puts("No");

  else puts("Yes");

  return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

#define rep(i,n) for(int i=0;i<(int)(n);++i)

#define pb(a) push_back(a)

#define mp(a,b) make_pair(a,b)

#define ALL(a) (a).begin(),(a).end()

#define F first

#define S second

typedef pair<int,int> PI;





int m,t,p,r;



int app[400][400];

int pena[400];





void solve(){

  memset(app,0,sizeof(app));

  memset(pena,0,sizeof(pena));  

  

  vector<int> sol(10000);

  

  rep(i,r){

    int mk,tk,pk,jk;

    cin >> mk >> tk >> pk >> jk;

    if(jk==0){

      pena[tk] += app[tk][pk]*20+mk;

      ++sol[tk];

    }else{

      ++app[tk][pk];

    }

  }



  vector<pair<PI,int> > team;

  

  rep(i,t){

    team.pb(mp(mp(-sol[i+1],pena[i+1]),-i-1));

  }



  

  sort(ALL(team));

  rep(i,t){

    if(i){

      if(team[i-1].F == team[i].F) cout << "=";

      else cout << ",";

    }

    cout << -team[i].S;

  }

  cout << endl;

}



int main(){

  while(cin >> m >> t >> p >> r && m) solve();

}

// Faster C++ solution for the same problem (measured speedup: 2.2947142837867727x):
#include <cstdio>

#include <vector>

#include <algorithm>



using namespace std;



int a[50][2];

int b[50][10];



int main()

{

  while (1) {

    int m, t, p, r, i, j;

    vector <pair<int, pair<int, int> > > v;



    scanf("%d %d %d %d", &m, &t, &p, &r);



    if (m == 0 && t == 0 && p == 0 && r == 0) break;



    for (i = 0; i < t; i++) a[i][0] = a[i][1] = 0;

    for (i = 0; i < t; i++) {

      for (j = 0; j < p; j++) {

        b[i][j] = 0;

      }

    }



    for (i = 0; i < r; i++) {

      int m, t, p, j;



      scanf("%d %d %d %d", &m, &t, &p, &j);



      t--;

      p--;



      if (j == 0) {

        a[t][0]++;

        a[t][1] += b[t][p];

        a[t][1] += m;

      } else {

        b[t][p] += 20;

      }

    }



    for (i = 0; i < t; i++) v.push_back(make_pair(a[i][0], make_pair(-a[i][1], i + 1)));



    sort(v.begin(), v.end());

    reverse(v.begin(), v.end());



    printf("%d", v[0].second.second);



    for (i = 1; i < v.size(); i++) {

      if (v[i].first == v[i - 1].first && v[i].second.first == v[i - 1].second.first) {

        putchar('=');

      } else {

        putchar(',');

      }



      printf("%d", v[i].second.second);

    }



    puts("");

  }



  return 0;

}
// Slower C++ solution:
#include <stdio.h>

#include <algorithm>

using namespace std;



int N, C, A[6], bc[1 << 5];

int P[333], Q[333], M[1<<5][1<<5], V;

long long prv[333][333];

long long nxt[333][333];



int main()

{

	scanf("%d %d", &N, &C);

	for (int i = 0; i < N; i++) scanf("%d", &A[i]);

	sort(A, A + N);



	int b = (1 << (N - 1));

	prv[0][A[N - 1] * N] = nxt[0][A[N - 1] * N] = 1;

	for (int i = 1; i < b; i++) bc[i] = bc[i - (i&(-i))] + 1;

	for (int i = 0; i < b; i++) for (int j = 0; j < b; j++) if (bc[i] == bc[j]) {

		P[V] = i; Q[V] = j;

		M[i][j] = V++;

	}

	for (int t = 0; t < N*C; t++) {

		for (int i = 0; i < V; i++) {

			int p = P[i], q = Q[i], d = t % N - 1;

			if (d < 0 || (q & (1 << d))) continue;

			for (int k = t; k <= N*C; k++) if (prv[i][k]) {

				for (int j = 0; j < N-1; j++) if (~p & (1 << j)) {

					int x = min(N*C, max(k, t + A[j] * N));

					nxt[M[p + (1 << j)][q + (1 << d)]][x] += prv[i][k];

				}

			}

		}

		for (int i = 0; i < V; i++) for (int k = 0; k <= N*C; k++) prv[i][k] = nxt[i][k];

	}



	double ans = prv[V-1][N*C];

	for (int i = 1; i < N; i++) {

		ans /= i;

		ans /= C;

	}



	printf("%.16lf\n", ans);



	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.5988279729581816x):
#include <stdio.h>

#include <algorithm>

using namespace std;



int N, C, A[6], bc[1 << 5];

int P[333], Q[333], M[1 << 5][1 << 5], V;

long long D[333][333];



int main()

{

	scanf("%d %d", &N, &C);

	int L = N * C;

	for (int i = 0; i < N; i++) scanf("%d", &A[i]);

	sort(A, A + N);



	int b = (1 << (N - 1));

	D[0][A[N - 1] * N] = 1;

	for (int i = 1; i < b; i++) bc[i] = bc[i - (i&(-i))] + 1;

	for (int i = 0; i < b; i++) for (int j = 0; j < b; j++) if (bc[i] == bc[j]) {

		P[V] = i; Q[V] = j;

		M[i][j] = V++;

	}

	for (int t = 0; t < L; t++) {

		int d = t % N - 1;

		if (d >= 0) for (int i = V - 1; i >= 0; i--) {

			int p = P[i], q = Q[i];

			if (q & (1 << d)) continue;

			for (int j = 0; j < N - 1; j++) if (~p & (1 << j)) {

				int l = t + A[j] * N;

				long long *v = D[M[p + (1 << j)][q + (1 << d)]];

				for (int k = t; k <= L; k++) if (D[i][k]) {

					int x = min(L, max(k, l));

					v[x] += D[i][k];

				}

			}

		}

	}



	double ans = D[V - 1][L];

	for (int i = 1; i < N; i++) {

		ans /= i;

		ans /= C;

	}



	printf("%.16lf\n", ans);



	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

#define N 510

int n,c,a[N],ct;

double r,f[N][(1<<7)];

int main(){

	cin>>n>>c;

	for(int i=0;i<n;i++)

		cin>>a[i];

	sort(a,a+n);

	do{

		memset(f,0,sizeof(f));

		f[a[n-1]*n][0]=1;

		for(int i=0;i<=n*c;i++)

			for(int j=i;j<=n*c;j++)

				for(int s=0;s<(1<<(n-1));s++)

					if(i%n&&!(s&(1<<(i%n-1)))&&f[j][s]){

						f[min(n*c,max(j,i+a[i%n-1]*n))][s+(1<<(i%n-1))]+=f[j][s];

					}

		r+=f[n*c][(1<<(n-1))-1];

		ct++;

	}while(next_permutation(a,a+n-1));

	printf("%.15lf",(double)r/ct/pow(c,n-1));

}

// Faster C++ solution for the same problem (measured speedup: 1.2823791840770389x):
#include <bits/stdc++.h>

using namespace std;

double z,f[500][50],t;

int n,c,a[10];

int main(){

    scanf("%d%d",&n,&c);

    for(int i=0;i<n;i++)scanf("%d",&a[i]);

    sort(a,a+n);

    do{

        memset(f,0,sizeof(f));

		f[n*a[n-1]][0]=1;

		for(int i=0;i<n*c;i++){

			for(int j=i;j<=n*c;j++){

				for(int k=0;k<(1<<(n-1));k++){

					if (i%n&&(k>>(i%n-1)&1)==0){

						f[min(max(j,i+n*a[i%n-1]),n*c)][k|(1<<(i%n-1))]+=f[j][k];

					}

				}

			}

		}

        z+=f[n*c][(1<<(n-1))-1];

		t++;

    }while(next_permutation(a,a+n-1));

    printf("%.15f\n",z/t/pow(c,n-1));

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int n,c,l[10];

double dp[500][(1<<7)],t,ans;

int main()

{

    cin>>n>>c; 

    for(int i=0;i<n;++i)

    cin>>l[i];

    sort(l,l+n);

    do

    {

        memset(dp,0,sizeof(dp));

        dp[l[n-1]*n][0]=1;

        for(int i=0;i<=n*c;++i)

        for(int j=i;j<=n*c;++j)

        for(int S=0;S<(1<<n-1);++S)

            if(i%n && !((S>>(i%n-1))&1))

                dp[min(n*c,max(j,i+l[i%n-1]*n))][S|(1<<(i%n-1))]+=dp[j][S];

        ans+=dp[n*c][(1<<n-1)-1];

        t++;

    }

    while(next_permutation(l,l+n-1));

    printf("%.15lf",(double)ans/t/pow(c,n-1));

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.2798242717316912x):
#include <bits/stdc++.h>

using namespace std;

double z,f[500][50],t;

int n,c,a[10];

int main(){

    scanf("%d%d",&n,&c);

    for(int i=0;i<n;i++)scanf("%d",&a[i]);

    sort(a,a+n);

    do{

        memset(f,0,sizeof(f));

		f[n*a[n-1]][0]=1;

		for(int i=0;i<n*c;i++){

			for(int j=i;j<=n*c;j++){

				for(int k=0;k<(1<<(n-1));k++){

					if (i%n&&(k>>(i%n-1)&1)==0){

						f[min(max(j,i+n*a[i%n-1]),n*c)][k|(1<<(i%n-1))]+=f[j][k];

					}

				}

			}

		}

        z+=f[n*c][(1<<(n-1))-1];

		t++;

    }while(next_permutation(a,a+n-1));

    printf("%.15f\n",z/t/pow(c,n-1));

}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



const int N = 112;

const int C = 1103;



int n, c;

int l[N], q[N];

long long f[C][N];



long long solve();



int main() {

  scanf("%d%d", &n, &c);

  for (int i = 1; i <= n; ++i) scanf("%d", &l[i]);

  sort(l + 1, l + n + 1);

  for (int i = 1; i < n; ++i) q[i] = i;

  long double res = 0;

  do { 

    res += solve();

  } while (next_permutation(q + 1, q + n));

  for (int i = 1; i < n; ++i) 

    res /= i * c * 1.0;

  printf("%.12Lf\n", res);

  return 0;

}



long long solve() {

  memset(f, 0, sizeof(f));

  f[n * l[n]][0] = 1;

  for (int i = 0; i < n * c; ++i) {

    if (!(i % n)) continue;

    int x = q[i % n];

    for (int s = 0; s <= (1 << (n - 1)) - 1; ++s) {

      if (s & (1 << (x - 1))) continue;

      for (int j = i; j <= n * c; ++j) {

        f[min(n * c, max(j, i + n * l[x]))]

          [s | (1 << (x - 1))] += f[j][s];

      }

    }

  }

  return f[n * c][(1 << (n - 1)) - 1];

}


// Faster C++ solution for the same problem (measured speedup: 1.8213647946225564x):
#include <bits/stdc++.h>

#define N 10



using namespace std;

typedef long long ll;



template <class T> inline void read(T &x) {

	char ch; bool flag = false;

	while (!isdigit(ch = getchar())) flag |= ch == '-';

	for (x = ch ^ 48; isdigit(ch = getchar()); x = x * 10 + (ch ^ 48));

	if (flag) x = -x;

}



inline int input() {

	int x; char ch; bool flag = false;

	while (!isdigit(ch = getchar())) flag |= ch == '-';

	for (x = ch ^ 48; isdigit(ch = getchar()); x = x * 10 + (ch ^ 48));

	return flag ? -x : x;

}



const int mod = 1e9 + 7;

inline int add(int x, int y) { x += y; return x >= mod ? x - mod : x; }

inline void inc(int &x, int y) { x += y; x -= x >= mod ? mod : 0; }



inline int Power(int x, int y) {

	int res = 1;

	while (y) {

		if (y & 1) res = (ll) res * x % mod;

		x = (ll) x * x % mod, y >>= 1;

	} return res;

}



template <class T> void chkmax(T &x, T y) { x = x > y ? x : y; }

template <class T> void chkmin(T &x, T y) { x = x < y ? x : y; }

template <class T> T gcd(T x, T y) { return !y ? x : gcd(x % y, y); }



int n, c;

int len[N];

ll f[50][500];

int p[N];



ll calc() {

	memset(f, 0, sizeof f);

	f[0][len[n] * n] = 1;

	for (int i = 0; i < n * c; ++i) {

		if (!(i % n)) continue;

		int x = p[i % n];

		for (int S = 0; S < (1 << (n - 1)); ++S) {

			if (S & (1 << x - 1)) continue;

			for (int j = i; j <= n * c; ++j)

				f[S | (1 << x - 1)][min(n * c, max(j, i + n * len[x]))] += f[S][j];

		}

	}

	return f[(1 << (n - 1)) - 1][n * c];

}



int main() {

	cin >> n >> c;

	for (int i = 1; i <= n; ++i) cin >> len[i];

	sort(len + 1, len + n + 1);

	for (int i = 1; i < n; ++i) p[i] = i;

	long double ans = 0;

	do { ans += calc(); } while (next_permutation(p + 1, p + n));

	for (int i = 1; i < n; ++i) ans /= 1.0L * i * c;

	printf("%.12Lf\n", ans);

	return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<algorithm>

#define inlien inline

#define retrun return

#define cpnst const

typedef long double ld;

int a[111],n,c;

ld dp[555][555];

inline int min(int x,int y)

{return(x<y)?x:y;}

inline int max(int x,int y)

{return(x>y)?x:y;}

int main()

{

	scanf("%d%d",&n,&c);

	register int i,ii,S;

	for(i=1;i<=n;i++)scanf("%d",&a[i]);

	ld fac=0,pwd=1;

	for(i=1;i<n;i++)pwd*=c;

	std::sort(a+1,a+n+1);

	ld ans=0;

	do

	{

		memset(dp,0,sizeof(dp)),

		fac++,dp[a[n]*n][0]=1;

		for(i=1;i<=n*c;i++)

		{

			int v=i%n;

			if(!v)continue;

			for(ii=i;ii<=n*c;ii++)

				for(S=0;S<(1<<(n-1));S++)

				{

					if(S&(1<<(v-1)))continue;

					int to=min(n*c,max(ii,i+n*a[v]));

					dp[to][S|(1<<(v-1))]+=dp[ii][S];

				}

		}ans+=dp[n*c][(1<<(n-1))-1]/pwd;

	}while(std::next_permutation(a+1,a+n));

	printf("%.15Lf\n",ans/fac);

}

/*

Giving the world a better yourself is giving yourself a better world. 

*/

// Faster C++ solution for the same problem (measured speedup: 3.0792629306016615x):
#include <cmath>

#include <cstdio>

#include <cstring>

#include <iostream>

#include <algorithm>



using namespace std;



int n , c;



const int N = 505;



int l[N];



double f[N][2 << 7] , ans , t;



int main(){

	cin >> n >> c;

	for(int i = 0; i < n; i++)

		cin >> l[i];

	sort(l , l + n);

	do{

		memset(f, 0, sizeof(f));

        f[l[n - 1] * n][0] = 1;

        for(int i = 0; i <= n * c; i++)

            for(int j = i; j <= n * c; j++)

                for(int S = 0; S < (1 << n - 1); S++)

                    if(i % n && !((S >> (i % n - 1)) & 1))

                        f[min(n * c, max(j, i + l[i % n - 1] * n))][S | (1 << (i % n - 1))] += f[j][S];

        ans += f[n * c][(1 << n - 1) - 1];

        ++t;

	}while(next_permutation(l , l + n - 1));

	printf("%.15lf" , (double)ans / t / pow(c , n - 1));

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

typedef long long ll;

using namespace std;

#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)

ll n, c, g, a, we, le, ac, L[7], p[7], k, dp[500][500];

signed main()

{

    cin >> n >> c, c *= n, k = (1 << (n - 1));

    forn(i, n) cin >> L[i], L[i] *= n;

    sort(L, L + n);

    iota(p, p + n - 1, 0);

    do {

        memset(dp, 0, sizeof(dp));

        dp[L[n - 1]][0] = 1;

        forn(i, c) if (i % n)

        {

            we = p[i % n - 1];

            forn(mask, k) if (!((1 << we) & mask))

                for (ac = i; ac <= c; ac++)

                    dp[max(ac, min(c, L[we] + i))][mask + (1 << we)] += dp[ac][mask];

        }

        g += dp[c][k - 1], a++;

    } while (next_permutation(p, p + n - 1));

    printf("%.15f", g / pow(c / n, n - 1) / a);

}


// Faster C++ solution for the same problem (measured speedup: 1.181393765793711x):
#include <bits/stdc++.h>

typedef long long ll;

using namespace std;

#define forn(i,n) for(int i=0;i!=n;i++)

ll n,c,g,a,ac,L[7],m,k,dp[500][500];

int main(){

cin>>n>>c,c*=n,m=n-1,k=1<<m;

forn(i,n)cin>>L[i],L[i]*=n;

sort(L,L+n);

do{

    memset(dp,0,sizeof(dp)),dp[L[m]][0]=1;

    forn(i,c)if(i%n){

        forn(mask,k)if(!((1<<(i%n-1))&mask))

            for(ac=i;ac<=c;ac++)dp[max(ac,min(c,L[i%n-1]+i))][mask+(1<<(i%n-1))]+=dp[ac][mask];

    }g+=dp[c][k-1],a++;

}while(next_permutation(L,L+m));

printf("%.15f",g/pow(c/n,m)/a);

}
// Slower C++ solution:
#include <bits/stdc++.h>

typedef long long ll;

using namespace std;

#define forn(i,n) for(int i=0;i!=n;i++)

ll n,c,g,a,we,ac,L[7],p[7],m,k,dp[500][500];

int main(){

cin>>n>>c,c*=n,m=n-1,k=1<<m;

forn(i,n)cin>>L[i],L[i]*=n;

sort(L,L+n);

iota(p,p+m,0);

do{

    memset(dp,0,sizeof(dp)),dp[L[m]][0]=1;

    forn(i,c)if(i%n){

        we = p[i%n-1];

        forn(mask,k)if(!((1<<we)&mask))

            for(ac=i;ac<=c;ac++)dp[max(ac,min(c,L[we]+i))][mask+(1<<we)]+=dp[ac][mask];

    }g+=dp[c][k-1],a++;

}while(next_permutation(p,p+m));

printf("%.15f",g/pow(c/n,m)/a);

}


// Faster C++ solution for the same problem (measured speedup: 1.1814906998126058x):
#include <bits/stdc++.h>

typedef long long ll;

using namespace std;

#define forn(i,n) for(int i=0;i!=n;i++)

ll n,c,g,a,ac,L[7],m,k,dp[500][500];

int main(){

cin>>n>>c,c*=n,m=n-1,k=1<<m;

forn(i,n)cin>>L[i],L[i]*=n;

sort(L,L+n);

do{

    memset(dp,0,sizeof(dp)),dp[L[m]][0]=1;

    forn(i,c)if(i%n){

        forn(mask,k)if(!((1<<(i%n-1))&mask))

            for(ac=i;ac<=c;ac++)dp[max(ac,min(c,L[i%n-1]+i))][mask+(1<<(i%n-1))]+=dp[ac][mask];

    }g+=dp[c][k-1],a++;

}while(next_permutation(L,L+m));

printf("%.15f",g/pow(c/n,m)/a);

}
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <set>

#include <queue>

#include <iomanip>

#include <vector>

#include <numeric>

//#include <bits/stdc++.h>



using namespace std;

const int INF = 1 << 30 ;

queue<int> Q;





bool BFS()

{

    while(!Q.empty())

    {

        int x;

        x = Q.front();

        Q.pop();

        if(x==0)

        {

            return true;

        } 

        else 

        {

            if(x-4>=0)

                Q.push(x-4);

            if(x-7>=0)

                Q.push(x-7);

        }

    }

    return false;

}



int main()

{

    ios::sync_with_stdio(false);

    int n;

    cin>>n;

    Q.push(n);

    if(BFS())

        cout<<"Yes"<<endl;

    else 

        cout<<"No"<<endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.667844338213753x):
#include<stdio.h>

int main()

{

    int N,i,j;

	int sum=0;

	scanf("%d",&N);

    for(i=0;i<=25;i++)

	{

		for(j=0;j<=14;j++)

		{

            if(i*4+j*7==N)

			{

				sum=1;

			}

		}

	}

	if(sum==1)

	{

		printf("Yes\n");

	}

	if(sum==0)

	{

		printf("No\n");

	}

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int n;

int main()

{

    cin>>n;

    bool f=false;

    for(int i=0;i<=25;i++){

        for(int j=0;j<=14;j++){

            if(4*i+7*j==n){

                f=true;

                break;

            }

        }

    }

    if(f)

        cout<<"Yes";

    else

        cout<<"No";

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.298949655282062x):
#include<stdio.h>

int main()

{

    int N,i,j;

	int sum=0;

	scanf("%d",&N);

    for(i=0;i<=25;i++)

	{

		for(j=0;j<=14;j++)

		{

            if(i*4+j*7==N)

			{

				sum=1;

			}

		}

	}

	if(sum==1)

	{

		printf("Yes\n");

	}

	if(sum==0)

	{

		printf("No\n");

	}

	return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<iostream>

#include<cmath>

using namespace std;



int flag;



void dfs(int n){

     if (n < 0) return ;

     if(n == 0){

         flag = 1;

         //cout << "Yes"<<endl;

         return ;

     }

     dfs(n - 4);

     dfs(n - 7);

}



int main(){



   int n;

   while(cin >> n ){

        flag = 0;

        dfs(n);

        if(!flag) cout << "No" <<endl;

        else  cout << "Yes" <<endl;



   }

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.906686037302705x):
#include<stdio.h>

int main()

{

    int N,i,j;

	int sum=0;

	scanf("%d",&N);

    for(i=0;i<=25;i++)

	{

		for(j=0;j<=14;j++)

		{

            if(i*4+j*7==N)

			{

				sum=1;

			}

		}

	}

	if(sum==1)

	{

		printf("Yes\n");

	}

	if(sum==0)

	{

		printf("No\n");

	}

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>



#define rep(i,n) for(long long int (i)=0;(i)<(int)(n);(i)++)

#define rrep(i,a,b) for(long long int i=(a);i<(b);i++)

#define rrrep(i,a,b) for(long long int i=(a);i>=(b);i--)

#define all(v) (v).begin(), (v).end()

#define pb(q) push_back(q)

#define Abs(a,b) max(a,b)-min(a,b)

#define YES(condition) if(condition){cout << "YES" << endl;}else{cout << "NO" << endl;}

#define Yes(condition) if(condition){cout << "Yes" << endl;}else{cout << "No" << endl;}

#define Cout(x) cout<<(x)<<endl

#define POSSIBLE(condition) if(condition){cout << "POSSIBLE" << endl;}else{cout << "IMPOSSIBLE" << endl;}

#define Possible(condition) if(condition){cout << "Possible" << endl;}else{cout << "Impossible" << endl;}

#define possible(condition) if(condition){cout << "possible" << endl;}else{cout << "impossible" << endl;}

#define Size(n) (n).size()



typedef long long ll;





using namespace std;



const int INF = 1e9,MOD = 1e9 + 7,ohara = 1e6;

const ll LINF = 1e18;





long long int n,cnt=0,ans=0,a,b,c,d,cmp,cmpp,m,h,w,x,y,sum=0,pos;

int dy[]={1,0,-1,0};

int dx[]={0,1,0,-1};

string alph("abcdefghijklmnopqrstuvwxyz"),s;

bool fl;

struct edge{int to,cost;};



//-------------------------↓↓↓↓↓↓------------------------



int main(void){

       cin.tie(0);

    ios::sync_with_stdio(false);



      

      cin>>n;

      rep(i,100){

          rep(j,100){

              pos=4*i+7*j;

              if(pos==n){

                  fl=true;

              }

          }

      }

      Yes(fl);

     



       

return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.445201617160806x):
#include <stdio.h>

int main(void){

    // Your code here!

    int N,ans=0;

    scanf("%d",&N);

    for(int i = 0;i <= 25;i++){

        for(int j = 0;j <= 15;j++){

            if(4 * i + 7 * j == N)ans = 1;

        }

    }

    if(ans == 1)printf("Yes\n");

    else printf("No\n");

    return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;



int main()

{

   int sx, sy, tx, ty;

    cin >> sx >> sy >> tx >> ty;

    int i;

    for (i=sy+1 ; i<=ty ; i++)

    {

        cout << "U";

    }

    for (i=sx+1 ; i<=tx ; i++)

    {

        cout << "R";

    }

    for (i=ty-1 ; i>=sy ; i--)

    {

        cout << "D";

    }

    for (i=tx-1 ; i>=sx ; i--)

    {

        cout << "L";

    }

    cout << "L";

    for (i=sy ; i<=ty ; i++)

    {

        cout << "U";

    }

    for (i=sx ; i<=tx ; i++)

    {

        cout << "R";

    }

    cout << "DR";

      

    for (i=ty ; i>=sy ; i--)

    {

        cout << "D";

    }

    for (i=tx ; i>=sx ; i--)

    {

        cout << "L";

    }

    cout << "U" ;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.1789992603235895x):
#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;



int main()

{

	int a,b,x,y;

	while(~scanf("%d%d%d%d",&a,&b,&x,&y))

	{

		int n = x-a,m = y-b;

		for(int i = 0;i < m;i++)

			printf("U");

		for(int i = 0;i < n;i++)

			printf("R");

		for(int i = 0;i < m;i++)

			printf("D");

		for(int i = 0;i < n+1;i++)

			printf("L");

		for(int i = 0;i < m+1;i++)

			printf("U");

		for(int i = 0;i < n+1;i++)

			printf("R");

			printf("D");	

			printf("R");

		for(int i = 0;i < m+1;i++)

			printf("D");

		for(int i = 0;i < n+1;i++)

			printf("L");

		printf("U\n");

	}

return 0;

}