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

#include<climits>

#include<vector>

#include<list>

#include<functional>

#include<algorithm>

#include<string>

#include<cmath>

#include<complex>

#include<set>

#include<map>

#include<stack>

#include<queue>

#include<deque>

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

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

#define INF (int)1e9

#define INFL (ll)1e11

using namespace std;

typedef long long ll;

typedef pair<int, int> P;



set<int> yakusu(int x) {

	set<int> tmp;

	for (int i = 1;i <= sqrt(x);i++) {

		if (x%i == 0) {

			tmp.insert(i);

			tmp.insert(x / i);

		}

	}

	return tmp;

}



int main() {

	cin.tie(0);

	ios::sync_with_stdio(false);



	int N, X;

	cin >> N >> X;

	set<int> dis;

	REP(i, N) {

		int x;

		cin >> x;

		x = abs(x-X);

		dis.insert(x);

	}

	set<int> y = yakusu(*dis.begin());

	set<int>::iterator res = y.end();

	res--;

	

	bool flag = true;

	while (flag) {

		for (set<int>::iterator itr = dis.begin();itr != dis.end();++itr) {

			if (*itr%*res != 0) {

				res--;

				break;

			}

			

			set<int>::iterator end = dis.end();

			if (itr == --end) flag = false;

		}

	}

	cout << *res << "\n";



	return 0;

}

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

#include<climits>

#include<vector>

#include<list>

#include<functional>

#include<algorithm>

#include<string>

#include<cmath>

#include<complex>

#include<set>

#include<map>

#include<stack>

#include<queue>

#include<deque>

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

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

#define INF (int)1e9

#define INFL (ll)1e11

using namespace std;

typedef long long ll;

typedef pair<int, int> P;



int gcd(int x, int y) {

	if (x < y) return gcd(y, x);

	return y == 0 ? x : gcd(x%y, y);

}



int main() {

	cin.tie(0);

	ios::sync_with_stdio(false);



	int N, X;

	cin >> N >> X;

	vector<int> dis(N);

	REP(i, N) {

		int x;

		cin >> x;

		dis[i] = abs(x - X);

	}

	int res = dis[0];

	REP(i, N) res = gcd(res, dis[i]);

	cout << res << "\n";





	return 0;

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

#include <algorithm>

#include <iostream>

#include <map>

#include <numeric>

#include <set>

#include <sstream>

#include <string>

#include <vector>

using namespace std;

typedef long long ll;



bool check(int i, vector<int> v){

  bool flag = true;

  for (auto e: v){

    if (e%i != 0){

      flag = false;

      break;

    }

  }

  return flag;

}



int main(int argc, const char * argv[]) {



  int N, X; cin >> N >> X;

  vector<int> x(N);

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

    int xtemp; cin >> xtemp;

    x[i] = abs(xtemp-X);

  }

  int xmin = x[min_element(x.begin(), x.end()) - x.begin()];

  int D = 1;

  for (int i=1; i*i<=xmin; i++){

    if (xmin%i == 0){

      if (check(i, x))

        D = max(D, i);

      if (check(xmin/i, x))

        D = max(D, xmin/i);

    }

  }

  cout << D << endl;

  return 0;

}

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

#include <algorithm>

#include <iostream>

#include <map>

#include <numeric>

#include <set>

#include <sstream>

#include <string>

#include <vector>

using namespace std;

typedef long long ll;



int gcd(int a, int b){

  if (a<b)

    swap(a,b);

  if (b == 0)

    return a;

  else

    return gcd(b, a%b);

}



int main(){

  

  int N, X; cin >> N >> X;

  

  vector<int> x(N);

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

    int xtemp; cin >> xtemp;

    x[i] = abs(xtemp-X);

  }

  

  int ans = gcd(x[0], x[1]);

  for (int i=2; i<N; i++)

    ans = gcd(ans, x[i]);

  

  cout << ans << endl;

  

  return 0;

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

#define model l,mid,num<<1

#define moder mid+1,r,num<<1|1

#define bug(k)  cout<<"text :"<<t<<endl

#define lowbit(k) k&-k

using namespace std;

typedef long long LL;

const LL mod=1e9+7;

const int M=1e5+5;

map <string,int> ma;

int n,x;

