#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(const char *s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
void orange_(const char *s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  for (int f = 0; L != R; ++f)
    cerr << (f ? ", " : "") << *L++;
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define orange(...) safe
#define debug(...) safe
#endif

namespace {

constexpr int N = 8;
constexpr int M = N * (N - 1) / 2;

using i64 = int64_t;
using i128 = __int128;

i128 gcd(i128 x, i128 y) {
  if (y == 0)
    return x;
  return gcd(y, x % y);
}

struct F {
  i64 a, b;
  F() : a(0), b(1) {}
  F(i64 a_, i64 b_ = 1) : a(a_), b(b_) {}
  F operator*(const F &rhs) const {
    i128 up = i128(a) * rhs.a;
    i128 dn = i128(b) * rhs.b;
    i128 g = gcd(up, dn);
    return F(i64(up / g), i64(dn / g));
  }
  F operator/(const F &rhs) const {
    return *this * F(rhs.b, rhs.a);
  }
  F operator-() const {
    return F(-a, b);
  }
  F operator+(const F &rhs) const {
    i128 up = i128(a) * rhs.b + i128(rhs.a) * b;
    i128 dn = i128(b) * rhs.b;
    i128 g = gcd(up, dn);
    return F(i64(up / g), i64(dn / g));
  }
  F operator-(const F &rhs) const {
    return *this + (-rhs);
  }
  friend ostream &operator<<(ostream &os, const F &f) {
    return os << f.a << "/" << f.b;
  }
};

i64 comb[M + 1][M + 1];
void calcComb() {
  for (int i = 0; i <= M; ++i) {
    comb[i][0] = comb[i][i] = 1;
    for (int j = 1; j < i; ++j) {
      comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
    }
  }
}

F intl[M];

void calcIntl(int m) {
  for (int k = 0; k < m; ++k) {
    for (int i = 0; i <= m - k - 1; ++i) {
      bool neg = (m - k - 1 - i) & 1;
      i64 c = comb[m - k - 1][i];
      if (neg)
       c = -c; 
      intl[k] = intl[k] + F(c, (m - i + 1));
    }
  }
}

bool g[N][N];

i64 dp1[1 << N][M + 1], dp2[1 << N][M + 1];

void calcDP1(int n, int m) {
  const uint32_t n2 = 1u << n;
  dp1[0][0] = 1;
  for (uint32_t S = 1; S < n2; ++S) {
    const uint32_t p = countr_zero(S);
    const uint32_t cur = S ^ (1u << p);
    vector<pair<uint32_t, int>> v;
    auto dfs2 = [&](auto self, size_t i, int c, i64 w) {
      if (i == v.size()) {
        dp1[S][c] += w;
        return;
      }
      const int sz = int(popcount(v[i].first));
      for (int c1 = sz - 1; c1 <= m; ++c1) {
        if (dp1[v[i].first][c1] == 0)
          break;
        for (int c2 = 1; c2 <= v[i].second; ++c2)
          self(self, i + 1, c + c1 + c2, w * dp1[v[i].first][c1] * comb[v[i].second][c2]);
      }
    };
    auto dfs = [&](auto self, int i) {
      if (i == n) {
        dfs2(dfs2, 0, 0, 1);
        return;
      }
      if (((cur >> i) & 1) == 0) {
        self(self, i + 1);
        return;
      }
      v.emplace_back(1u << i, g[p][i]);
      self(self, i + 1);
      v.pop_back();
      for (auto &[vi, c] : v) {
        vi ^= 1u << i;
        c += g[p][i];
        self(self, i + 1);
        c -= g[p][i];
        vi ^= 1u << i;
      }
    };
    dfs(dfs, 0);
  }
}

F solve(int n, int m, int U, int V) {
  const uint32_t Suv = (1u << U) | (1u << V);
  const uint32_t n2 = 1u << n;
  for (uint32_t S = 0; S < n2; ++S)
    for (int i = 0; i <= m; ++i)
      dp2[S][i] = 0;
  dp2[0][0] = 1;
  for (uint32_t S1 = 0; S1 < n2; ++S1) {
    for (int i = 0; i <= m; ++i) {
      for (uint32_t S2 = 1; S2 < n2; ++S2) {
        if ((S1 & S2) != 0)
          continue;
        if (S1 != 0 and countr_zero(S1) < countr_zero(S2))
          continue;
        if ((S2 & Suv) == Suv)
          continue;
        for (int j = 0; i + j <= m; ++j) {
          dp2[S1 | S2][i + j] += dp2[S1][i] * dp1[S2][j];
        }
      }
    }
  }
  F ret = 0;
  for (int i = 0; i < m; ++i) {
    ret = ret + intl[i] * dp2[n2 - 1][i];
  }
  return ret;
}

} // namespace

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);

  calcComb();

  int n, m;
  cin >> n >> m;
  vector<pair<int, int>> e(m);
  for (auto &[u, v] : e) {
    cin >> u >> v;
    --u, --v;
    g[u][v] = g[v][u] = true;
  }
  calcIntl(m);
  calcDP1(n, m);
  F ans = 0;
  for (auto [u, v] : e)
    ans = ans + solve(n, m, u, v);
  cout << ans << '\n';
  return 0;
}