#include <algorithm>
#include <bitset>
#include <queue>
#include <vector>
using namespace std;

#define DIM 1<<8

int N, M, XXX, L[ DIM ], R[ DIM ];
bitset <DIM> F;
vector <int> V[ DIM ];

inline int last( const int &X ) {

    if( !L[ X ] )
        return X;

    return last( L[ X ] );
}

inline int pair_up( const int &X ) {

    unsigned int I;

    if( F[ X ] )
        return 0;

    F[ X ] = 1;
    for( I = 0; I < V[ X ].size(); ++I )
        if( !R[ V[ X ][ I ] ] ) {

            L[ X ] = V[ X ][ I ];
            R[ V[ X ][ I ] ] = X;

            return 1;
        }

    for( I = 0; I < V[ X ].size(); ++I )
        if( pair_up( R[ V[ X ][ I ] ] ) ) {

            L[ X ] = V[ X ][ I ];
            R[ V[ X ][ I ] ] = X;

            return 1;
        }

    return 0;
}

inline void print( const int &X ) {

    if( !X )
        return;

    printf( "%d ", X );
    print( L[ X ] );
}

int main() {

    freopen( "strazi.in", "r", stdin );
    freopen( "strazi.out", "w", stdout );

    int i, x, y, ok, f_next, f_prev, l_next, l_prev;

    scanf( "%d %d", &N, &M );
    for( i = 0; i < M; ++i ) {

        scanf( "%d %d", &x, &y );
        V[ x ].push_back( y );
    }

    do {

        ok = 0;
        F.reset();
        for( i = 1; i <= N; ++i )
            if( !L[ i ] && pair_up( i ) )
                ok = 1;
    }
    while( ok );

//    for( int i = 1; i <= N; ++i )
//        printf( "%d %d\n", L[ i ], R[ i ] );

    for( i = 1; i <= N; ++i )
        if( !L[ i ] )
            ++XXX;

    printf( "%d\n", XXX-1 );

    f_prev = l_prev = 0;
    for( i = 1; i <= N; ++i )
        if( !R[ i ] ) {

            f_next = i;
            l_next = last( i );
            if( f_prev && l_prev ) {

                printf( "%d %d\n", l_prev, f_next );
                L[ l_prev ] = f_next;
                R[ f_next ] = l_prev;
            }
            f_prev = f_next;
            l_prev = l_next;
        }

//    for( i = 1; i <= N; ++i )
//        printf( "%d %d\n", L[ i ], R[ i ] );

    for( i = 1; i <= N; ++i )
        if( !R[ i ] ) {

            print( i );
            break;
        }

    return 0;
}