int arr[M];

int bits_gcd(int x,int y)

{

    if(y==0)return x;

    if(x==0)return y;

    int i,j;

    for(i=0;0==(x&1);i++)x>>=1;

    for(j=0;0==(y&1);j++)y>>=1;

    if(i>j)i=j;

    while(1)

    {

        if(x<y)x^=y,y^=x,x^=y;

        if(0==(x-=y))return y<<i;

        while(0==(x&1))x>>=1;

    }

}

int main()

{

     int ans;

     int t;

     while(cin>>n>>x)

     {

         ans=INT_MAX;

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

         {

             scanf("%d",&t);

             if(t>x)t^=x,x^=t,t^=x;

             arr[i]=x-t;

         }

         int ans=arr[1];

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

         {

//             cout<<ans<<" "<<arr[i]<<endl;

//             cout<<bits_gcd(ans,arr[i])<<endl;

             ans=bits_gcd(ans,arr[i]);

         }

         cout<<ans<<endl;

     }

}

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

#include<algorithm>

using namespace std;



const int Maxn=1e5;



int N,X;

int t[Maxn+5];



inline int abs(int x) {

	return x<0?-x:x;

}



int GCD(int a,int b) {

	if(b==0)return a;

	return GCD(b,a%b);

}



int main() {

	#ifdef LOACL

	freopen("in.txt","r",stdin);

	freopen("out.txt","w",stdout);

	#endif

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

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

		int tmp;

		scanf("%d",&tmp);

		t[i]=abs(tmp-X);

	}

	int ans=GCD(t[1],t[2]);

	for(int i=3;i<=N;i++)

		ans=GCD(ans,t[i]);

	printf("%d\n",ans);

	return 0;

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

#define model l,mid,num<<1

#define moder mid+1,r,num<<1|1

#define bug(k)  cout<<"text :"<<t<<endl

#define lowbit(k) k&-k

using namespace std;

typedef long long LL;

const LL mod=1e9+7;

const int M=1e5+5;

map <string,int> ma;

int n,x;

int arr[M];

int bits_gcd(int x,int y)

{

    if(y==0)return x;

    if(x==0)return y;

    int i,j;

    for(i=0;0==(x&1);i++)x>>=1;

    for(j=0;0==(y&1);j++)y>>=1;

    if(i>j)i=j;

    while(1)

    {

        if(x<y)x^=y,y^=x,x^=y;

        if(0==(x-=y))return y<<i;

        while(0==(x&1))x>>=1;

    }

}

int main()

{

     int ans;

     int t;

     while(cin>>n>>x)

     {

         ans=INT_MAX;

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

         {

             scanf("%d",&t);

             if(t>x)t^=x,x^=t,t^=x;

             arr[i]=x-t;

         }

         int ans=arr[1];

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

         {

//             cout<<ans<<" "<<arr[i]<<endl;

//             cout<<bits_gcd(ans,arr[i])<<endl;

             ans=bits_gcd(ans,arr[i]);

         }

         cout<<ans<<endl;

     }

}

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

#include<algorithm>

using namespace std;

#define MAXN 100005

#define LL long long

LL n,X;

LL x[MAXN];

LL ans;

LL gcd(LL a,LL b)

{

	if(b==0) return a;

	return gcd(b,a%b);

}

LL Abs(LL p)

{

	if(p>=0) return p;

	return -p;

}

int main()

