/*
   poj  3349     
   哈希算法  
   用G++编译提交通过，但用C++编译提交时会超时
*/

#include<iostream>
#include <algorithm>
#include <cstdio>

const long maxn=100000;
const long mtemp=100000;

/*
每片雪花的具体长度，并且是一个链表
*/
typedef struct node 
{
    long data[6];
    node *next;
}node;

/*
   存放雪花的初始地址
 */
 typedef struct hnode
 {
     int elCount;
     node *head;
 }HeadNode;

/*
      全局变量
 */
HeadNode *snows=new HeadNode[maxn];

/*
比较两片雪花是否相等
*/
bool CompareArray( long *d1, long *d2,const long len)
{
    int i,j,count,t;
    bool flag=false;
    count=0;

/*
    从数组的头开始判断两个数组是否相等，即两片雪花是否相等
    依次以d1数组的第 i（0<=i>=5)个元素作为头依次和d2数组的元素作比较，
    只有各个元素都相等时才证明两片雪花相等。
   */
    while(count<len)
    {
        i=count;
    
        for(j=0;j<len;j++)
        {
            if(d1[i]==d2[j])
            {
                i++;
                if(i>=len)i=0;
            }else
            {
                break;
            }
        }

if(j>=len)
        {
            flag=true;
            
        }
        
        if(flag==true)break;

count++;
    }
     /*
         从数组的末尾开始判断两个数组是否相等
     */
    if(flag==false)
    {
        count=len-1;
        while(count>=0)
        {
            i=count;
            for(j=0;j<len;j++)
            {
                if(d1[i]==d2[j])
                {
                    i--;
                    if(i<0)i=len-1;
                }else
                {
                    break;
                }
            }
            if(j>=len)
            {
                flag=true;
                
            }
            if(flag==true)break;

count--;
        }
    }
        
    return flag;

}
int main(void)
{
    long n,c,k,key,index;
    int i,j;
    long *a;
    bool isHasSameSnowFlake;
    node *t,*headtemp;
    std::cin>>n;
    c=getchar();

isHasSameSnowFlake=false;

for(i=0;i<n;i++)
    {
        //a=new long[6];
        t=new node();
        t->next=NULL;
        key=0;
        for(j=0;j<6;j++)
        {   
            k=0;
            c='0';
            
            while(c!='\n'&&c!=' ')
            {
              k=k*10+c-'0'; 
              c=getchar();
            }

t->data[j]=k;
            key+=k;

}
       
        //qsort(a,6,sizeof(long),Compare);
        
        if(isHasSameSnowFlake==false)
        {

index=key%mtemp;  //取当前输入的雪花的hash值，通过求6个角的长度的和，然后对mtemp相除取余数，即为其hash值

if(snows[index].elCount>0)   //判断已经输入的雪花中是否已经存在拥有相同hash值的雪花
            {
                headtemp=snows[index].head->next;
                while(headtemp!=NULL)
                {  //判断拥有相同hash值的雪花是否是两片相同的雪花
                    isHasSameSnowFlake=CompareArray(headtemp->data,t->data,6);
                    if(isHasSameSnowFlake==true) break;
                    headtemp=headtemp->next;
                }

if(isHasSameSnowFlake==false)
                {
                    t->next=snows[index].head->next;
                    snows[index].head->next=t;
                    snows[index].elCount++;
                }
        
                    /*t->next=snows[index].head->next;
                    snows[index].head->next=t;*/

}else 
            {   
                snows[index].elCount++;
                snows[index].head=new node();
                snows[index].head->next=t;
            }

}

}

if(isHasSameSnowFlake==false){

std::cout<<"No two snowflakes are alike."<<std::endl;
    }else{

std::cout<<"Twin snowflakes found."<<std::endl;
    }

return 0;

}