/* 
 * File:   CicluEulerian.cpp
 * Author: slycer
 *
 * Created on December 31, 2011, 6:30 PM
 */

#include <cstdlib>
#include <vector>
#include <algorithm>
#include <set>
#include <fstream>
#include <iostream>

using namespace std;

class Graf{
    
public :
    int n;
    vector<int> *data; 
    int *grad; 
    Graf( int n){
        this->n = n; 
        data = new vector<int>[n+1]; 
        grad = new int[n+1];
        for ( int i=0; i<=n; i++ ){
            grad[i] = 0; 
        }
    }
    
    void sort_(){
        for ( int i=1; i<=n; i++){
            sort( data[i].begin(), data[i].end() );
        }
    }
    
    void add( int a, int b ){
        data[a].push_back( b );
        data[b].push_back( a );
        grad[a]++;
        grad[b]++;
    }
    
    bool isEulerian(){
        if ( !isConnex() ){
            return false; 
        }
        for ( int i=1; i<=n; i++ ){
            if ( grad[i] % 2 == 1 ){
                return false; 
            }
        }
        return true; 
    }
    
    vector<int> printSolution(){
        vector<int> sol; 
        vector<int> stack_a;
        stack_a.push_back( 1 );
        
        while ( stack_a.size() > 0 ){
            int a = stack_a.back(); 
            bool gata = true; 
            while ( data[a].size() > 0 ){
                int c = data[a].back(); 
                data[a].pop_back(); 
                if ( c > n ){
                    continue;
                }
                if ( binary_search( data[c].begin(), data[c].end(),a) ){
                    vector<int>::iterator  lb = 
                                lower_bound( data[c].begin(), data[c].end(), a );
                    data[c][ lb - data[c].begin() ] = 1000000;
                    stack_a.push_back( c );
                    gata = false; 
                    break;
                }
            }
            
            if ( gata ){
                sol.push_back( a );
                stack_a.pop_back(); 
            }
        }
        return sol;
        
    }
    
    bool isConnex(){
        vector<int> v; 
        bool *marcat = new bool[n+1]; 
        for ( int i=0; i<=n; i++){
            marcat[i] = false; 
        }
        marcat[1] = true; 
        v.push_back( 1 );
        int op=0; 
        while ( v.size() > 0 ){
            op++;
            int current = v.back(); 
            v.pop_back(); 
            for ( int i=0; i<data[current].size(); i++ ){
                int next = data[current][i];
                if ( !marcat[next] ){
                    v.push_back( next );
                    marcat[next] = true; 
                }
            }
        }
        return op == n; 
    }
    
};
/*
 * 
 */
int main(int argc, char** argv) {

    ifstream input( "ciclueuler.in" );
    ofstream output( "ciclueuler.out" );
    
    int n,m; 
    input >> n >> m; 
    Graf g(n); 
    for ( int i=0; i<m; i++){
        int a,b;
        input >> a >> b;
        g.add( a, b );
       // g.add( b, a );
    }
    g.sort_(); 
    
    vector<int> sol = g.printSolution();
    for ( int i=0; i<sol.size()-1; i++){
        //cout << sol[i] << endl;
        output << sol[i] << " ";
    }
    return 0;
}