#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>

struct muchie{
    int x,y;
    int valid;
    muchie(int x_,int y_){
        x=x_;
        y=y_;
        valid=1;
    }
};

const int NMAX=100001;
std::vector<muchie>muchii;
std::vector<int>v[NMAX];
std::vector<int>sol;
int nr[NMAX];
class input_parser{
protected:
    FILE *fin;///Input file
    static const int max_load=1<<10;///Maximum Allocation
    size_t pos;///Index of the buffer
    char buffer[max_load];///Input is being store here
public:
    input_parser():pos(0){}
    input_parser(const char *);///Opens the specified file
    void open(const char *);///^
    template<class T>
    void read(T &);///Read function
    void read(){}
    template<class T,typename ... Args>
    void read(T & ,Args&...args);
    void read(char *,size_t);///Read a string
    inline char next();///Advances the buffer
};

input_parser::input_parser(const char * fName){
    this->fin=fopen(fName,"r");
    this->pos=0;
}

void input_parser::open(const char *fName){
    delete this->fin;
    memset(this->buffer,0,sizeof(this->buffer));
    this->fin=fopen(fName,"r");
    this->pos=0;
}

inline char input_parser::next(){
    if(this->pos==max_load)
            fread(this->buffer,1,max_load,this->fin),this->pos=0;
    return this->buffer[this->pos++];
}

template<class T>
void input_parser::read(T & nr){
    char c;
    int semn=1;
    nr=0;
    c=this->next();
    while(!isdigit(c) && c!='-')
        c=this->next();
    while(c=='-')
        c=this->next(),semn*=-1;
    while(isdigit(c))
        nr=nr*10+c-'0',c=this->next();
    nr*=semn;
}
template<class T,typename ... Args>
void input_parser::read(T & t,Args&...args){
    read(t);
    read(args...);
}

void input_parser::read(char *chp,size_t sz){
    char c;
    c=next();
    while(c==' ' || c=='\n')
        c=next();
    for(size_t i=0;i<sz && c!=' ' && c!='\n';i++)
        chp[i]=c,c=next();
}
input_parser in("ciclueuler.in");
void dfs(int nod){
    while(nr[nod]){
        for(int i=0;i<v[nod].size();i++){
            int m=v[nod][i];
            if(muchii[m].valid){
                muchii[m].valid=0;
                nr[nod]--;
                if(nod==muchii[m].x)
                    nr[muchii[m].y]--,dfs(muchii[m].y);
                else
                    nr[muchii[m].x]--,dfs(muchii[m].x);
                }
        }
    }
    sol.push_back(nod);
}
class output_parser{
protected:
    FILE *fout;
    char buff[1000000];
    int k;
public:
    output_parser():fout(NULL),k(0){}
    output_parser(const char *str):fout(fopen(str,"w")),k(0){}
    void print(int n){
        char add[10],nc=0;
        do{
            add[nc++]=n%10+'0';
            n/=10;
        }while(n);
        for(int i=nc-1;i>=0;i--)
            buff[k++]=add[i];
    }
    void print(unsigned int n){
        char add[10],nc=0;
        do{
            add[nc++]=n%10+'0';
            n/=10;
        }while(n);
        for(int i=nc-1;i>=0;i--)
            buff[k++]=add[i];
    }
    void print(char c){
        buff[k++]=c;
    }
    void refresh(){
        fwrite(buff,1,k,fout);
    }
};
output_parser out("ciclueuler.out");
int main(){
    int n,m;
    in.read(n,m);
    for(int i=0,x,y;i<m;i++){
        in.read(x,y);
        muchii.push_back(muchie(x,y));
        v[x].push_back(muchii.size()-1);
        v[y].push_back(muchii.size()-1);
        nr[x]++;
        nr[y]++;
    }
    dfs(1);
    sol.pop_back();
    for(int x:sol)
        out.print(x),out.print(' ');
    out.refresh();
    return 0;
}