output_description: Print the number of the different paths that start from vertex 1 and visit all
  the vertices exactly once.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N M  
      a_1 b_1  
      a_2 b_2
      :  
      a_M b_M
attempt: def examA():
      O = SI()
      E = SI()
      ans = ""
      for i in range(len(O) + len(E)):
          if i % 2 == 0:
              ans += O[i // 2]
          else:
              ans += E[i // 2]
      print(ans)
      return
  
  
  def examB():
      A = LI()
      A.sort()
      ans = (A[2] - A[0]) // 2 + (A[2] - A[1]) // 2
      if (A[2] - A[0]) % 2 == 1:
          ans += 1
          if (A[2] - A[1]) % 2 == 0:
              ans += 1
      elif (A[2] - A[1]) % 2 == 1:
          ans += 2
      print(ans)
      return
  
  
  def examC():
      S = SI()
      S.replace("RL", "A")
      S.replace("LR", "B")
      N = len(S)
      A = [0] * N
      print(S)
      l = 0
      r = 0
      for i, s in enumerate(S):
          if s == "A":
              A[i] += r
          elif s == "B":
              A[i] += l
      ans = 0
      print(ans)
      return
  
  
  def examD():
      def warshall_floyd(n, d):
          # d[i][j]: iからjへの最短距離
          for k in range(n):
              for i in range(n):
                  for j in range(n):
                      d[i][j] = min(d[i][j], d[i][k] + d[k][j])
          return d
  
      H, W = LI()
      C = [LI() for _ in range(10)]
      A = [LI() for _ in range(H)]
      C = warshall_floyd(10, C)
      ans = 0
      for i in range(H):
          for j in range(W):
              a = A[i][j]
              if a == -1:
                  continue
              ans += C[a][1]
      print(ans)
      return
  
  
  def examE():
      N, M = LI()
      V = [[] for _ in range(N)]
      for _ in range(M):
          a, b = LI()
          a -= 1
          b -= 1
          V[a].append(b)
          V[b].append(a)
  
      def dfs(s, visited):
          # print(s,visited)
          res = 0
          visited.add(s)
          if len(visited) == N:
              visited.remove(s)
              return 1
          for ne in V[s]:
              if ne in visited:
                  continue
              res += dfs(ne, visited)
          visited.remove(s)
          return res
  
      visited = set()
      ans = dfs(0, visited)
      # print(visited)
      print(ans)
      return
  
  
  def examF():
      ans = 0
      print(ans)
      return
  
  
  import sys, bisect, itertools, heapq, math, random
  from copy import deepcopy
  from heapq import heappop, heappush, heapify
  from collections import Counter, defaultdict, deque
  
  
  def I():
      return int(sys.stdin.readline())
  
  
  def LI():
      return list(map(int, sys.stdin.readline().split()))
  
  
  def LSI():
      return list(map(str, sys.stdin.readline().split()))
  
  
  def LS():
      return sys.stdin.readline().split()
  
  
  def SI():
      return sys.stdin.readline().strip()
  
  
  global mod, mod2, inf, alphabet, _ep
  mod = 10**9 + 7
  mod2 = 998244353
  inf = 10**18
  _ep = 10 ** (-12)
  alphabet = [chr(ord("a") + i) for i in range(26)]
  
  sys.setrecursionlimit(10**6)
  
  if __name__ == "__main__":
      examE()
  
  """
  
  """
  
problem_description: Statement
  
  You are given an undirected unweighted graph with N vertices and M edges that
  contains neither self-loops nor double edges.  
  Here, a _self-loop_ is an edge where a_i = b_i (1≤i≤M), and _double edges_ are
  two edges where (a_i,b_i)=(a_j,b_j) or (a_i,b_i)=(b_j,a_j) (1≤i<j≤M).  
  How many different paths start from vertex 1 and visit all the vertices
  exactly once?  
  Here, the endpoints of a path are considered visited.
  
  For example, let us assume that the following undirected graph shown in Figure
  1 is given.
  
  ![](https://atcoder.jp/img/5013/888b2f55d46f66125a4ac25cd8cfc19a.png)
  
  Figure 1: an example of an undirected graph
  
  The following path shown in Figure 2 satisfies the condition.
  
  ![](https://atcoder.jp/img/5013/694eda4639f3f4608c9f0b38af1633d3.png)
  
  Figure 2: an example of a path that satisfies the condition
  
  However, the following path shown in Figure 3 does not satisfy the condition,
  because it does not visit all the vertices.
  
  ![](https://atcoder.jp/img/5013/4739baf6665ab2832ea424b1cc404ee1.png)
  
  Figure 3: an example of a path that does not satisfy the condition
  
  Neither the following path shown in Figure 4, because it does not start from
  vertex 1.
  
  ![](https://atcoder.jp/img/5013/7ad401c30e069a98a34c8cfec70ec278.png)
  
  Figure 4: another example of a path that does not satisfy the condition
samples: [{"input": "3 3\n    1 2\n    1 3\n    2 3", "output": "2\n    \n\nThe given graph is shown in the following figure:\n\n![43c0ac53de20d989d100bf60b3cd05fa.png](https://atcoder.jp/img/5013/43c0ac53de20d989d100bf60b3cd05fa.png)\n\nThe following two paths satisfy the condition:\n\n![c4a27b591d364fa479314e3261b85071.png](https://atcoder.jp/img/5013/c4a27b591d364fa479314e3261b85071.png)\n\n* * *"}, {"input": "7 7\n    1 3\n    2 7\n    3 4\n    4 5\n    4 6\n    5 6\n    6 7", "output": "1\n    \n\nThis test case is the same as the one described in the problem statement."}]