#include <iostream>
#include <fstream>
#include <vector>
#define DIM 100000


std::vector<int> G[DIM],sol;
int n,m;

void read(){
    std::ifstream f("ciclueuler.in");
    f>>n>>m;
    for(int i=0;i<m;i++){
        int x,y;
        f>>x>>y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    f.close();
    m*=2;
}

void eliminate(int x, int y){
    for(int i=0;i<G[x].size();i++){
        if(G[x][i]==y){
            G[x].erase(G[x].begin()+i);
            m--;
            break;
        }
    }
}

std::vector<int> cycle(int s){
    std::vector<int> c;
    int u=s;
    c.push_back(u);
    int v=G[u].front();
    eliminate(u,v);
    eliminate(v,u);
    while(v!=s){
        u=v;
        c.push_back(u);
        v=G[v].front();
        eliminate(u,v);
        eliminate(v,u);
    }
    c.push_back(v);
    return c;
}

void print_vect(std::vector<int> v){
    for(int i:v){
        std::cout<<i<<" ";
    }
    std::cout<<"\n";
}

void hierzholer(){
    std::vector<int> cur_path;
    std::vector<int> aux;
    int s=1;
    while(m){
        std::vector<int> cur_c=cycle(s);
        cur_path.insert(cur_path.end(),cur_c.begin(),cur_c.end());
        while (!cur_path.empty()&&G[cur_path.back()].size()<1){
            aux.push_back(cur_path.back());
            cur_path.pop_back();
        }
        if(!cur_path.empty()) {
            s = cur_path.back();
            cur_path.pop_back();
        }
    }
    while(!aux.empty()){
        sol.push_back(aux.back());
        aux.pop_back();
    }
    sol.pop_back();
}

void print_sol(){
    std::ofstream f("ciclueuler.out");
    for(int i:sol){
        f<<i<<" ";
    }
    f.close();
}
int main() {
    read();
    hierzholer();
    print_sol();
    return 0;
}