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: # import time
  N, M = map(int, input().split())
  
  # 動くことのできる経路とその逆向きの移動をリストにし、それをリストにしたもの
  lst = []
  for i in range(M):
      a = list(map(int, input().split()))
      lst += [a] + [a[::-1]]
  
  
  def next_permutation(L):  # リストを順列で並び替える部分
      i = N - 2
      while i >= 0 and L[i] > L[i + 1]:
          i -= 1
  
      if i == -1:
          return False
  
      j = i + 1
      while j < N and L[i] < L[j]:
          j += 1
      j -= 1
  
      L[i], L[j] = L[j], L[i]
  
      left = i + 1
      right = N - 1
  
      while left < right:
          L[left], L[right] = L[right], L[left]
          left += 1
          right -= 1
  
      return True
  
  
  # 1-->Nまでの整数が順に並んでいるリスト、このリストの順番にたどるとする
  L = [i + 1 for i in range(N)]
  # print ('作成したL', L)
  
  
  def judge(
      L,
  ):  # ある経路Lが与えられたときに、その移動がリスト内の移動法で可能かどうかを判定、可能-->True 不可-->Falseを返す
      for i in range(N - 1):
          if not L[i : i + 2] in lst:
              #            print ('L[i:i+2]=', L[i:i+2])
              return False
      return True
  
  
  def roop(L):  # 全判定する部分
      count = 0
      while True:
          # 順路が条件を満たすか判定する部分
          #        print ('ループ内L', L)
          #        time.sleep(3)
          if (
              L[0] != 1
          ):  # 並び替えた後に最初が1ではない-->パスが1から始まらず条件を満たさない
              print(count)
              break
          if judge(L):
              count += 1
          if not next_permutation(L):
              print(count)
              break
      return "error"
  
  
  # print ('lst = ',lst)
  roop(L)
  
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."}]