#include <bits/stdc++.h>
#define mp make_pair
#define all(vec) vec.begin(), vec.end()
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF = (1LL << 30) - 1LL;
const ll LINF = (1LL << 60) - 1LL;
const double eps = 1e-9;
const ll MOD = 1000000007LL;
template <typename T>
void chmin(T& a, T b) {
    a = min(a, b);
};
template <typename T>
void chmax(T& a, T b) {
    a = max(a, b);
};
template <typename T>
vector<T> make_v(size_t a) {
    return vector<T>(a);
}
template <typename T, typename... Ts>
auto make_v(size_t a, Ts... ts) {
    return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T& t, const V& v) {
    t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T& t, const V& v) {
    for(auto& e : t) {
        fill_v(e, v);
    }
};
template <ll mod>
struct modint {
    ll val;
    inline ll extgcd(ll a, ll b, ll& x, ll& y) {
        if(b == 0) {
            x = 1, y = 0;
            return a;
        }
        ll d = extgcd(b, a % b, y, x);
        y -= a / b * x;
    }
    inline ll minv(ll k) {
        ll x = 0, y = 0;
        extgcd(k, mod, x, y);
        if(x < 0) {
            x += mod;
        } else if(x == mod) {
            x = 0;
        }
        return x;
    }
    inline ll mpow(ll n) {
        ll res = 1, x = val;
        while(n > 0) {
            if(n & 1) {
                res *= x;
                res % mod;
            }
            x = x * x % mod;
            n >>= 1;
        }
        return res;
    }
    constexpr modint() : val(0) {}
    constexpr modint(ll x) { val = (x + mod) % mod; }
    modint inv() { return modint(minv(val)); }
    modint operator+(const modint& to) const { return modint(val + to.val); }
    modint operator-(const modint& to) const { return modint(val - to.val); }
    modint operator*(const modint& to) const { return modint(val * to.val); }
    modint operator/(const modint& to) const {
        return modint(val * minv(to.val));
    }
    template <class T>
    explicit operator T() {
        return T(val);
    }
    template <typename T>
    modint operator+(const T& to) const {
        return modint(val + to);
    }
    template <typename T>
    modint operator-(const T& to) const {
        return modint(val - to);
    }
    template <typename T>
    modint operator*(const T& to) const {
        return modint(val * to);
    }
    template <typename T>
    modint operator/(const T& to) const {
        return modint(val * minv(to));
    }
    modint& operator++() { return *this = modint(val + 1); }
    modint& operator--() { return *this = modint(val - 1); }
    template <typename T>
    modint& operator+=(const T& to) {
        return *this = *this + to;
    }
    template <typename T>
    modint& operator-=(const T& to) {
        return *this = *this - to;
    }
    template <typename T>
    modint& operator*=(const T& to) {
        return *this = *this * to;
    }
    template <typename T>
    modint& operator/=(const T& to) {
        return *this = *this / to;
    }
    bool operator==(const modint& to) const { return val == to.val; }
    bool operator!=(const modint& to) const { return val != to.val; }
    bool operator>(const modint& to) const { return val > to.val; }
    bool operator>=(const modint& to) const { return val >= to.val; }
    bool operator<(const modint& to) const { return val < to.val; }
    bool operator<=(const modint& to) const { return val <= to.val; }
};
using mint = modint<MOD>;
int main() {
    int n, m;
    cin >> n >> m;
    auto dp = make_v<mint>(2 * n + 10, 2 * n + 10);
    auto co = make_v<ll>(2 * n + 10, 2 * n + 10);
    auto s = make_v<mint>(2 * n + 10, 2 * n + 10);
    vector<mint> f(2 * n + 10);
    f[0] = 1;
    for(ll i = 2; i <= 2 * n; i++) {
        f[i] = f[i - 2] * (i - 1LL);
    }
    vector<int> to(2 * n + 10, -1);
    for(int i = 0; i < m; i++) {
        int a, b;
        cin >> a >> b;
        to[a] = b;
        to[b] = a;
    }
    for(int i = 1; i <= 2 * n; i++) {
        for(int j = i + 1; j <= 2 * n; j++) {
            for(int k = i; k <= j; k++) {
                if(to[k] == -1) {
                    co[i][j]++;
                }
            }
            s[i][j] = f[co[i][j]];
        }
    }
    mint ans = 0;
    for(int l = 1; l <= 2 * n; l++) {
        for(int i = 1; i <= 2 * n - l; i++) {
            int j = i + l;
            if(co[i][j] % 2) {
                dp[i][j] = 0;
                continue;
            }
            bool br = false;
            dp[i][j] = s[i][j];
            for(int k = i; k <= j; k++) {
                if(to[k] != -1 && (j < to[k] || to[k] < i)) {
                    br = true;
                }
                if(i < k && k < j) {
                    dp[i][j] -= dp[i][k] * s[k + 1][j];
                }
            }
            if(br) {
                dp[i][j] = 0;
                continue;
            }
            ans += dp[i][j] * f[2 * (n - m) - co[i][j]];
        }
    }
    cout << ans.val << endl;
}


Measured memory_bytes: 9088