#include<bits/stdc++.h>

//this is for sweet ladies from Musala Soft <3

using namespace std;

#define pb push_back
const int maxi=1e5+10;

vector<int> v[maxi],vt[maxi],v1[maxi],ans;
int n,m;
long long bestAns;
int ob[maxi],del[maxi],pr[maxi],h[maxi],order[maxi];
pair<long long, int> dp[maxi],longest[maxi], haviest[maxi];
int diamFirst, diamLast, diamLca;
long long diamAns,treeDiameter;
long long  subTree[maxi];
int cnt[maxi];
int currentTreeLevel;
map<pair<int,int>,int> con;
void reset_array(int* x,int n)
{
    for (int i=1; i<=n; i++)
        x[i]=0;
}

void read()
{
    freopen("maxpath.in","r",stdin);
    cin>>n>>m;
    for (int i=1; i<=m; i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if (n<=100)
        {
            con[ {x,y}]=true;
            con[ {y,x}]=true;
        }
        v[x].pb(y);
        v[y].pb(x);
    }
    for (int i=1; i<=n; i++)
    {
        v1[i].assign(v[i].begin(),v[i].end());
        sort(v1[i].begin(),v1[i].end());
    }
    fclose(stdin);
}
void makeItBetter(vector<int> &currentPath)
{
    int sz = currentPath.size();
    for (int i=0; i<sz; i++)
        for (int j=i+1; j<sz; j++)
        {
            int nd1,nd2,nd3,nd4,nd5,nd6;
            if (i!=0)
                nd1=currentPath[i-1];
            if (i+1!=sz)
                nd3=currentPath[i+1];
            nd2 = currentPath[i];

            nd4 = currentPath[j-1];
            nd5 = currentPath[j];
            if (j+1!=sz)
                nd6 = currentPath[j+1];

            if (i+1 == j)
            {
                if ((i==0 || con[ {nd1,nd5}]) && ((j==sz-1) || con[ {nd2,nd6}]) && nd2>nd5)
                    swap(currentPath[i],currentPath[j]);
            }
            else
            {
                if ((i==0 || con[ {nd1,nd5}]) && (i==sz-1 || con[ {nd3,nd5}]) && (j==0 || con[ {nd2,nd4}]) &&(j==sz-1 || con[ {nd2,nd6}]) && nd2>nd5)
                    swap(currentPath[i],currentPath[j]);
            }
        }
}

void print()
{
    freopen("maxpath.out","w",stdout);

    if (ans.size()<=100)
    {
        makeItBetter(ans);
    }
    cout<<ans.size()<<endl;

    for (int i:ans)
        printf("%d\n",i);
    fclose(stdout);
}

void calcRes(vector<int> &currentPath)
{
    long long currentAns = 0;

    for (int i=0; i<currentPath.size(); i++)
        currentAns+=1ll*currentPath[i]*(i+1);

    if (currentAns>bestAns)
    {
        bestAns = currentAns;
        ans.assign(currentPath.begin(),currentPath.end());
    }
}


void solve1(int idx)
{
    reset_array(ob,n);
    int currentNode = 1;
    vector<int> path;

    while(currentNode < n+1)
    {
        path.pb(currentNode);
        ob[currentNode] = 1;
        int mm = n+1;
        for (int i:v[currentNode])
            if (!ob[i] && mm>i)
            {
                mm=i;
            }
        currentNode = mm;
    }

    calcRes(path);
    reverse(path.begin(),path.end());
    calcRes(path);

}

void solve2(int idx)
{
    reset_array(ob,n);
    int currentNode = idx;
    vector<int> path;

    while(currentNode > 0)
    {
        path.pb(currentNode);
        ob[currentNode] = 1;
        int mm = 0;
        for (int i:v[currentNode])
            if (!ob[i] && mm<i)
            {
                mm=i;
            }
        currentNode = mm;
    }

    calcRes(path);
    reverse(path.begin(),path.end());
    calcRes(path);

}

void solve3(int idx)
{
    reset_array(ob,n);
    int currentNode = idx;
    vector<int> path;
    int currentIdx = 0;
    while(currentNode > 0)
    {
        path.pb(currentNode);
        ob[currentNode] = 1;
        currentIdx++;
        int mm = -10000000;
        for (int i:v[currentNode])
            if (!ob[i] && abs(currentIdx-mm)>abs(currentIdx-i))
            {
                mm=i;
            }
        currentNode = mm;
    }

    calcRes(path);
    reverse(path.begin(),path.end());
    calcRes(path);

}

bool cmp2(int x, int y)
{
    if (n<=1000)
    {
        return cnt[x]/2+x/10<cnt[y]/2+y/10;
    }
    else
        return cnt[x]<cnt[y];
}
bool cmp3(int x, int y)
{
    return 1ll*cnt[x]*y<1ll*cnt[y]*x;
}

bool cmp4(int x, int y)
{
  int len = min(v1[x].size(),v1[y].size());

  int i = 0;
  int j = 0;

  while(i<len && j<len)
  {
     while(i<len && ob[v1[x][i]])
        i++;
     while(j<len && ob[v1[y][j]])
        j++;

     if (j<len && i<len)
     {
        if (v1[x][i]!=v1[y][j])
            return cnt[v1[x][i]]<cnt[v1[y][j]];

        i++;
        j++;
     }
  }


  return v1[x].size()<v1[y].size();
}

