import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.fill;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.sort;

public class Main {
	public static void main(String[] args) throws IOException {
//		try {
//			if (new File("input.txt").exists())
//				System.setIn(new FileInputStream("input.txt"));
//		} catch (SecurityException e) {}
		
//		long time1 = System.currentTimeMillis();
		new Main().run();
//		checkMemory();
//		long time2 = System.currentTimeMillis();
//		System.err.println((time2 - time1) + " ms");
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");
	
	int vNum;
	int eNum;
	boolean[][] g;
	
	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		vNum = nextInt();
		eNum = nextInt();
		g = new boolean [vNum][vNum];
		for (int e = 0; e < eNum; e++) {
			int u = nextInt() - 1;
			int v = nextInt() - 1;
			g[u][v] = g[v][u] = true;
		}
		
//		for (int v = 7; v <= 11; v++) {
//			genFullGraph(v);
//			if (naiveDP() != optimizedDP())
//				System.err.println("Error on " + v);
//		}
		
		out.println(optimizedDP());
		
		out.close();
	}
	
	/*************************************************************** 
	 * Test
	 **************************************************************/
	long naiveDP() {
		long[] count = new long [vNum + 1];
		int size = 1 << vNum;
		long[][] dp = new long [size][vNum];
		for (int begin = 0; begin < vNum; begin++) {
			for (long[] row : dp) fill(row, 0L);
			dp[1 << begin][begin] = 1L;
			for (int mask = 0; mask < size; mask++) {
				int len = Integer.bitCount(mask);
				for (int v = 0; v < vNum; v++) {
					long cval = dp[mask][v];
					if (cval == 0L) continue;
					if (g[v][begin]) count[len] += cval;
					for (int nv = 0; nv < vNum; nv++) {
						if (g[v][nv]) {
							int nmask = mask | (1 << nv);
							if (nmask != mask)
								dp[nmask][nv] +=... Which one is the correct time complexity of the code snippet: constant, linear, quadratic, cubic, log(n), nlog(n) or NP-hard?