/*#include <cstdio>

using namespace std;

int m,n;
int d[100];
bool g[100][100];

struct nod{int vf;
            nod *urm;
}

typedef nod * lista;

lista c1,c2;



void dfs(int x){

    viz[x]=1;
    for(j=1;j<=n;++j){

        if(g[x][j] && !viz[j]){

            dfs(j);

        }

    }
}

bool gradepare(){

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

        if(d[i]%2==1){

            return 0;

        }
    }
    return 1;

}

void citire(){

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

    for(i=1;i<=m;++i){

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

        g[x][y]=g[y][x]=true;
        d[x]++;
        d[y]++;

    }

}
bool conex(){

    for(x=1;x<=n && !d[x];++x);

    if(x>n) return 1;
    dfs(x);
    for(x=1;x<=n;++x)//verific daca au mai ramas vf neviz si neizolate
        if(viz[x] && d[x])
            return 0;
    return 1;

}

int ciclu(int x,lista &c,lista &sfc){

    //incep ciclul cu vf x;
    p=new nod;
    p->urm=NULL;
    p->vf=x;
    c=p;
    sfc=p;

    do
    {

        //caut y un vf ad cu ultimul vf din lista
        //parcurg linia uvf pana dau de un
        uvf=sfc->vf;
        for(y=1;!g[uvf][y];++y);
        p=new nod;
        p->vf=y;
        p->urm=NULL;
        sfc->urm=p;
        sfc=p;
        ++lg;
        g[uvf][y]=0;
        g[y][uvf]=0;

        d[y]--;
        d[uvf]--;

    }
    while(y!=x);

    return lg;

}
void determina_eulerian(){
    int x,nr2,total;
    lista p;
    //caut un vf cu gradul nenul;
    for(i=1;i<=n && !d[i];++i);

    total+=ciclu(x,c1,sfc1);

    while(total<=m){
        //caut pe c1 un vf cu gradul nenul

        for(p=c1;d[p->vf];p=p->urm);
        nr2=ciclu(p->vf,c2,sfc2);
        //reunesc ciclul c1 cu c2
        q=p->urm;

        p->urm=c2->urm;

        sfc2->urm=1;

        total+=nr2;
    }

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

    citire();

    //dfs dintr-un vf neizolat
    for(i=1;i<=n && !d[i];++i);

    if(i>n) printf("grad izolat");
    dfs(i);
    if(conex() && gradepare()){

        printf("eulerian");
        ciclu();

    }
    else{

        printf("neeulerian");

    }

    return 0;
}
*/

#include <fstream>
using namespace std;

ifstream fin("euler.in");
ofstream fout("euler.out");

int n, m;
int G[101][101],d[100];

struct nod
{
    int x;
    struct nod * urm;
};
typedef nod * lista;

lista C1,C2,sfc1,sfc2;

void citire();
void euler();
void afisare();
int ciclu(int st, lista & C, lista & sf);
lista cauta();

int main()
{
    int total=0,nr;
    lista p,q;
    citire();
    // construim primul ciclu
    total+=ciclu(1,C1,sfc1);
    while(total<m) //mai am muchii care nu apartin ciclului
    {
        //caut un varf care apartine lui C1 incident cu o muchie care nu apartine lui C1
        p=cauta();
        nr=ciclu(p->x, C2, sfc2);
        //unific C1 cu C2
        q=p->urm;
        p->urm=C2->urm;
        sfc2->urm=q;
        total+=nr;
    }
    afisare();
    return 0;
}

void citire()
{
    int i,a,b;
    fin>>n>>m;
    for(i=1;i<=m;i++)
    {
        fin>>a>>b;
        if(a!=b){
        G[a][++G[a][0]]=b;
        ++d[a];
        G[b][++G[b][0]]=a;
        ++d[b];
        }
        else{

            G[a][++G[a][0]]=a;
            ++d[a];
        }
    }
}

int ciclu(int st,lista & C,lista & sf)
{
    int vf,i,nr=0,nou;
    lista p;
    p=new nod;
    p->x=st;
    p->urm=NULL;
    C=sf=p;
    //construiesc ciclul
    do
    {
        vf=sf->x;
        for(i=1;i<=G[vf][0];i++)
            if(G[vf][i]!=0)
                break;
        // creez un nod cu informatia i si il inserez la sfarsitul listei C
        nou=G[vf][i];
        p=new nod;
        p->x=nou;
        p->urm=NULL;
        sf->urm=p;
        sf=p;
        nr++;
        //elimin din graf muchia vf i
        G[vf][i]=0;
        --d[vf];
        for(int j=1;j<=G[i][0];++j){

            if(G[nou][j]==vf){
                G[nou][j]=0;
                --d[nou];
                break;
            }
        }

    }
    while(nou!=st);
    return nr;
}

lista cauta()
{
    int i;
    lista p;
    // caut in lista C1 un nod care mai are muchii incidente cu el
    for(p=C1;p!=NULL;p=p->urm)
        if(d[p->x])
        return p;
}

void afisare()
{
    lista p;
    for(p=C1;p->urm!=NULL;p=p->urm)
        fout << p->x << ' ';
    fout<<'\n';
    fout.close();
}