#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 105

struct Edge{

	bool operator<(const struct Edge &arg) const{
		if(from != arg.from){

			return from < arg.from;
		}else{

			return to < arg.to;
		}
	}

	Edge(int arg_from,int arg_to){
		from = arg_from;
		to = arg_to;
	}
	int from,to;
};

int V,E;
int table[NUM]; //ノードから出ている辺の数
int boss[NUM],height[NUM],member_num[NUM];
int num_add[NUM];
int parent[NUM]; //偶奇の木における親
bool check[NUM][NUM],visited[NUM],is_GU[NUM];
vector<int> MEMBER[NUM];
vector<Edge> neg_G[NUM],ans;

//自分のボスのindexを取得しつつ、経路圧縮を行う関数
int get_boss(int id){
	if(boss[id] == id)return id; //自分が代表なら、自分の値を返す
	else{
		return boss[id] = get_boss(boss[id]); //代表でないなら、自分が所属する組織の代表を返しつつ、経路圧縮
	}
}

int is_same(int x,int y){
	return get_boss(x) == get_boss(y);
}

void unite(int x,int y){
	int boss_x = get_boss(x);
	int boss_y = get_boss(y);

	//既に同じグループなら何もしない
	if(boss_x == boss_y)return;

	//高さが高い方に吸収する
	if(height[x] > height[y]){

		member_num[boss_x] += member_num[boss_y];
		boss[boss_y] = boss_x;

	}else if(height[x] < height[y]){

		member_num[boss_y] += member_num[boss_x];
		boss[boss_x] = boss_y;

	}else{ //height[x] == height[y]

		member_num[boss_x] += member_num[boss_y];
		boss[boss_y] = boss_x;
		height[x]++;
	}
}

void dfs(int node_id,int pre_node){

	for(int next = 0; next < V; next++){

		if(visited[next] == true || check[node_id][next] == true)continue;

		visited[next] = true;

		dfs(next,node_id);
	}

	if(!is_GU[node_id]){ //ここで、グループ間をまたぐ辺を張り得る
		if(pre_node != -1){
			ans.push_back(Edge(min(node_id,pre_node),max(node_id,pre_node)));

			unite(node_id,pre_node); //★注意★

			is_GU[node_id] = true;
			is_GU[pre_node] = 1-is_GU[pre_node];

			check[node_id][pre_node] = true;
			check[pre_node][node_id] = true;

			table[node_id]++;
			table[pre_node]++;
		}
	}
}

void outPut(){

	sort(ans.begin(),ans.end());

	printf("%lld\n",ans.size());

	for(int i = 0; i < ans.size(); i++){

		printf("%d %d\n",ans[i].from+1,ans[i].to+1);
	}
}

