#include <iostream>
#include <stdio.h>
#include <vector>
#include <string.h>
#include <algorithm>
#include <time.h>
using namespace std;
typedef long long llong;

bool TimeIsOK()
{
    return (double)clock() / (double)CLOCKS_PER_SEC < 4.0;
}

int n,m;
vector<int> Graph[100111];
bool TFO[100111];

int comefrom[100111];
llong val[100111];

void DFS(int ver, int dad, int num)
{
    if (TFO[ver])
        return;
    TFO[ver] = true;

    val[ver] = val[dad] + (llong)num * (llong)ver;
    comefrom[ver] = dad;

    int i;

    for (i=0;i<Graph[ver].size();i++)
    {
        DFS(Graph[ver][i], ver, num + 1);
    }

    return;
}

llong maxval;
int maxver;
vector<int> ans;

llong bestval = 0;
vector<int> bestans;

void examineVertex(int ver)
{
    int i;

    if (n == 100000)
        memset(TFO,false,sizeof(TFO));
    else
    {
        for (i=1;i<=n;i++)
        {
            TFO[i] = false;
        }
    }

    DFS(ver, 0, 1);

    maxver = 1;
    maxval = val[1];
    for (i=2;i<=n;i++)
    {
        if (val[i] > maxval)
        {
            maxval = val[i];
            maxver = i;
        }
    }

    ans.clear();
    while(maxver != 0)
    {
        ans.push_back(maxver);
        maxver = comefrom[maxver];
    }

    maxval = 0;

    for (i=0;i<ans.size();i++)
    {
        maxval += (llong)(i+1) * (llong)(ans[i]);
    }

    llong altval = 0;

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

    for (i=0;i<ans.size();i++)
    {
        altval += (llong)(i+1) * (llong)(ans[i]);
    }

    if (altval >= maxval)
        maxval = altval;
    else
        reverse(ans.begin(), ans.end());
}

int bestchoice[100111];
int maxlen[100111];
int w[100111];

bool SW(int v1,int v2)
{
    if (w[v1] != w[v2])
        return w[v1] < w[v2];
    else
        return v1 > v2;
}

void getPath(int ver)
{
    int i;

    TFO[ver] = true;

    for (i=0;i<Graph[ver].size();i++)
    {
        w[ Graph[ver][i] ]--;
    }

    bestchoice[ver] = 0;
    maxlen[ver] = 1;

    sort(Graph[ver].begin(), Graph[ver].end(), SW);

    for (i=0;i<Graph[ver].size();i++)
    {
        int nver = Graph[ver][i];

        if (TFO[nver])
            continue;

        getPath(nver);

        if (maxlen[nver] + 1 > maxlen[ver])
        {
            maxlen[ver] = maxlen[nver] + 1;
            bestchoice[ver] = nver;
        }
    }
}

bool inPath[100111];

void longPath(int ver)
{
    int i,j,in;

    if (n == 100000)
        memset(TFO,false,sizeof(TFO));
    else
    {
        for (i=1;i<=n;i++)
        {
            TFO[i] = false;
        }
    }

    for (i=1;i<=n;i++)
    {
        w[i] = Graph[i].size();
    }

    getPath(ver);

    ans.clear();

    int cur = ver;

    while(cur != 0)
    {
        inPath[cur] = true;

        ans.push_back(cur);
        cur = bestchoice[cur];
    }

    maxval = 0;
    for (i=0;i<ans.size();i++)
    {
        maxval += (llong)(i + 1) * (llong)ans[i];
    }

    llong altval = 0;
    int mult = 1;

    for (i=ans.size() - 1; i >= 0; i--)
    {
        altval += (llong)mult * (llong)ans[i];
        mult++;
    }

    if (altval > maxval)
    {
        reverse(ans.begin(), ans.end());
        maxval = altval;
    }
}

int genNum(int lim)
{
    return rand() % lim;
}

int genNum(int L,int R)
{
    return genNum(R - L + 1) + L;
}

int MAX(int a,int b)
{
    if (a > b)
        return a;
    else
        return b;
}

void smallShuffle(int ver, int coef)
{
    int i;

    sort(Graph[ver].begin(), Graph[ver].end());
    reverse(Graph[ver].begin(), Graph[ver].end());

    for (i=1;i<Graph[ver].size();i++)
    {
        int prev = genNum(MAX(0, i - coef), i);
        int swp;

        swp = Graph[ver][i];
        Graph[ver][i] = Graph[ver][prev];
        Graph[ver][prev] = swp;
    }
}

const int KV = 14;
int mem[101][KV][(1<<KV)];
int choice[101][KV][(1<<KV)];

int getLengths(int maxver,int mvb,unsigned int mask)
{
    if (mem[maxver][mvb][mask] != -1)
        return mem[maxver][mvb][mask];

    int ver = maxver - mvb;
    int i;
    int ans = 1;
    int cur;

    choice[maxver][mvb][mask] = 0;
    //fprintf(stderr,"%d %d %u\n",maxver,mvb,mask);

    for (i=0;i<Graph[ver].size();i++)
    {
        if (Graph[ver][i] <= maxver - KV)
            continue;

        if (Graph[ver][i] <= maxver)
        {
            if ( (mask&(1<<(maxver - Graph[ver][i]))) == 0 )
            {
                cur = getLengths(maxver, maxver - Graph[ver][i], mask|(1<<(maxver - Graph[ver][i]))) + 1;

                if (ans < cur)
                {
                    ans = cur;
                    choice[maxver][mvb][mask] = Graph[ver][i];
                }
            }
        }
        else
        {
            cur = getLengths(Graph[ver][i], 0, ((mask<<(Graph[ver][i] - maxver))&((1<<KV)-1)) | 1 ) + 1;

            if (ans < cur)
            {
                ans = cur;
                choice[maxver][mvb][mask] = Graph[ver][i];
            }
        }
    }

    mem[maxver][mvb][mask] = ans;

    return ans;
}

