stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include<bits/stdc++.h>



using namespace std;



int main()

{

	int a;

	string s;

	cin >> a;

	cin >> s;

	if(a >= 3200)

	{

		cout << s <<  endl;

	}

	else

	{

		cout << "red" << endl;

	}

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

const int maxd = 1e5+10;

char s[maxd];

int main()

{

	// freopen("a.in","r",stdin);

	// freopen("k.out","w",stdout);

	int x;

	scanf("%d %s",&x,s);

	if(x >= 3200) printf("%s",s);

	else printf("red");

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#define ll long long

#define ull unsigned long long

#define IO ios::sync_with_stdio(false), cin.tie(0)

#define endl '\n'

#define pi acos(-1.0)

#define ms(a, x) memset(a, x, sizeof(a))

#define lowbit(x) ((x)&(-(x)))

#define pb push_back

#define binarycount __builtin_popcount(x)

#define tr t[root]

#define lson t[root << 1]

#define rson t[root << 1 | 1]

#define debug(x) cout<<x<<'\n'

#define pii pair<ll,pair<ll,ll> >

using namespace std;

const int inf = 0x3f3f3f3f;

const ll INF=0x3f3f3f3f3f3f3f3f;

const ll mod = 1e9+7;

const double eps = 1e-8;

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

ll lcm(ll a, ll b) {return a/gcd(a, b)*b;}

ll powmod(ll a,ll b){

    ll ans = 1, pow = a;

    while(b) { if(b&1) ans = (ans*pow)%mod; pow = (pow*pow)%mod; b >>= 1; }

    return ans;

}

ll mul(ll a,ll b){//大数取模乘法防止溢出

    ll ans=0;

    a%=mod,b%=mod;

    while(b) { if(b&1) ans = (ans+a)%mod; a = (a*2)%mod; b >>= 1; }

    return ans;

}

//(b/a)%p=b*a^(p-2)%p

int pr(ll num){//判断素数

     if(num == 1) return 0;

     if(num ==2|| num==3 ) return 1 ;

     if(num %6!= 1&&num %6!= 5) return 0 ;

     int tmp =sqrt( num);

     for(int i= 5;i <=tmp; i+=6 )

          if(num %i== 0||num %(i+ 2)==0 )return 0 ;

     return 1 ;

}

int Day(int y,int m, int d){

    if(m==1||m==2) { m+=12; y--; }

    int w=(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7;

    return w+1;

}

inline int read() {

    int c = 0, f = 1;

    char ch = getchar();

    while (ch < '0' || ch > '9') {

        if (ch == '-') f = -1;

        ch = getchar();

    }

    while (ch >= '0' && ch <= '9') {

        c = c * 10 + ch - '0';

        ch = getchar();

    }

    return c * f;

}



//#pragma comment(linker, "/STACK:1024000000,1024000000")//外挂开栈

//stable_sort 排序不处理相同元素

//map<int,int>::reverse_iterator rit;

//for(rit=mp.rbegin();rit!=mp.rend();rit++)

//vec动态二维数组

//vector<vector<int>> g(26,vector<int>(100005));

//初始化vec里面套了n个vec



//lower_bound(begin,end,num) 有序数列中返回第一个>=num的数字的地址

//upper_bound( begin,end,num) 返回第一个>num的数字的地址



const int maxn=1e5+5;

int main(){

    ll x,a=101;

    cin>>x;

    int cnt=0;

    while(a<x){

        a*=1.01;

        cnt++;

    }

    cout<<cnt+1<<endl;

    return 0;

}


// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long n;

	scanf("%lld",&n);

	long long x=100,y,cnt=0;

	while(1)

	{

		y=x/100;

		x=x+y;

		cnt++;

		if(x>=n)

		break;

	}

	printf("%lld",cnt);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

int main(){

	ll x;

	cin>>x;

	ll ans=100;

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

		ans+=(ans/100);

		if(ans>=x) {

			cout<<i;

			break;

		}

	}

	return 0;

} 

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long n;

	scanf("%lld",&n);

	long long x=100,y,cnt=0;

	while(1)

	{

		y=x/100;

		x=x+y;

		cnt++;

		if(x>=n)

		break;

	}

	printf("%lld",cnt);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 0x3f3f3f3f

const int N=1e5+5;

int main()

{

    ios::sync_with_stdio(false);

    ll x,ans=100;

    int i;

    scanf("%lld",&x);

    for(i=1;;i++)

    {

    	ans+=ans/100;

    	if(ans>=x)

    	{

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

    		break;

		}

	}

    return 0; 

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long n;

	scanf("%lld",&n);

	long long x=100,y,cnt=0;

	while(1)

	{

		y=x/100;

		x=x+y;

		cnt++;

		if(x>=n)

		break;

	}

	printf("%lld",cnt);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cstdio>

#define ll long long

using namespace std;

int main()

{

	ll m,st=100;

	int len=0;

	cin >> m;

	while (st < m)

	{

		st = st*1.01;

		len++;

	}

	cout << len << endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long n;

	scanf("%lld",&n);

	long long x=100,y,cnt=0;

	while(1)

	{

		y=x/100;

		x=x+y;

		cnt++;

		if(x>=n)

		break;

	}

	printf("%lld",cnt);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



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

#define for1(i, n) for (int i = 1; i <= int(n); ++i)

#define ms(a, x) memset(a, x, sizeof(a))

#define F first

#define S second

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



using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

const int INF = 0x3f3f3f3f;

mt19937 gen(chrono::steady_clock::now().time_since_epoch().count());

template<typename... Args> void rd(Args&... args) {((cin >> args), ...);}

template<typename... Args> void write(Args... args) { ((cout << args << " "), ...); cout<<endl;}



int main() {

    ios::sync_with_stdio(false);

    cin.tie(nullptr);

    int ans=0;

    ll x;

    cin>>x;

    ll n=100;

    while(n<x){

        n=n*1.01;

        ans++;

    }

    cout<<ans;

    return 0;

}




// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

        return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

const int maxn = 2e5 + 100; 

const double pi = acos(-1.0);



inline ll read()

{

    ll kk=0,f=1;

    char cc=getchar();

    while(cc<'0'||cc>'9'){if(cc=='-')f=-1;cc=getchar();}

    while(cc>='0'&&cc<='9'){kk=(kk<<1)+(kk<<3)+cc-'0';cc=getchar();}

    return kk*f;

}





int main(void)

{

	ll x,num,ans=0;

	x=read();

//	scanf("%lf",&x);

//	ans = log(x/100)/log(1.01);

//	num = x/100;





	ll i=100;

//	printf("%lld",i);

	ll y=0;

	while(i<x)

	{

		i*=1.01;

		y++;

	}

	printf("%lld",y);

	

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

        return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

typedef long long int ll;

vector<ll>vec;

int main() 

{

    ll x;

    cin>>x;

    ll ans=0;

    ll p=100;

    for(;p<x;ans++)

    {

        p=p*(1.01);

    }

    cout<<ans<<endl;

    

    return 0;

}


// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

        return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#pragma region 

#include<iostream>

#include<algorithm>

#include<vector>

#include<stack>

#include<queue>

#include<map>

#include<cstring>

#include<string>

typedef long long ll;

template <typename T>void read(T &x){x=0;char ch=getchar();ll f=1;while(!isdigit(ch)){if(ch=='-')f*=-1;ch=getchar();}while(isdigit(ch)){x=x*10+ch-48;ch=getchar();}x*=f;}

#define IO ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)

using namespace std;

#pragma endregion



int main() {

    IO;

    ll x;

    cin >> x;

    int cnt = 0;

    ll now = 100;

    while (now<x) {

        now = (ll)(1.0 * now * 1.01);

        cnt++;

    }

    cout << cnt << endl;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<math.h>

using namespace std;

int main()

{

	unsigned long long a=100;

	unsigned long long n,k=0;

	scanf("%lld",&n);

	while(a)

	{

		if(a>=n)

		break;

		a=a+a/100;

		k++;

	}

	printf("%lld",k);

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include"iostream"

#include"algorithm"

using namespace std;

int main()

{

	long long int n, flag = 0, cnt = 100;

	while (cin >> n) {

		for(;;) {

			cnt += cnt / 100;

			flag++;

			if ( cnt >= n ) {

				break;

			}

		}

		cout << flag << endl;

	}

	return 0;

} 

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;

int main(){

	long long int a,b=100,c=0;

	cin>>a;

	while(b<a){

		b=b*1.01;

		c++;

	}

	cout<<c;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<cstdio>

#include<cmath>

#include<iostream>

using namespace std;

int main()

{

    long long sum[60000],a,b;

    sum[0]=100;

    scanf("%lld",&a);

    for(b=1;1;b++){

    sum[b]=sum[b-1]/100+sum[b-1];

    if(sum[b]>=a) break;

    }

    printf("%lld",b);

    return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cstdio>

using namespace std;

typedef long long ll;

const int maxn = 1e6+6;

int main()

{

	ll x;

	scanf("%lld",&x);

	ll sum = 100;

	ll ji = 0;

	while(sum < x)

	{

		ji ++;

		sum += sum/100;

	}

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

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

#define IO ios::sync_with_stdio(0), cin.tie(0) 

using namespace std;

typedef long long ll;

const int maxn = 1e5 + 5;

const int inf = ~0u >> 1;

int main() {

    IO;

    ll x;

    cin >> x;

    ll sum = 100;

    int ans = 0;

    while (sum < x) {

        sum += ll(0.01 * sum);

        ans++;

    }

    cout << ans << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
 #include<iostream>

 #include<algorithm>

 #include<cmath>

 #include<iomanip>

 #include<string.h>

 #include<cmath>

 #include<map>

 #include<vector>

using namespace std;

typedef long long ll;

char s[4005];

int main()

{

ll x;

cin>>x;

ll mmid=100;

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

{

  mmid=(ll)(1.0*mmid*1.01);  

//    cout<<mmid<<endl;

    if(mmid>=x)

    {

        cout<<i;

        break;

    }

}



}


// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main() {

	ll x,ans,cnt=0;

	cin>>x; ans=100;

	while (ans<x) {

		ans=ans*1.01;

		cnt++;

	}

	cout<<cnt<<endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>



using namespace std;



int main(){

    long long int a,x;

    int y=0;

    cin>>x;

    a=100;

    while(a<x){

        a+=a/100;

        y++;

    }

    cout<<y<<endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

#define eps 1e-3

#define pi acos(-1.0)

#define inf 0x3f

#define INF 0x3f3f3f3f

#define pb push_back

#define debug1 cout<<"&&";

#define debug2 cout<<"**";

#define ms(a, x) memset(a, x, sizeof(a))

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

#define for1(i, n) for(int i = 1; i <= n; ++i)

using namespace std;

typedef double db;

typedef long long ll;

typedef unsigned long long ull;

typedef pair<int, int> pii;

typedef pair<long long, int> pli;

typedef pair<long long, long long> pll;

const int mod = 1e9 + 7;

const int N = 1e5+10;

const int M = 1e6+10;

/*=================================================================================*/



int main() {

   ll end, st = 100, ans;

   cin>>end;

   for(int i = 1; st < end; ++i) {

      st = 1.01*st;

      ans = i;

   }

   cout<<ans;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

typedef long long ll;



int main()

{

	ll X;

	cin >> X;

	ll sum = 100;

	int cnt = 0;

	while(sum < X)

	{

		sum += sum * 0.01;

		cnt++;

	}

	printf("%d",cnt);

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

typedef long long int  ll;

const ll mod = 1e9+7;

const ll mod1 = 998244353;

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



void swap(ll &a , ll &b){

    ll t = a;

    a = b;

    b = t;

}



ll min(ll a, ll b){

    if(a<b)return a;

    return b;

}



ll max(ll a, ll b){

    if(a>b)return a;

    return b;

}



 ll pow(ll a, ll b) {

    a %= mod;

    ll ans = 1;

    while (b > 0) {

        if (b & 1)

            ans = ans * a % mod;

        a = a * a % mod;

        b /= 2;

    }

    return ans;

 }



 int n;

 int visited[102] = {0};

int x[102], y[102];



void dfs(int i)

{

    visited[i] = 1;

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

    {

        if(x[j] == x[i] || y[j]==y[i] )

        {

            if(visited[j] == 0)

            {

                dfs(j);

            }

        }

    }

}



int main(){



   ios_base :: sync_with_stdio(0);

   cin.tie(0);



   ll x;

   cin>>x;



   ll p =100;

   ll y = 0;

   while(p<x)

   {

       y++;

       p += 0.01 * p;

   }



   cout<<y<<endl;

    return 0;



}


// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

	long long int n,m;

	int t=0;

	m=100;

	scanf("%lld",&n);

	while(m<n)

	{

		m=m*1.01;

		t++;

	}

	printf("%d",t);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cmath>

using namespace std;

typedef long long ll;





int main(){

	ll yu = 100;

	ll x;

	cin>>x;

	int ans = 0;

	while(yu < x)

	{

		yu += yu * 0.01;

		ans++;

	}

	

	cout<<ans<<endl;

	

	return 0;

}




// Optimized solution to the same problem (faster):
#include <stdio.h>

int main ()

{

	long long x,i;

	int ans = 0;	

	scanf ("%lld",&x);

	for (i = 100; i < x;ans++)

	{

		i = i+i/100;

	}

	printf ("%d",ans);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<int, int> P;

using Graph = vector<vector<int>>;

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

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

const long long INF = 1LL << 60;

const int MOD = 1000000007;

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

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



vector<int> g[100010];



int main()

{

    int n, m;

    cin >> n >> m;

    rep(i, m)

    {

        int s, t;

        cin >> s >> t;

        g[s].push_back(t);

        g[t].push_back(s);

    }

    queue<int> q;

    vector<int> dist(n + 1, -1);

    vector<int> pre(n + 1, -1);

    dist[0] = 0;

    q.push(1);



    while (!q.empty())

    {

        int v = q.front();

        q.pop();

        for (int u : g[v])

        {

            if (dist[u] != -1)

                continue;

            dist[u] = dist[v] + 1;

            pre[u] = v;

            q.push(u);

        }

    }



    cout << "Yes" << endl;

    Rep(i, 2, n + 1)

    {

        int ans = pre[i];

        cout << ans << endl;

    }

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<int, int> P;

using Graph = vector<vector<int>>;

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

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

#define RRep(i, k, n) for (int i = k; i > (int)(n); i--)

#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl

//#define coutyn(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl

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

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; }

const long long INF = 1LL << 60;

const int MOD = 1000000007;

const double PI = acos(-1); //3.14~

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

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



int main()

{

    int n, m; cin >> n >> m;

    Graph g(n + 1);

    rep(i, m)

    {

        int a, b;

        cin >> a >> b;

        --a;--b;

        g[a].push_back(b);

        g[b].push_back(a);

    }



    queue<int> q;

    vector<int> dist(n, -1);

    vector<int> pre(n, -1);

    dist[0] = 0;

    q.push(0);

    while(!q.empty())

    {

        int v = q.front();q.pop();

        for(auto it : g[v])

        {

            if (dist[it] != -1) continue;

            dist[it] = dist[v] + 1;

            pre[it] = v;

            q.push(it);

        }

    }



    cout << "Yes" << endl;

    Rep(i, 1, n)

    {

        int ans = pre[i];

        ans++;

        cout << ans << endl;

    }

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<vector>

#include<queue>

using namespace std;

typedef long long ll;

typedef pair<ll, ll> P;

ll inf = 1000000007;

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

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

vector<ll>to[200005];

ll ans[200005] = {};

int main() {

	int n, m;

	cin >> n >> m;

	int a, b;

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

		cin >> a >> b;

		a--; b--;

		to[a].push_back(b);

		to[b].push_back(a);

	}



	vector<ll>dist(n, inf);

	vector<ll>pre(n, -1);

	dist[0] = 0;

	queue<ll>que;

	que.push(0);

	while (!que.empty()) {

		int v = que.front();

		que.pop();

		for (int id : to[v]) {

			if (dist[id] != inf)continue;

			dist[id] = dist[v] + 1;

			pre[id] = v;

			que.push(id);

		}

	}

	cout << "Yes" << endl;

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

		cout << ++pre[i] << endl;

	}

	return 0;

}

// Optimized solution to the same problem (faster):
#include <cmath>

#include<iostream>

#include<vector>

#include<algorithm>

#include<functional>

#include<queue>

#include<set>

#include<map>

#include<bitset>

#include<iomanip>

#include<stack>

#include<set>

using namespace std;

typedef long long ll;

typedef pair<ll, ll> P;

ll mod = 1000000007;

vector<ll>G[100005];

int main() {

	int n, m;

	cin >> n >> m;

	int a, b;

	

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

		cin >> a >> b;

		a--; b--;

		G[a].push_back(b);

		G[b].push_back(a);

	}



	vector<ll>dist(n, mod);

	vector<ll>pre(n, -1);

	dist[0] = 0;

	pre[0] = -1;

	queue<ll>que;

	que.push(0);

	while (!que.empty()) {

		int x = que.front();

		que.pop();

		for (auto id : G[x]) {

			if (dist[id] != mod) {

				continue;

			}

			dist[id] = dist[x] + 1;

			pre[id] = x;

			que.push(id);

		}

	}

	cout << "Yes" << endl;

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

		cout << pre[i] + 1 << endl;

	}

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

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

#define lower(s) transform(s.begin(), s.end(), s.begin(), ::tolower)

using namespace std;

using ll = long long;

int INF = 1001001001;



vector<int> to[200005];



int main() {

  int n, m;

  cin >> n >> m;

  rep(i, m) {

    int a, b;

    cin >> a >> b;

    a--;b--;

    to[a].push_back(b);

    to[b].push_back(a);

  }



  vector<int> dist(n, INF);

  vector<int> prev(n);

  queue<int> q;

  q.push(0);



  while(!q.empty()) {

    int v = q.front(); q.pop();

    for(int u : to[v]) {

      if(dist[u] != INF) {

        continue;

      }

      prev[u] = v;

      dist[u] = dist[v] + 1;

      q.push(u);

    }

  }

  cout << "Yes" << endl;

  rep(i, n) {

    if(i==0) continue;

    int ans = prev[i];

    ans++;

    cout << ans << endl;

  }

  return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

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

#define lower(s) transform(s.begin(), s.end(), s.begin(), ::tolower)

using namespace std;

using ll = long long;

int INF = 1001001001;



int main() {

  int n, m;

  cin >> n >> m;

  vector<vector<int>> g(n);

  rep(i, m) {

    int a, b;

    cin >> a >> b;

    a--; b--;

    g[a].push_back(b);

    g[b].push_back(a);

  }

  queue<int> q;

  q.push(0);

  vector<int> d(n, -1);

  vector<int> prev(n);

  d[0] = 0;

  while(!q.empty()) {

    int v = q.front(); q.pop();

    for(int nv : g[v]) {

      if(d[nv] != -1) continue;

      prev[nv] = v;

      d[nv] = d[v] + 1;

      q.push(nv);

    }

  }

  bool ok = true;

  rep(i, n) {

    if(d[i] == -1) ok = false;

  }

  if(ok) {

    cout << "Yes" << endl;

  } else {

    cout << "No" << endl;

  }

  rep(i, n) {

    if(i == 0) continue;

    cout << prev[i]+1 << endl;

  }

  return 0;

}

// Fastest known solution for this problem: