/*

     Name:NYOJ-1278-Prototypes analyze

     Copyright:

     Author:

     Date: 2018/4/14 19:19:03

     Description:

     二叉排序树模板

 */

 #include<cstdio>

 #include<iostream>

 using namespace std;

 /*模板---------------------------------------------------------------*/

 typedef int ElemType;//定义ElemType的类型，可自己更改

 template<typename T>

 int getArrayLength(T &array) {

     return (sizeof(array) / sizeof(array[]));

 }

 //设计数据结构，构造二叉树

 typedef struct node {

     ElemType data;

     struct node *lchild, *rchild;

 }*BST;

 //插入元素

 bool insertBST(BST &T, ElemType element) {

     if (T==NULL)

     {

         T = new node;

         T->data = element;

         T->lchild = T->rchild = NULL;

         return true;

     }

     if (T->data==element)   //元素的值不能和树中已有的值相等

     {

         return false;

     }

     if (element<T->data)

     {

         insertBST(T->lchild,element);

     }

     else

     {

         insertBST(T->rchild,element);

     }

 }

 //创建二叉排序树

 void createBST(BST &T,ElemType array[],int len){   //Debug模式下，未初始化的栈内存上的指针全部填成0xcccccccc;

     T = NULL;

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

     {

         insertBST(T,array[i]);

     }

 }

 //访问，可改为数组保存

 void visit(ElemType elem) {

     cout << elem << "  ";

 }

 //中序遍历

 void preOrderTraverse(BST &T) {

     if (T!=NULL)

     {

         preOrderTraverse(T->lchild);

         visit(T->data);

         preOrderTraverse(T->rchild);

     }

 }

 //释放内存

 void relese(BST &T) {

     if (T==NULL)

     {

         return;

     }

     relese(T->lchild);

     relese(T->rchild);

     delete T;

 }

 //删除某个结点

 bool deleteNode(BST &T, ElemType element) {

     if (T==NULL)

     {

         return false;

     }

     BST p,q,s,parent;

     p = T;

     while (p!=NULL)

     {

         if (p->data == element)  break;

         parent = p;

         p = (p->data < element) ? p->rchild: p->lchild;

     }

     if (p==NULL)

     {

 //        cout << "该二叉排序树中无您要删除的值！"<<endl;

         return false;

     }

     if ((p->lchild==NULL)&&(p->rchild==NULL))

     {

         //重置其父亲结点的左右子孩子

         if (parent->lchild != NULL&&parent->lchild->data==element)

         {

             parent->lchild = NULL;

         }

         if (parent->rchild!=NULL&&parent->rchild->data==element)

         {

             parent->rchild = NULL;

         }

         return true;

     }

     else if (p->lchild!=NULL&&p->rchild==NULL)

     {

         //要让p的左孩子接上

         s=p->lchild;

         p ->data= s->data;

         p->lchild = s->lchild;

         delete s;

         return true;

     }

     else if (p->lchild==NULL&&p->rchild!=NULL)

     {

         //要让p的右孩子接上

         s = p->rchild;

         p->data = s->data;

         p->rchild = s->rchild;

         delete s;

         return true;

     }

     else

     {

         q = p;

         s = p->lchild;

         while (s->rchild!=NULL)

         {

             q = s;

             s = s->rchild;

         }

         p->data = s->data;

         if (q!=p)

         {

             q->rchild = s->lchild;

         }

         else

         {

             q->lchild = s->lchild;

         }

         delete s;

         return true;

     }

 }

 /*模板-------------------------------------------------------------结束*/

 int flag;

 void judge(BST T1,BST T2)  //判断形状；

 {

     if(T1==NULL&&T2==NULL)

         return;

     else if(T1&&T2)

     {

         judge(T1->lchild,T2->lchild);

         judge(T1->rchild,T2->rchild);

     }

     else

         flag=;

 }

 int main()

 {

     int t,n,k,x;

     BST tree[];

     scanf("%d",&t);

     while(t--)

     {

         scanf("%d%d",&n,&k);

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

         {

             BST T=NULL;

             for(int j=; j<k; j++)  //建树；

             {

                 scanf("%d",&x);

                 insertBST(T,x);

             }

             tree[i]=T;

         }

         //找形状种类数；

         int ans=;

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

         {

             int flog=;

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

             {

                 flag=;

                 judge(tree[i],tree[j]);

                 if(flag)

                 {

                     flog=;

                     break;

                 }

             }

             if(flog)

                 ++ans;

         }

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

     }

     return ;

 }