{

	scanf("%lld %lld",&n,&X);

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

	{

		scanf("%lld",&x[i]);

		x[i]=Abs(x[i]-X);

		if(i==1) ans=gcd(x[1],x[2]);

		else ans=gcd(ans,x[i]);

	}

	printf("%lld\n",ans);

	return 0;

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

#define model l,mid,num<<1

#define moder mid+1,r,num<<1|1

#define bug(k)  cout<<"text :"<<t<<endl

#define lowbit(k) k&-k

using namespace std;

typedef long long LL;

const LL mod=1e9+7;

const int M=1e5+5;

map <string,int> ma;

int n,x;

int arr[M];

int bits_gcd(int x,int y)

{

    if(y==0)return x;

    if(x==0)return y;

    int i,j;

    for(i=0;0==(x&1);i++)x>>=1;

    for(j=0;0==(y&1);j++)y>>=1;

    if(i>j)i=j;

    while(1)

    {

        if(x<y)x^=y,y^=x,x^=y;

        if(0==(x-=y))return y<<i;

        while(0==(x&1))x>>=1;

    }

}

int main()

{

     int ans;

     int t;

     while(cin>>n>>x)

     {

         ans=INT_MAX;

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

         {

             scanf("%d",&t);

             if(t>x)t^=x,x^=t,t^=x;

             arr[i]=x-t;

         }

         int ans=arr[1];

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

         {

//             cout<<ans<<" "<<arr[i]<<endl;

//             cout<<bits_gcd(ans,arr[i])<<endl;

             ans=bits_gcd(ans,arr[i]);

         }

         cout<<ans<<endl;

     }

}

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

int abs(int x) {

	return (x>0)?x:-x;

}

int n,k;

int gcd(int a,int b) {

	return (b==0)?a:gcd(b,a%b);

}

int main()

{

	int x,G;

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

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

		scanf("%d",&x);

		if(i==1) G=abs(x-k);

		else G=gcd(G,abs(x-k));

	}

	printf("%d",G);

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

using namespace std;

int cnt[100010];

int res[100010];

int a[100010];

int main(){

	int n,m;

	cin>>n>>m;

	int b=0;

	for(int i=0;i<n;i++)cin>>a[i];

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

		cnt[b]=abs(a[i]-m);

		b++;

	}

	sort(cnt,cnt+n);

	int x=cnt[0];

	int c=0;

	for(int i=1;i*i<=x;i++){

		if(x%i==0){

			res[c]=i;

			c++;

			res[c]=x/i;

			c++;

		}

	}

	sort(res,res+c);

	for(int i=c-1;i>=0;i--){

		bool flag=true;

		int ans=m;

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

			if(abs(a[j]-ans)%res[i]!=0){

				flag=false;

				break;

			}

			ans=a[j];

		}

		if(flag){

			cout<<res[i]<<endl;

			return 0;

		}

	}

	return 0;

}

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

#include <sstream>

#include <fstream>

#include <string>

#include <vector>

#include <deque>

#include <queue>

#include <stack>

#include <set>

#include <map>

#include <algorithm>

#include <functional>

#include <utility>

#include <bitset>

#include <cmath>

#include <cstdlib>

#include <ctime>

#include <cstdio>

#include <string.h>

using namespace std;

int n,m;

int a[100010];

