Problem: The project of a data center of a Big Software Company consists of n computers connected by m cables. Simply speaking, each computer can be considered as a box with multiple cables going out of the box. Very Important Information is transmitted along each cable in one of the two directions. As the data center plan is not yet approved, it wasn't determined yet in which direction information will go along each cable. The cables are put so that each computer is connected with each one, perhaps through some other computers.

The person in charge of the cleaning the data center will be Claudia Ivanova, the janitor. She loves to tie cables into bundles using cable ties. For some reasons, she groups the cables sticking out of a computer into groups of two, and if it isn't possible, then she gets furious and attacks the computer with the water from the bucket.

It should also be noted that due to the specific physical characteristics of the Very Important Information, it is strictly forbidden to connect in one bundle two cables where information flows in different directions.

The management of the data center wants to determine how to send information along each cable so that Claudia Ivanova is able to group all the cables coming out of each computer into groups of two, observing the condition above. Since it may not be possible with the existing connections plan, you are allowed to add the minimum possible number of cables to the scheme, and then you need to determine the direction of the information flow for each cable (yes, sometimes data centers are designed based on the janitors' convenience...)

Input

The first line contains two numbers, n and m (1 ≤ n ≤ 100 000, 1 ≤ m ≤ 200 000) — the number of computers and the number of the already present cables, respectively.

Each of the next lines contains two numbers ai, bi (1 ≤ ai, bi ≤ n) — the indices of the computers connected by the i-th cable. The data centers often have a very complex structure, so a pair of computers may have more than one pair of cables between them and some cables may connect a computer with itself.

Output

In the first line print a single number p (p ≥ m) — the minimum number of cables in the final scheme.

In each of the next p lines print a pair of numbers ci, di (1 ≤ ci, di ≤ n), describing another cable. Such entry means that information will go along a certain cable in direction from ci to di.

Among the cables you printed there should be all the cables presented in the original plan in some of two possible directions. It is guaranteed that there is a solution where p doesn't exceed 500 000.

If there are several posible solutions with minimum possible value of p, print any of them.

Examples

Input

4 6
1 2
2 3
3 4
4 1
1 3
1 3


Output

6
1 2
3 4
1 4
3 2
1 3
1 3

Input

3 4
1 2
2 3
1 1
3 3


Output

6
2 1
2 3
1 1
3 3
3 1
1 1

Note

Picture for the first sample test. The tied pairs of cables are shown going out from the same point.

<image>

Picture for the second test from the statement. The added cables are drawin in bold.

<image>

Alternative answer for the second sample test:

<image>

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Stack;
import java.util.StringTokenizer;

public class _527E {

    static int MAX = 500000;
    static int n;
    static int m;
    static int[] node, next, pre, twin;
    static int[] e, degree;
    static int ramPtr = 0;

    static void add(int u, int v) {
        int cb = ramPtr++;
        int wb = ramPtr++;

        node[cb] = v;
        next[cb] = next[e[u]];
        pre[cb] = e[u];
        pre[next[cb]] = next[pre[cb]] = cb;
        twin[cb] = wb;
        degree[u]++;

        node[wb] = u;
        next[wb] = next[e[v]];
        pre[wb] = e[v];
        pre[next[wb]] = next[pre[wb]] = wb;
        twin[wb] = cb;
        degree[v]++;
    }

    public static void main(String[] args) throws Exception {
        Reader.init(System.in);
        BufferedWriter cout = new BufferedWriter(new OutputStreamWriter(System.out));

        n = Reader.nextInt();
        m = Reader.nextInt();
        node = new int[2 * MAX];
        pre = new int[2 * MAX];
        next = new int[2 * MAX];
        twin = new int[2 * MAX];
        e = new int[n];
        degree = new int[n];
        for (int i = 0; i < n; i++) {
            next[ramPtr] = pre[ramPtr] = ramPtr;
            e[i] = ramPtr;
            ramPtr++;
        }
        for (int i = 0; i < m; i++) {
            int u = Reader.nextInt() - 1;
            int v = Reader.nextInt() - 1;
            add(u, v);
        }

        // add edges to vertices of odd degree
        for (int i = 0; i < n;)
            if (degree[i] % 2 == 1) {
                for (int j = i + 1; j < n; j++)
                    if (degree[j] % 2 == 1) {
                        add(i, j);
                        i = j + 1;
                        m++;
                        break;
                    }
            } else {
                i++;
            }

        // add a self-loop if # of edges is odd
        if (m % 2 == 1) {
            add(0, 0);
            m++;
        }

        // Now do the euler tour
        int[] tour = eulerTour();
        cout.write(String.format("%d%n", m));
        boolean flag = true;
        for (int i = 0; i < tour.length - 1; i++, flag = !flag)
            if (flag)
                cout.write(String.format("%d %d%n", tour[i] + 1, tour[i + 1] + 1));
            else
                cout.write(String.format("%d %d%n", tour[i + 1] + 1, tour[i] + 1));

        cout.close();
    }

    static void remove(int i) {
        next[pre[i]] = next[i];
        pre[next[i]] = pre[i];
    }

    static int[] eulerTour() {
        Stack<Integer> res = new Stack<>();
        Stack<Integer> stack = new Stack<>();
        stack.add(0);
        while (!stack.isEmpty()) {
            //            for (int i = 0; i < n; i++) {
            //                System.out.print(i + ": ");
            //                for (int j = next[e[i]]; j != e[i]; j = next[j])
            //                    System.out.print((node[j]) + " ");
            //                System.out.println();
            //            }
            //            System.out.println();

            int u = stack.pop();
            if (next[e[u]] != e[u]) {
                stack.push(u);

                int e1 = next[e[u]];
                int e2 = twin[e1];
                remove(e1);
                remove(e2);
                stack.push(node[e1]);
            } else {
                res.add(u);
            }
        }
        //        System.out.println(res);

        int[] arr = new int[res.size()];
        for (int i = 0; !res.isEmpty(); i++)
            arr[i] = res.pop();
        return arr;
    }

    static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
        final U _1;
        final V _2;

        private Pair(U key, V val) {
            this._1 = key;
            this._2 = val;
        }

        public static <U extends Comparable<U>, V extends Comparable<V>> Pair<U, V> instanceOf(U _1, V _2) {
            return new Pair<U, V>(_1, _2);
        }

        @Override
        public String toString() {
            return _1 + " " + _2;
        }

        @Override
        public int hashCode() {
            int res = 17;
            res = res * 31 + _1.hashCode();
            res = res * 31 + _2.hashCode();
            return res;
        }

        @Override
        public int compareTo(Pair<U, V> that) {
            int res = this._1.compareTo(that._1);
            if (res < 0 || res > 0)
                return res;
            else
                return this._2.compareTo(that._2);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (!(obj instanceof Pair))
                return false;
            Pair<?, ?> that = (Pair<?, ?>) obj;
            return _1.equals(that._1) && _2.equals(that._2);
        }
    }

    /** Class for buffered reading int and double values */
    static class Reader {
        static BufferedReader reader;
        static StringTokenizer tokenizer;

        /** call this method to initialize reader for InputStream */
        static void init(InputStream input) {
            reader = new BufferedReader(new InputStreamReader(input));
            tokenizer = new StringTokenizer("");
        }

        /** get next word */
        static String next() throws IOException {
            while (!tokenizer.hasMoreTokens()) {
                // TODO add check for eof if necessary
                tokenizer = new StringTokenizer(reader.readLine());
            }
            return tokenizer.nextToken();
        }

        static int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        static double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }
    }

    static class ArrayUtil {
        static void swap(int[] a, int i, int j) {
            int tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }

        static void swap(long[] a, int i, int j) {
            long tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }

        static void swap(double[] a, int i, int j) {
            double tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }

        static void swap(char[] a, int i, int j) {
            char tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }

        static void swap(boolean[] a, int i, int j) {
            boolean tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }

        static void reverse(int[] a, int i, int j) {
            for (; i < j; i++, j--)
                swap(a, i, j);
        }

        static void reverse(long[] a, int i, int j) {
            for (; i < j; i++, j--)
                swap(a, i, j);
        }

        static void reverse(double[] a, int i, int j) {
            for (; i < j; i++, j--)
                swap(a, i, j);
        }

        static void reverse(char[] a, int i, int j) {
            for (; i < j; i++, j--)
                swap(a, i, j);
        }

        static void reverse(boolean[] a, int i, int j) {
            for (; i < j; i++, j--)
                swap(a, i, j);
        }

        static long sum(int[] a) {
            int sum = 0;
            for (int i : a)
                sum += i;
            return sum;
        }

        static long sum(long[] a) {
            long sum = 0;
            for (long i : a)
                sum += i;
            return sum;
        }

        static double sum(double[] a) {
            double sum = 0;
            for (double i : a)
                sum += i;
            return sum;
        }

        static int max(int[] a) {
            int max = Integer.MIN_VALUE;
            for (int i : a)
                if (i > max)
                    max = i;
            return max;
        }

        static int min(int[] a) {
            int min = Integer.MAX_VALUE;
            for (int i : a)
                if (i < min)
                    min = i;
            return min;
        }

        static long max(long[] a) {
            long max = Long.MIN_VALUE;
            for (long i : a)
                if (i > max)
                    max = i;
            return max;
        }

        static long min(long[] a) {
            long min = Long.MAX_VALUE;
            for (long i : a)
                if (i < min)
                    min = i;
            return min;
        }
    }
}