Problem:
Score : 900 points

Problem Statement

There are 2N points evenly spaced on the circumference of a circle.
These points are numbered 1 to 2N in clockwise order, starting from some of them.

Snuke will divide these points into N pairs, then for each pair, he will draw a line segment connecting the two points.
After the line segments are drawn, two points are connected when one can reach from one of those points to the other by traveling only on the line segments.
The number of the connected parts here is the number of the connected components in the graph with 2N vertices, corresponding to the 2N points, where every pair of vertices corresponding to two connected points is connected with an edge.

Snuke has already decided K of the pairs, and the i-th of them is a pair of Point A_i and Point B_i.

He is thinking of trying all possible ways to make the remaining N-K pairs and counting the number of the connected parts for each of those ways.
Find the sum of those numbers of the connected parts.
As the answer can be extremely large, compute the sum modulo 10^9+7.

Constraints

1 \leq N \leq 300

0 \leq K \leq N

1 \leq A_i,B_i \leq 2N

A_1,\ A_2,\ ...\ A_K,\ B_1,\ B_2,\ ...\ B_K are all distinct.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K
A_1 B_1
A_2 B_2
:
A_K B_K

Output

Print the sum of the numbers of the connected parts for all possible ways to make the remaining N-K pairs.

Sample Input 1

2 0

Sample Output 1

5

There are three ways to draw line segments, as shown below, and the number of the connected parts for these ways are 2, 2 and 1, respectively.
Thus, the answer is 2+2+1=5.

Sample Input 2

4 2
5 2
6 1

Sample Output 2

6

Sample Input 3

20 10
10 18
11 17
14 7
4 6
30 28
19 24
29 22
25 32
38 34
36 39

Sample Output 3

27087418

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
using Debug = System.Diagnostics.Trace;
using SB = System.Text.StringBuilder;
using System.Numerics;
using static System.Math;
using Number = System.Int64;
namespace Program {
	public class Solver {
		Random rnd = new Random();
		public void Solve() {
			var n = ri * 2; var k = ri;
			var a = Enumerate(k, x => new int[] { ri - 1, ri - 1 });

			var dp = Enumerate(n, x => new ModInt[n]);
			var ep = Enumerate(n, x => new ModInt[n]);
			for (int i = 0; i < n; i++)
				for (int j = 0; j < n; j++)
					dp[i][j] = ep[i][j] = -1;
			ModInt[] f = new ModInt[n + 5];
			f[0] = 1;
			for (int i = 2; i <= n; i += 2)
				f[i] = f[i - 2] * (i - 1);
			Func<int, int, ModInt> efs = null;
			efs = (l, r) => {
				if (ep[l][r].num != -1) return ep[l][r];
				var cnt = 0;
				foreach (var v in a) {
					if (l <= v[0] && v[0] <= r) cnt++;
					if (l <= v[1] && v[1] <= r) cnt++;
					if (cnt % 2 == 1) return dp[l][r] = 0;
				}
				return ep[l][r] = f[r - l + 1 - cnt];
			};
			Func<int, int, ModInt> dfs = null;
			dfs = (l, r) => {
				if (dp[l][r].num != -1) return dp[l][r];
				var ret = efs(l, r);
				for (int i = l + 1; i < r; i += 2)
					ret = ret - dfs(l, i) * efs(i + 1, r);
				return dp[l][r] = ret;
			};
			ModInt ans = 0;
			for (int l = 0; l < n; l++)
				for (int r = l + 1; r < n; r++) {
					var add = dfs(l, r);
					if (add.num == 0) continue;
					var cnt = 0;
					foreach (var v in a) {
						if (l <= v[0] && v[0] <= r) cnt++;
						if (l <= v[1] && v[1] <= r) cnt++;
					}
					var rem = n - (r - l + 1);
					rem -= 2 * k - cnt;
					add *= f[rem];
					Debug.WriteLine($"{l + 1} {r + 1} {add}");
					ans += add;
				}
			Console.WriteLine(ans);
		}

		const long INF = 1L << 60;
		static int[] dx = { -1, 0, 1, 0 };
		static int[] dy = { 0, 1, 0, -1 };
		int ri { get { return sc.Integer(); } }
		long rl { get { return sc.Long(); } }
		double rd { get { return sc.Double(); } }
		string rs { get { return sc.Scan(); } }
		public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());

		static T[] Enumerate<T>(int n, Func<int, T> f) {
			var a = new T[n];
			for (int i = 0; i < n; ++i) a[i] = f(i);
			return a;
		}
		static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
	}
}

#region main
static class Ex {
	static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
	static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
		return string.Join(st, ie);
	}
	static public void Main() {
		//Console.SetOut(new Program.IO.Printer(Console.OpenStandardOutput()) { AutoFlush = false });
		var solver = new Program.Solver();
		solver.Solve();
		Console.Out.Flush();
	}
}
#endregion
#region Ex
namespace Program.IO {
	using System.IO;
	using System.Text;
	using System.Globalization;

	public class Printer : StreamWriter {
		public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
		public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
	}

	public class StreamScanner {
		public StreamScanner(Stream stream) { str = stream; }

		public readonly Stream str;
		private readonly byte[] buf = new byte[1024];
		private int len, ptr;
		public bool isEof = false;
		public bool IsEndOfStream { get { return isEof; } }

		private byte read() {
			if (isEof) return 0;
			if (ptr >= len) {
				ptr = 0;
				if ((len = str.Read(buf, 0, 1024)) <= 0) {
					isEof = true;
					return 0;
				}
			}
			return buf[ptr++];
		}

		public char Char() {
			byte b = 0;
			do b = read(); while ((b < 33 || 126 < b) && !isEof);
			return (char)b;
		}
		public string Scan() {
			var sb = new StringBuilder();
			for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
			return sb.ToString();
		}
		public string ScanLine() {
			var sb = new StringBuilder();
			for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
			return sb.ToString();
		}
		public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
		public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
		public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
	}
}

#endregion
#region ModInt
/// <summary>
/// [0,<see cref="Mod"/>) までの値を取るような数
/// </summary>
public struct ModInt {
	public const long Mod = (int)1e9 + 7;
	public long num;
	public ModInt(long n) { num = n; }
	public override string ToString() => num.ToString();
	public static ModInt operator +(ModInt l, ModInt r) => new ModInt(l.num + r.num < Mod ? l.num + r.num : l.num + r.num - Mod);
	public static ModInt operator -(ModInt l, ModInt r) => new ModInt(l.num + Mod - r.num < Mod ? l.num + Mod - r.num : l.num - r.num);
	public static ModInt operator *(ModInt l, ModInt r) => new ModInt(l.num * r.num % Mod);
	public static ModInt operator /(ModInt l, ModInt r) => l * Inverse(r);
	public static implicit operator ModInt(long n) => new ModInt(n);
	public static ModInt Pow(ModInt v, long k) { return Pow(v.num, k); }
	public static ModInt Pow(long v, long k) {
		long ret = 1;
		for (k %= Mod - 1; k > 0; k >>= 1, v = v * v % Mod)
			if ((k & 1) == 1) ret = ret * v % Mod;
		return new ModInt(ret);
	}
	public static ModInt Inverse(ModInt v) { return Pow(v, Mod - 2); }
	public static ModInt Modulo(long v) => new ModInt(((v % Mod) + Mod) % Mod);
}
#endregion