int main(){

	//freopen("input.txt","r",stdin);

	//freopen("output.txt","w",stdout);

	cin>>n>>m;

	for(int i=0;i<n;i++)cin>>a[i];

	vector<int> v;

	v.push_back(abs(m-a[0]));

	for(int i=0;i<n-1;i++)v.push_back(abs(a[i]-a[i+1]));

	int ans=v[0];

	for(int i=1;i<v.size();i++)ans=__gcd(ans,v[i]);

	cout<<ans<<endl;

	return 0;

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

#include <bits/stdc++.h>

#define pb push_back

#define ob pop_back

#define xx first

#define yy second

#define dob double

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

#define int long long int

#define ss size()

using namespace std;

const int M=1e9+7,maxn=100010;

std::vector<int> adj[maxn];

std::vector<int> v1;

int ans,n,k,m,x,y,q,par[maxn],h[maxn],mach[maxn],sk[maxn],dp[maxn];

bool mark[maxn],bpart[maxn];

string s,s1,s2;

map <string ,int> mp;

bool markchaild[maxn];

bool dfsmach(int v){

    if(v==-1) return true;

    if(mark[v]==1) return false;

    mark[v]=1;

    for(int i=0;i<adj[v].ss;i++){

        int u=adj[v][i];

        if(dfsmach(mach[u])){

            bpart[u]=((bpart[v]+1)%2);

            mach[u]=v;

            mach[v]=u;

            return true;

        }

    }

    return false;

}





int32_t main() {

    cin>>n>>m>>k;

    if(n<=k&&m>=k)

        cout<<"Yes";

    else

        cout<<"No";

    return 0;

}


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



using namespace std;



int main()

{

    int A;

    int B;

    int C;

    cin>>A;

    cin>>B;

    cin>>C;

    if(A<=C&&C<=B){

        cout<<"Yes";

    }

    else{

        cout<<"No";

    }

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

#include<cstdio>

#include<algorithm>

#include<cmath>

#include<cstring> 

#include<queue>

#include<stack> 

#include<string.h>

#include<set>

#define ll long long

using namespace std;

int main()

{

	int a,b,c;

	scanf("%d%d%d",&a,&b,&c);

	if(c>=a&&c<=b)

	{

		printf("Yes\n");

	}

	else

	printf("No\n");

	return 0;

}

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



int main()

{

	int a,b,c;

	scanf ("%d %d %d",&a,&b,&c);

	if (c>=a && c<=b )

	{

		printf ("Yes\n");

	}

	else printf ("No\n");

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

#include <cstring>

#include <cmath>

#include <algorithm>

#include <iostream>

#include <sstream>

#include <queue>

#include <map>

#include <vector>

#include <set>

#include <cstdlib>

#include <stack>



using namespace std;



typedef long long LL;

typedef double db;

#define FAST ios::sync_with_stdio(false);

const int MaxN = 105;

int main()

{

	int a , b ,c;

	cin >> a >> b >> c;

	if(c >= a && c <= b)cout << "Yes" << endl;

	else cout << "No" << endl;

	return 0;

	}

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



int main()

{

	int a,b,c;

	scanf ("%d %d %d",&a,&b,&c);

	if (c>=a && c<=b )

	{

		printf ("Yes\n");

	}

	else printf ("No\n");

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

using namespace std;



int main()

{

    int a; int b; int c;

    cin>>a>>b>>c;

    if(c>=a&&c<=b)

        cout<<"Yes"<<endl;

    else

        cout<<"No"<<endl;



}


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



int main()

{

	int a,b,c;

	scanf ("%d %d %d",&a,&b,&c);

	if (c>=a && c<=b )

	{

		printf ("Yes\n");

	}

	else printf ("No\n");

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

using namespace std;

int main()

{

   int a,b,c;

   cin>>a>>b>>c;

   if(c>=a && c<=b)

    cout<<"Yes";

    else

        cout<<"No";

    return 0;

}

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



int main()

{

	int a,b,c;

	scanf ("%d %d %d",&a,&b,&c);

	if (c>=a && c<=b )

	{

		printf ("Yes\n");

	}

	else printf ("No\n");

}
// Slower C++ solution:
//This code is solely the property of StarnyC



#include<bits/stdc++.h>

using namespace std;

int main()



{

int a,b,c;

cin>>a>>b>>c;

if(c<=b&&a<=c){cout<<"Yes";}

else{cout<<"No";

}

}






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



int main()

{

	int a,b,c;

	scanf ("%d %d %d",&a,&b,&c);

	if (c>=a && c<=b )

	{

		printf ("Yes\n");

	}

	else printf ("No\n");

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

using namespace std;

int main()

{

   int A,B,C;

  cin>>A>>B>>C;

  if(C>=A&&C<=B)

cout<<"Yes";

else

cout<<"No";

return 0;

}

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



int main()

{

	int a,b,c;

	scanf ("%d %d %d",&a,&b,&c);

	if (c>=a && c<=b )

	{

		printf ("Yes\n");

	}

	else printf ("No\n");

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

using namespace std;

int main()

{

	int a,b,c;

	cin>>a>>b>>c;

	if(c>=a)

	{

		if(c<=b)

		cout<<"Yes";

		else

		cout<<"No";

	}

	else

	cout<<"No";

}

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



int main()

{

	int a,b,c;

	scanf ("%d %d %d",&a,&b,&c);

	if (c>=a && c<=b )

	{

		printf ("Yes\n");

	}

	else printf ("No\n");

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

using namespace std;

int main(){

int A,B,C;









cin>>A>>B>>C;





if( A>=-100 && A<=100 && B>=-100 && B<=100 && C>=-100 && C<=100){



if(A<=C && B>=C ){

cout<<"Yes";

}

else cout<<"No";

}

}


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



int main()

{

	int a,b,c;

	scanf ("%d %d %d",&a,&b,&c);

	if (c>=a && c<=b )

	{

		printf ("Yes\n");

	}

	else printf ("No\n");

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

#include <bits/stdc++.h>

#define pb push_back

#define ob pop_back

#define xx first

#define yy second

#define dob double

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

#define int long long int

#define ss size()

using namespace std;

const int M=1e9+7,maxn=100010;

std::vector<int> adj[maxn];

std::vector<int> v1;

int ans,n,k,m,x,y,q,par[maxn],h[maxn],mach[maxn],sk[maxn],dp[maxn];

bool mark[maxn],bpart[maxn];

string s,s1,s2;

map <string ,int> mp;

bool markchaild[maxn];

bool dfsmach(int v){

    if(v==-1) return true;

    if(mark[v]==1) return false;

    mark[v]=1;

    for(int i=0;i<adj[v].ss;i++){

        int u=adj[v][i];

        if(dfsmach(mach[u])){

            bpart[u]=((bpart[v]+1)%2);

            mach[u]=v;

            mach[v]=u;

            return true;

        }

    }

    return false;

}





int32_t main() {

    cin>>n>>m>>k;

    if(n<=k&&m>=k)

        cout<<"Yes";

    else

        cout<<"No";

    return 0;

}


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



int main()

{

	int a,b,c;

	scanf ("%d %d %d",&a,&b,&c);

	if (c>=a && c<=b )

	{

		printf ("Yes\n");

	}

	else printf ("No\n");

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



using namespace std;



int main()

{

    int A;

    int B;

    int C;

    cin>>A;

    cin>>B;

    cin>>C;

    if(A<=C&&C<=B){

        cout<<"Yes";

    }

    else{

        cout<<"No";

    }

}




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



int main()

{

	int a,b,c;

	scanf ("%d %d %d",&a,&b,&c);

	if (c>=a && c<=b )

	{

		printf ("Yes\n");

	}

	else printf ("No\n");

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

using namespace std;

int main()

{

        int a,b,c;

        scanf("%d%d%d",&a,&b,&c);

        if(c<=b && c>=a)

                printf("Yes\n");

        else

                printf("No\n");

}


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

#include <stdlib.h>

int main()

{

	int a,b,c;

    scanf("%d",&a);

    scanf("%d",&b);

    scanf("%d",&c);

if (a <=c)

	{

		if (c <=b)

		{

			printf("Yes\n");

		}

		else

		{

			printf("No\n");

		}

	}

	else

	{

		printf("No\n");

	}

	system("pause");

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

using namespace std;



int main() {

	

	int A,B,C;

	

	cin >> A;

	cin >> B;

	cin >> C;

	

	if((C >= A)&&(C<=B)){

	printf("Yes");

	}

	else{

	printf("No");

	}

	

	return 0;

}


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

#include <stdlib.h>

int main()

{

	int a,b,c;

    scanf("%d",&a);

    scanf("%d",&b);

    scanf("%d",&c);

if (a <=c)

	{

		if (c <=b)

		{

			printf("Yes\n");

		}

		else

		{

			printf("No\n");

		}

	}

	else

	{

		printf("No\n");

	}

	system("pause");

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

#include<cstring>

#include<algorithm>

#include<queue>

#include<map>

#include<iostream>

using namespace std;

typedef long long ll;

const int INF = 0x3f3f3f3f;

int main()

{



    int a, b, c; 

    scanf("%d%d%d",&a,&b,&c);

    if(c >= a && c <= b)

        printf("Yes\n");

    else

    {

        printf("No\n");

    }

    return 0;

}




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

#include <stdlib.h>

int main()

{

	int a,b,c;

    scanf("%d",&a);

    scanf("%d",&b);

    scanf("%d",&c);

if (a <=c)

	{

		if (c <=b)

		{

			printf("Yes\n");

		}

		else

		{

			printf("No\n");

		}

	}

	else

	{

		printf("No\n");

	}

	system("pause");

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

using namespace std;

int main()

{

    int A,B,C;

    cin>>A>>B>>C;

    if(C>=A&&B>=C){

        cout<<"Yes";

    }

    else{

        cout<<"No";

    }

}

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

#include<string.h>

using namespace std;

int main()

{

    int A, B, C;

    scanf("%d %d %d", &A, &B, &C);

    if(A >= -100 && B >= -100 && C >= -100 && A <= 100 && B <= 100 && C <= 100){

    if(C >= A && C <= B){

      printf("Yes\n");

    }

    else{



    printf("No\n");

    }

    }



    return 0;

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



using namespace std;



int a, b, c;



int main(){

	cin >> a >> b >> c;

	if(c >= a && c <= b){

		cout << "Yes" << endl;

		return 0;

	}

	cout << "No" << endl;

	return 0;

}

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

#include<string.h>

using namespace std;

int main()

{

    int A, B, C;

    scanf("%d %d %d", &A, &B, &C);

    if(A >= -100 && B >= -100 && C >= -100 && A <= 100 && B <= 100 && C <= 100){

    if(C >= A && C <= B){

      printf("Yes\n");

    }

    else{



    printf("No\n");

    }

    }



    return 0;

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

using namespace std;

int main()

{

    int A,B,C;

    cin>>A>>B>>C;

    if(C>=A&&B>=C){

        cout<<"Yes";

    }

    else{

        cout<<"No";

    }

}

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

#include <stdlib.h>



int main()

{

    int a,b,c;

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

    {

        if(c>=a&&c<=b)

         printf("Yes\n");

        else

            printf("No\n");



    }



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



using namespace std;



int a, b, c;



int main(){

	cin >> a >> b >> c;

	if(c >= a && c <= b){

		cout << "Yes" << endl;

		return 0;

	}

	cout << "No" << endl;

	return 0;

}

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

#include <stdlib.h>



int main()

{

    int a,b,c;

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

    {

        if(c>=a&&c<=b)

         printf("Yes\n");

        else

            printf("No\n");



    }



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

#include <bits/stdc++.h>

#define pb push_back

#define ob pop_back

#define xx first

#define yy second

#define dob double

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

#define int long long int

#define ss size()

using namespace std;

const int M=1e9+7,maxn=100010;

std::vector<int> adj[maxn];

std::vector<int> v1;

int ans,n,k,m,x,y,q,par[maxn],h[maxn],mach[maxn],sk[maxn],dp[maxn];

bool mark[maxn],bpart[maxn];

string s,s1,s2;

map <string ,int> mp;

bool markchaild[maxn];

bool dfsmach(int v){

    if(v==-1) return true;

    if(mark[v]==1) return false;

    mark[v]=1;

    for(int i=0;i<adj[v].ss;i++){

        int u=adj[v][i];

        if(dfsmach(mach[u])){

            bpart[u]=((bpart[v]+1)%2);

            mach[u]=v;

            mach[v]=u;

            return true;

        }

    }

    return false;

}





int32_t main() {

    cin>>n>>m>>k;

    if(k>=n&&k<=m)

        cout<<"Yes";

    else

        cout<<"No";

    return 0;

}


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

using namespace std;

main()

{

    int a,b,c;

    cin>>a>>b>>c;

    if((a<=c)&&(c<=b))

       cout<<"Yes";

    else

        cout<<"No";

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

#include <bits/stdc++.h>

#define pb push_back

#define ob pop_back

#define xx first

#define yy second

#define dob double

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

#define int long long int

#define ss size()

using namespace std;

const int M=1e9+7,maxn=100010;

std::vector<int> adj[maxn];

std::vector<int> v1;

int ans,n,k,m,x,y,q,par[maxn],h[maxn],mach[maxn],sk[maxn],dp[maxn];

bool mark[maxn],bpart[maxn];

string s,s1,s2;

map <string ,int> mp;

bool markchaild[maxn];

bool dfsmach(int v){

    if(v==-1) return true;

    if(mark[v]==1) return false;

    mark[v]=1;

    for(int i=0;i<adj[v].ss;i++){

        int u=adj[v][i];

        if(dfsmach(mach[u])){

            bpart[u]=((bpart[v]+1)%2);

            mach[u]=v;

            mach[v]=u;

            return true;

        }

    }

    return false;

}





int32_t main() {

    cin>>n>>m>>k;

    if(k>=n&&k<=m)

        cout<<"Yes";

    else

        cout<<"No";

    return 0;

}


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

using namespace std;

int a, b, c;

int main (){

	cin >> a >> b >> c;

	if(c>=a&&c<=b) cout << "Yes" << endl;

	else cout << "No" << endl;	

}