void restoreArray(int maxver, int mvb, unsigned int mask)
{
    ans.push_back(maxver - mvb);

    int nver = choice[maxver][mvb][mask];

    if (nver == 0)
        return;

    if (nver <= maxver)
        restoreArray(maxver, maxver - nver, mask|(1<<(maxver - nver)));
    else
        restoreArray(nver, 0, ((mask<<(nver - maxver))&((1<<KV)-1)) | 1);
}

bool SE(int v1,int v2)
{
    return v1 / (int)Graph[v1].size() > v2 / (int)Graph[v2].size();
}

bool SE2(int v1,int v2)
{
    return (int)Graph[v1].size() < (int)Graph[v2].size();
}

bool SE3(int v1,int v2)
{
    return v1 > v2;
}

bool SE4(int v1,int v2)
{
    return v1 / ((int)Graph[v1].size()*(int)Graph[v1].size()) > v2 / ((int)Graph[v2].size()*(int)Graph[v2].size());
}

vector<int> inputOrder;
bool seenOnInput[100111];

int main()
{
    freopen("maxpath.in","r",stdin);
    freopen("maxpath.out","w",stdout);

    memset(mem,-1,sizeof(mem));

    int i,j;

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

    for (i=1;i<=m;i++)
    {
        int a,b;

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

        if (!seenOnInput[a])
        {
            inputOrder.push_back(a);
            seenOnInput[a] = true;
        }

        if (!seenOnInput[b])
        {
            inputOrder.push_back(b);
            seenOnInput[b] = true;
        }

        Graph[a].push_back(b);
        Graph[b].push_back(a);
    }

    if (n == 100000)
    {
        for (int sa = 0; sa <= 3; sa++)
        {
            if (!TimeIsOK())
                break;

            for (i=1;i<=n;i++)
            {
                if (sa == 1)
                {
                    sort(Graph[i].begin(), Graph[i].end(), SE);
                }
                else if (sa == 2)
                {
                    sort(Graph[i].begin(), Graph[i].end(), SE2);
                }
                else if (sa == 3)
                {
                    sort(Graph[i].begin(), Graph[i].end(), SE3);
                }

            }

            for (i=0;i<10;i++)
            {
                if (!TimeIsOK())
                    break;

                int ver;
                if (i == 0)
                    ver = inputOrder[0];
                else if (i == 1)
                    ver = inputOrder.back();
                else
                    ver = inputOrder[i];

                longPath(ver);

                if (maxval > bestval)
                {
                    bestans.clear();
                    for (j=0;j<ans.size();j++)
                    {
                        bestans.push_back(ans[j]);
                    }

                    bestval = maxval;
                }

                examineVertex(ver);

                if (maxval > bestval)
                {
                    bestans.clear();
                    for (j=0;j<ans.size();j++)
                    {
                        bestans.push_back(ans[j]);
                    }

                    bestval = maxval;
                }
            }
        }
    }
    else if (n == 1000)
    {
        int iter;

        for (iter=1;iter<=5;iter++)
        {
            if (!TimeIsOK())
                break;

            if (iter != 1)
            {
                for (i=1;i<=n;i++)
                {
                    smallShuffle(i, iter * 2);
                }
            }

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

                if (maxval > bestval)
                {
                    bestans.clear();
                    for (j=0;j<ans.size();j++)
                    {
                        bestans.push_back(ans[j]);
                    }

                    bestval = maxval;
                }
            }
        }
    }
    else
    {
        for (i=1;i<=n;i++)
        {
            sort(Graph[i].begin(), Graph[i].end());
        }

        getLengths(1, 0, 1);
        ans.clear();
        restoreArray(1, 0, 1);

        bestval = 0;
        for (i=0;i<ans.size();i++)
        {
            bestval += (llong)(i + 1) * (llong)ans[i];
            bestans.push_back(ans[i]);
        }

        int iter;

        for (iter=1;;iter++)
        {
            if (!TimeIsOK())
                break;

            if (iter != 1)
            {
                for (i=1;i<=n;i++)
                {
                    smallShuffle(i, iter/20 + 1);
                }
            }

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

                if (maxval > bestval)
                {
                    bestans.clear();
                    for (j=0;j<ans.size();j++)
                    {
                        bestans.push_back(ans[j]);
                    }

                    bestval = maxval;
                }
            }
        }
    }

    printf("%d\n",(int)bestans.size());
    for (i=0;i<bestans.size();i++)
    {
        printf("%d\n",bestans[i]);
    }

    fprintf(stderr,"%lld\n",bestval);
    fprintf(stderr,"Length = %d\n",(int)bestans.size());

    return 0;
}