#include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<string>

 #include<algorithm>

 #include<cmath>

 #include<queue>

 using namespace std;

 const int maxn=;

 const int maxm=1e3+;

 int n,m,s;

 int deg[maxn];

 int mp[maxn][maxn];

 int Stack[maxn];

 int ans;

 struct Edge

 {

     int to;

     int next;

 }edge[maxm];

 int tot,head[maxn];

 void add(int u,int v)

 {

     edge[tot].to=v;

     edge[tot].next=head[u];

     head[u]=tot++;

  }

 void Init()

 {

     ans=;

     tot=;

     memset(head,-,sizeof(head));

     memset(deg,,sizeof(deg));

     memset(mp,,sizeof(mp));

     memset(Stack,,sizeof(Stack));

 }

 bool judge(int a[],int v)

 {

     for(int i=;i<=a[];i++)

     {

         if(!mp[v][a[i]])

         {

             return false;

         }

     }

     return true;

 }

 void DFS(int a[],int u)

 {

     if(a[]==s)

     {

         ans++;

         return;

     }

     for(int i=head[u];i!=-;i=edge[i].next)

     {

         int v=edge[i].to;

         //判断这个点是不是和每个已有团结点都有边

         if(judge(a,v))

         {

             //入栈

             a[++a[]]=v;

             DFS(a,v);

             a[]--;

         }

     }

 }

 int main()

 {

     int T;

     scanf("%d",&T);

     while(T--)

     {

         Init();

         scanf("%d%d%d",&n,&m,&s);

         int u,v;

         for(int i=;i<m;i++)

         {

             scanf("%d%d",&u,&v);

             //这是去重的关键

             /*用一个数组记录已经存在的团的大小，数组是一个由小到大

 的数组，即前点要进入团时，判断该节点是否比团内所有点大，这样就避免了重复，判断大小时只需要判断进最后一个点是否比当前点小就行了

 所以建图是可以按照 小的点指向大的点得方式建图，这样会少很多不必要的搜索操作 */

             /*之所以可以从小的节点指向大的节点是因为，最后要找的是一个无向完全图，在无向完全图中肯定可以找到一条从小节点依次走到到大节点的有向路：比如1->2->3这样的路，边的双向信息用另一个数组存一下就行了

 这样就减少了大量不必要的计算，而且不会重复，因为你在一个无向完全图里只可能找到一个，v1 < v2 < v3 ... < vx

 这样的偏序关系的路，不可能再出现例如v2 < v1 < v3 < ... < vx这种路，因为这么多点大小的偏序关系是唯一的，确定了一次，以后都不会重复了，连标记去重都不用，真巧妙！*/

             if(u>v)

             {

                 swap(u,v);

             }

             add(u,v);

             mp[u][v]=mp[v][u]=;

             //为了剪枝

             deg[u]++;

             deg[v]++;

         }

         for(int i=;i<=n;i++)

         {

             //剪枝，度小于s-1的一定不在团内

             if(deg[i]<s-)

             {

                 continue;

             }

             //模拟栈，Stack[0]保存已经确定的团结点的大小

             Stack[]=;

             Stack[]=i;

             DFS(Stack,i);

         }

         printf("%d\n",ans);

     }

     return ;

 }