#define _USE_MATH_DEFINES
#include <set>
#include <array>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <stack>
#include <queue>
#include <vector>
#include <tuple>
#include <string>
#include <math.h>
#include <time.h>
#include <bitset>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <limits>
#include <climits>
#include <numeric>
#include <functional>
#include <iomanip>
#include <cmath>

#define lnd '\n'
// #define reverse(i, n) for(ll i = n-1; i >= 0; --i)
#define from(i, n) for (ll i = 0; i < n; ++i)
#define loop(i, n) for(ll i = 0; i < n; i++)
#define REPN(i, n) for (ll i = 1; i <= n; ++i)
#define ALL(s) (s).begin(), (s).end()
#define rALL(s) (s).rbegin(), (s).rend()
#define sz(s) (int)(s).size()
#define mk make_pair
#define pb push_back
#define sqr(s) ((s) * (s))

using namespace std;

typedef long long ll;
typedef long long int lli;
typedef long double ld;
typedef unsigned long long ull;
typedef unsigned int ui;

template <class T>
T GCD (T a, T b) {
  if(a == 0) return b;
  return GCD(b%a, a);
}

template <class T>
T LCM(T a, T b){
  return a*b/GCM(a,b);
}

template <class T>
T modpow(T x, T p){
    T res = 1;
    while(p > 0){
        if(p&1) res *= x;
        x *= x;
        p /= 2;
    }
    return res;
}

template <class T>
T modpow(T x, T p, ll mod){
    T res = 1;
    while(p > 0){
        if(p&1) res = (res*x)%mod;
        x = (x*x)%mod;
        p /= 2;
    }
    return res%mod;
}

template <class T>
void print(T a[], ll n){
    for (ll i = 0; i < n; i++) std::cout << a[i] << ' ';
    cout << endl;
}

template<class T>
void printc(T c){
    for(auto const& v: c) std::cout << v << ' ';
    cout << endl;
}

struct HASH{
  size_t operator()(const pair<long,long>&x)const{
    return hash<long long>()(((long long)x.first)^(((long long)x.second)<<32));
  }
};

bool pair_sort(const pair<int, int> &p1, const pair<int,int> &p2){
    if(p1.first != p2.first) return p1.first < p2.first;
    else return p1.second < p2.second;
}

const int INF = std::numeric_limits<int>::max();
const ll M_INF = std::numeric_limits<ll>::min();
const ll LL_INF = std::numeric_limits<ll>::max();

void solution();
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    solution();
    return 0;
}

ll result[200005] = {0};
void fact(ll n) {
   if (n >= 0) {
      result[0] = 1;
      for (ll i = 1; i <= n; ++i) {
         result[i] = i * result[i - 1];
      }
   }
}

void dfs(ll n, ll m, ll i, vector<ll> &v){
  if(i == n){
  }else{
    for(int k = 1; k <= m; k++){
      v.push_back(k);
      dfs(n, m, i+1, v);
      v.pop_back();
    }
  
  }
}

ld calcAngle(double h, double m)  
{  
    if (h == 12) h = 0;  
    if (m == 60) m = 0;  
   
    ld hour_angle = 0.5 * (h * 60 + m);  
    ld minute_angle = 6 * m;  
  
    ld angle = abs(hour_angle - minute_angle);    
    angle = min(360 - angle, angle);  
  
    return angle;  
}

void solution2(){
  ld a, b, h, m;
  cin >> a >> b >> h >> m;
  ld angle = calcAngle(h, m);
  cout << angle << endl;
  ld ans = a*a + b*b - (2*a*b*cos(angle));
  cout << std::fixed << setprecision(12) << endl;
  cout << sqrt(ans) << endl;
}    

void solution(){
  ll n, m;
  cin >> n >> m;
  vector<vector<ll>> edges(n+1, vector<ll>(0));
  loop(i, m){
    ll u, v;
    cin >> u >> v;
    edges[u].push_back(v);
    edges[v].push_back(u);
  }

  vector<ll> ans(n+1, 0);
  set<ll> queue;
  queue.insert(1);

  ll count = 0;
  while(queue.size()){
    set<ll> tmp;
    for(auto cur: queue){
      for(auto v: edges[cur]){
        if(cur == v) continue;
        if(ans[v] == 0){
          count++;
          ans[v] = cur;
          tmp.insert(v);
        }
      }
    }

    queue.clear();
    queue = tmp;
  }
  
  if(count == n){
    cout << "Yes"<< endl;
    for(ll i = 2; i <= n; i++){
      cout << ans[i] << endl;
    }
  }else{
    cout << "No" << endl;
  }
  
}



Measured memory_bytes: 21132