int main(){


	scanf("%d %d",&V,&E);

	for(int i = 0; i < V; i++){

		table[i] = 0;
	}

	for(int from = 0; from < V; from++){
		for(int to = 0; to < V; to++){

			check[from][to] = (from==to); //from-toに辺があるか
		}
	}

	for(int i = 0; i < V; i++){

		boss[i] = i;
		height[i] = i;
		member_num[i] = 1;
	}

	int from,to;

	for(int loop = 0; loop < E; loop++){

		scanf("%d %d",&from,&to);

		from--;
		to--;

		table[from]++;
		table[to]++;

		check[from][to] = true;
		check[to][from] = true;

		unite(from,to);
	}



	for(int i = 0; i < V; i++){

		is_GU[i] = (table[i]%2 == 0); //次数が偶数かどうか
		visited[i] = false;
	}

	vector<int> ROOT;

	//補グラフを作る
	for(int i = 0; i < V; i++){
		if(visited[i])continue;

		visited[i] = true;
		ROOT.push_back(i);
		dfs(i,-1);
	}



	for(int i = 0; i < ROOT.size(); i++){

		if(!is_GU[ROOT[i]]){

			printf("-1\n");
			return 0;
		}
	}

	//グループ数を数える
	vector<int> BOSS;

	for(int i = 0; i < V; i++){
		if(i == get_boss(i)){
			BOSS.push_back(i);
		}
	}

	for(int i = 0; i < V; i++){

		MEMBER[get_boss(i)].push_back(i); //メンバーを取得
	}

	if(BOSS.size() == 1){

		outPut();

	}else if(BOSS.size() == 2){ //コーナーケースあり

		if(member_num[BOSS[0]] > member_num[BOSS[1]])swap(BOSS[0],BOSS[1]);
		for(int i = 0; i < V; i++)MEMBER[i].clear();

		for(int i = 0; i < V; i++){

			MEMBER[get_boss(i)].push_back(i); //メンバーを取得
		}

		//2つのグループのサイズがいずれも2以上か
		vector<int> P;

		P.push_back(member_num[BOSS[0]]);
		P.push_back(member_num[BOSS[1]]);

		if(P[0] >= 2){

			//グループ同士を結んで連結にする
			ans.push_back(Edge(min(MEMBER[BOSS[0]][0],MEMBER[BOSS[1]][0]),max(MEMBER[BOSS[0]][0],MEMBER[BOSS[1]][0])));
			ans.push_back(Edge(min(MEMBER[BOSS[0]][0],MEMBER[BOSS[1]][1]),max(MEMBER[BOSS[0]][0],MEMBER[BOSS[1]][1])));

			ans.push_back(Edge(min(MEMBER[BOSS[0]][1],MEMBER[BOSS[1]][0]),max(MEMBER[BOSS[0]][1],MEMBER[BOSS[1]][0])));
			ans.push_back(Edge(min(MEMBER[BOSS[0]][1],MEMBER[BOSS[1]][1]),max(MEMBER[BOSS[0]][1],MEMBER[BOSS[1]][1])));
			outPut();

		}else{


			if(P[0] == 1 && P[1]%2 == 1){ //コーナーケース

				if(E+ans.size() == (member_num[BOSS[1]])*(member_num[BOSS[1]]-1)/2){ //完全グラフ+孤立点なら不可
					printf("-1\n");

				}else{

					vector<int> D;
					//次数がノード数-1でない、偶数頂点をピックアップ
					for(int i = 0; i < MEMBER[BOSS[1]].size(); i++){
						if(table[MEMBER[BOSS[1]][i]] < MEMBER[BOSS[1]].size()-1){
							D.push_back(MEMBER[BOSS[1]][i]);
						}
					}

					for(int i = 0; i < V; i++){

						visited[i] = false;
					}

					//とりあえず直線を作る
					queue<int> Q;

					int start = D[0],end = D[1];
					visited[start] = true;

					Q.push(start);

					while(!Q.empty()){

						end = Q.front();

						for(int next = 0; next < D.size(); next++){
							if(visited[D[next]] == true || check[Q.front()][D[next]] == true)continue;

							visited[D[next]] = true;
							ans.push_back(Edge(min(Q.front(),D[next]),max(Q.front(),D[next])));
							check[Q.front()][D[next]] = true;
							check[D[next]][Q.front()] = true;
							Q.push(D[next]);
							break;
						}

						Q.pop();
					}

					//孤立点からstart-endを結んで輪にする
					ans.push_back(Edge(min(BOSS[0],start),max(BOSS[0],start)));
					ans.push_back(Edge(min(BOSS[0],end),max(BOSS[0],end)));

					outPut();
				}

			}else{ //1+偶数

				//すべての頂点に辺を張る
				for(int i = 0; i < MEMBER[BOSS[1]].size(); i++){

					ans.push_back(Edge(min(BOSS[0],MEMBER[BOSS[1]][i]),max(BOSS[0],MEMBER[BOSS[1]][i])));
				}

				//偶数の方を、完全グラフにする(★次数を奇数にするため→孤立点との辺で偶数になる★)
				for(int i = 0; i < MEMBER[BOSS[1]].size(); i++){
					from = MEMBER[BOSS[1]][i];
					for(int k = i+1; k < MEMBER[BOSS[1]].size(); k++){
						to = MEMBER[BOSS[1]][k];

						if(check[from][to])continue;

						check[from][to] = true;
						check[to][from] = true;

						ans.push_back(Edge(min(from,to),max(from,to)));
					}
				}

				outPut();
			}
		}

	}else{

		//ボス同士を結んで連結にする
		for(int i = 0; i < BOSS.size(); i++){

			ans.push_back(Edge(min(BOSS[i],BOSS[(i+1)%BOSS.size()]),max(BOSS[i],BOSS[(i+1)%BOSS.size()])));
		}

		outPut();
	}

	return 0;
}



Measured memory_bytes: 3344