Problem:
Score : 800 points

Problem Statement

You are given a simple connected undirected graph consisting of N vertices and M edges.
The vertices are numbered 1 to N, and the edges are numbered 1 to M.

Edge i connects Vertex a_i and b_i bidirectionally.

Determine if three circuits (see Notes) can be formed using each of the edges exactly once.

Notes

A circuit is a cycle allowing repetitions of vertices but not edges.

Constraints

All values in input are integers.

1 \leq N,M \leq 10^{5}

1 \leq a_i, b_i \leq N

The given graph is simple and connected.

Input

Input is given from Standard Input in the following format:

N M
a_1 b_1
:
a_M b_M

Output

If three circuits can be formed using each of the edges exactly once, print Yes; if they cannot, print No.

Sample Input 1

7 9
1 2
1 3
2 3
1 4
1 5
4 5
1 6
1 7
6 7

Sample Output 1

Yes

Three circuits can be formed using each of the edges exactly once, as follows:

Sample Input 2

3 3
1 2
2 3
3 1

Sample Output 2

No

Three circuits are needed.

Sample Input 3

18 27
17 7
12 15
18 17
13 18
13 6
5 7
7 1
14 5
15 11
7 6
1 9
5 4
18 16
4 6
7 2
7 11
6 3
12 14
5 2
10 5
7 8
10 15
3 15
9 8
7 15
5 16
18 15

Sample Output 3

Yes

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <stdio.h>  
#include <algorithm>  
#include <assert.h>
#include <bitset>
#include <cmath>  
#include <complex>  
#include <deque>  
#include <functional>  
#include <iostream>  
#include <limits.h>  
#include <map>  
#include <math.h>  
#include <queue>  
#include <set>  
#include <stdlib.h>  
#include <string.h>  
#include <string>  
#include <time.h>  
#include <unordered_map>  
#include <unordered_set>  
#include <vector>  

#pragma warning(disable:4996)  
#pragma comment(linker, "/STACK:336777216")  
using namespace std;

#define mp make_pair  
#define Fi first  
#define Se second  
#define pb(x) push_back(x)  
#define szz(x) ((int)(x).size())  
#define rep(i, n) for(int i=0;i<n;i++)  
#define all(x) (x).begin(), (x).end()  
#define ldb ldouble  

typedef tuple<int, int, int> t3;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair <ll, int> pli;
typedef pair <db, db> pdd;

int IT_MAX = 1 << 19;
const ll MOD = 998244353;
const int INF = 0x3f3f3f3f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const db PI = acos(-1);
const db ERR = 1e-10;

set <int> conn[100050];
vector <int> Vl;
void DFS(int n) {
	while (!conn[n].empty()) {
		int t = *conn[n].begin();
		conn[n].erase(t);
		conn[t].erase(n);
		DFS(t);
	}
	Vl.push_back(n);
}

int main() {
	int N, M, i, j;
	scanf("%d %d", &N, &M);
	for (i = 1; i <= M; i++) {
		int t1, t2;
		scanf("%d %d", &t1, &t2);
		conn[t1].insert(t2);
		conn[t2].insert(t1);
	}

	for (i = 1; i <= N; i++) if (conn[i].size() % 2 != 0) return !printf("No\n");

//	for (i = 1; i <= N; i++) if (conn[i].size() >= 6) return !printf("Yes\n");

	DFS(1);
	Vl.pop_back();

	map <int, int> Mp;
	int d = INF, a1 = 0, a2 = 0;
	for (i = 0; i < 2 * Vl.size(); i++) {
		int t = Vl[i%Vl.size()];
		if (Mp.count(t)) {
			if (d > i - Mp[t]) {
				d = i - Mp[t];
				a1 = Mp[t];
				a2 = i;
			}
		}
		Mp[t] = i;
	}
	if (d >= Vl.size()) return !printf("No\n");

	map <int, int> Mc;
	a1++;
	for (i = 0; i < Vl.size(); i++) {
		if (a1 <= i && i <= a2) continue;
		if (a1 <= i + N && i + N <= a2) continue;
		Mc[Vl[i]]++;
	}
	for (auto it : Mc) if (it.second >= 2) return !printf("Yes\n");
	return !printf("No\n");
}