void dfsMakeTree(int x, int lev, int tip)
{
    ob[x] = 1;
    h[x] = lev;
    currentTreeLevel = lev;

    for (int i:v[x])
        cnt[i]--;

    if (tip==4)
        sort(v[x].begin(),v[x].end(),cmp2);

    if (tip==5)
        sort(v[x].begin(),v[x].end(),cmp3);
    if (tip==6){
        sort(v[x].begin(),v[x].end(),cmp4);
    }
    for (int i:v[x])
        if (!ob[i])
        {
            vt[i].pb(x);
            vt[x].pb(i);
            dfsMakeTree(i,lev+1,tip);
        }
}

void dfsDP(int x, int pred, int tip)
{
    pr[x]=pred;
    pair<long long, int> firstMax = {0,x} ;
    pair<long long, int> secondMax = {0,x};

    long long addValue;

    for (int i:vt[x])
        if (i!=pred)
        {
            dfsDP(i,x, tip);
            if (firstMax<dp[i])
            {
                secondMax = firstMax;
                firstMax = dp[i];
            }
            else if (secondMax<dp[i])
            {
                secondMax = dp[i];
            }
        }

    if (tip==2 || tip==4 || tip==5 || tip==6)
        addValue = 1;

    if (diamAns<secondMax.first+firstMax.first+addValue)
    {
        diamAns = secondMax.first + firstMax.first + addValue;
        diamLca = x;
        diamFirst = secondMax.second;
        diamLast = firstMax.second;
    }

    dp[x]=firstMax;
    dp[x].first+=addValue;
}

void diameterCalculation()
{
    vector<int> path, path1;

    while(diamFirst!=diamLca)
    {
        path.pb(diamFirst);
        diamFirst = pr[diamFirst];
    }

    path.pb(diamLca);

    while(diamLast!=diamLca)
    {
        path1.pb(diamLast);
        diamLast = pr[diamLast];
    }

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

    for (int i:path1)
        path.pb(i);

    assert(path.size()<=n);

    calcRes(path);
    reverse(path.begin(),path.end());
    calcRes(path);
}

void solveBig(int x, int tip)
{
    int root = x;
    reset_array(ob,n);
    reset_array(pr,n);
    diamAns = 0;
    diamFirst = 0;
    diamLast = 0;
    diamLca = 0;

    for (int i=1; i<=n; i++)
        vt[i].clear();

    for (int i=1; i<=n; i++)
        dp[i]= {0,0};

    dfsMakeTree(root,1, tip);

    dfsDP(root,0,tip);

    if (tip==2)
        treeDiameter = diamAns;

    diameterCalculation();
}

bool cmp(int x, int y)
{
    return v[x].size()<v[y].size();
}

bool cmp1(int x, int y)
{
    return 1ll*v[x].size()*y<1ll*v[y].size()*x;
}
void solve()
{
    srand(time(0));

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

    sort(order+1,order+n+1,cmp1);

    int firstLoopEnd, secondLoopEnd, thirdLoop;

    if (n<=100)
    {
        firstLoopEnd = n;
        secondLoopEnd = n;
        thirdLoop = n;
    }
    else if (n<=1000)
    {
        thirdLoop = 20;
        firstLoopEnd = 70;
        secondLoopEnd = 80;
    }
    else
    {
        thirdLoop = 2;
        firstLoopEnd = 4;
        secondLoopEnd = 14;
    }

    for (int i=1; i<=thirdLoop; i++)
    {
        solveBig(order[i],2);
    }

    for (int i=1; i<=secondLoopEnd; i++)
    {
        for (int j=1; j<=n; j++)
            cnt[j]=v[j].size();
        solveBig(order[i],5);
    }

    for (int i=1; i<=firstLoopEnd; i++)
    {
        int x = order[i];

        for (int j=1; j<=n; j++)
            cnt[j]=v[j].size();
        solveBig(x,4);

        solveBig(x,2);

        if (i==firstLoopEnd-2)
        {
            for (int j=1; j<=n; j++)
                sort(v[j].begin(),v[j].end(),cmp1);
        }
        else if (i==firstLoopEnd-1)
        {
            for (int j=1; j<=n; j++)
                sort(v[j].begin(),v[j].end(),cmp);
        }
    }

    if (n<=100)
    {
        for (int i=1; i<=10000; i++)
        {
            int x=rand()%n+1;
            solve1(x);
            solve2(x);
            solve3(x);
        }
        for (int j=1; j<=n; j++)
            random_shuffle(v[j].begin(),v[j].end());

        for (int i=1; i<=n; i++)
        {
            for (int j=1;j<=n;j++)
                cnt[j]=v[j].size();
            solveBig(i,6);
        }
    }
    else if (n<=1000)
    {
        for (int i=1; i<=400; i++)
        {
            int x = rand()%n+1;
            solve1(x);
            solve2(n-x+1);
            solve3(x);
        }

        for (int j=1; j<=n; j++)
            random_shuffle(v[j].begin(),v[j].end());
    }

}
int main()
{
    read();
    solve();
    print();
    return 0;
}