using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AOJ
{
    class Program
    {
        class Dice
        {
            int[] xIndices = new int[4];
            int[] yIndices = new int[4];
            string[] numIndicesMap = new string[6];

            public Dice()
            {
                yIndices[0] = 0;
                yIndices[1] = 1;
                yIndices[2] = 5;
                yIndices[3] = 4;

                xIndices[0] = 0;
                xIndices[1] = 3;
                xIndices[2] = 5;
                xIndices[3] = 2;

                for (int i = 0; i < numIndicesMap.Length; ++i)
                {
                    numIndicesMap[i] = (i + 1).ToString();
                }
            }
            public void SetNumberIndecesMap(string[] map)
            {
                if (map.Length != 6)
                {
                    throw new Exception("invalid mapper");
                }
                numIndicesMap = map;
            }

            static void Swap(ref int lhs, ref int rhs)
            {
                var tmp = lhs;
                lhs = rhs;
                rhs = tmp;
            }
            static void Move(int direction, ref int[] indices)
            {
                if (direction > 0)
                {
                    for (int i = 1; i < indices.Length; ++i)
                    {
                        Swap(ref indices[i - 1], ref indices[i]);
                    }
                }
                if (direction < 0)
                {
                    for (int i = indices.Length - 1; i > 0; --i)
                    {
                        Swap(ref indices[i - 1], ref indices[i]);
                    }
                }
            }
            void MoveX(int direction)
            {
                Move(direction, ref xIndices);
                yIndices[0] = xIndices[0];
                yIndices[2] = xIndices[2];
            }
            void MoveY(int direction)
            {
                Move(direction, ref yIndices);
                xIndices[0] = yIndices[0];
                xIndices[2] = yIndices[2];
            }
            public void Move(char directionCharactor)
            {
                switch (directionCharactor)
                {
                    case 'N':
                        MoveY(1);
                        return;
                    case 'S':
                        MoveY(-1);
                        return;
                    case 'E':
                        MoveX(1);
                        return;
                    case 'W':
                        MoveX(-1);
                        return;
                    default:
                        throw new Exception("invalid input");
                }
            }
            public void MoveReverse(char directionCharactor)
            {
                switch (directionCharactor)
                {
                    case 'N':
                        MoveY(-1);
                        return;
                    case 'S':
                        MoveY(1);
                        return;
                    case 'E':
                        MoveX(-1);
                        return;
                    case 'W':
                        MoveX(1);
                        return;
                    default:
                        throw new Exception("invalid input");
                }
            }

            public string Top
            {
                get
                {
                    return numIndicesMap[xIndices[0]];
                }
            }
            public string Bottom
            {
                get
                {
                    return numIndicesMap[xIndices[2]];
                }
            }
            public string Right
            {
                get
                {
                    return numIndicesMap[xIndices[3]];
                }
            }
            public string Left
            {
                get
                {
                    return numIndicesMap[xIndices[1]];
                }
            }
            public string Front
            {
                get
                {
                    return numIndicesMap[yIndices[1]];
                }
            }
            public string Back
            {
                get
                {
                    return numIndicesMap[yIndices[3]];
                }
            }
        }

        class DiceComparetor
        {
            class Snap
            {
                public string[] faces = new string[6];

                public Snap(Dice dice)
                {
                    faces[0] = dice.Top;
                    faces[1] = dice.Bottom;
                    faces[2] = dice.Right;
                    faces[3] = dice.Left;
                    faces[4] = dice.Front;
                    faces[5] = dice.Back;
                }

                public override bool Equals(object obj)
                {
                    var rhs = obj as Snap;
                    if (rhs == null) return false;
                    for (int i = 0; i < faces.Length; ++i)
                    {
                        if (faces[i].Equals(rhs.faces[i]) == false)
                        {
                            return false;
                        }
                    }
                    return true;
                }
                public override int GetHashCode()
                {
                    int hash = 0;
                    foreach (var f in faces)
                    {
                        hash = f.GetHashCode();
                    }
                    return hash;
                }
            }

            char[] moves = new char[4] { 'N', 'S', 'E', 'W' };
            HashSet<Snap> traversedChecker = new HashSet<Snap>();
            int maxDepth = 0;   // デバッグ用
            int checkCount = 0; // デバッグ用

            public Dice dice;

            public void traverse(int depth)
            {
                maxDepth = Math.Max(maxDepth, depth);

                for (int i = 0; i < moves.Length; ++i)
                {
                    dice.Move(moves[i]);
                    var snap = new Snap(dice);
                    if (traversedChecker.Contains(snap))
                    {
                        continue;
                    }
                    traversedChecker.Add(snap);

                    ++checkCount;
                    traverse(depth + 1);

                    dice.MoveReverse(moves[i]);
                }
            }

            public bool isSame(Dice dice)
            {
                var snap = new Snap(dice);
                return traversedChecker.Contains(snap);
            }
        }
        static bool isSameDice(string[] indicesMapper0, string[] indicesMapper1)
        {
            var dice0 = new Dice();
            dice0.SetNumberIndecesMap(indicesMapper0);

            var dice1 = new Dice();
            dice1.SetNumberIndecesMap(indicesMapper1);

            var comparator = new DiceComparetor { dice = dice0 };
            comparator.traverse(0);
            return comparator.isSame(dice1);
        }
        static bool isAllDifferentDice(List<string[]> indicesMappers)
        {
            var dice0 = new Dice();
            dice0.SetNumberIndecesMap(indicesMappers.First());

            var comparator = new DiceComparetor { dice = dice0 };
            comparator.traverse(0);

            for (int i = 1; i < indicesMappers.Count; ++i)
            {
                var dice = new Dice();
                dice.SetNumberIndecesMap(indicesMappers[i]);
                if (comparator.isSame(dice))
                {
                    return false;
                }
            }

            return true;
        }

        static void Main(string[] args)
        {
            var count = int.Parse(Console.In.ReadLine());
            var indicesMappers = new List<string[]>();
            for (int i = 0; i < count; ++i)
            {
                indicesMappers.Add(Console.In.ReadLine().Split(' ').ToArray());
            }

            var result = "No";
            if (isAllDifferentDice(indicesMappers))
            {
                result = "Yes";
            }

            Console.Out.WriteLine(result);
        }
    }
}



Measured memory_bytes: 18660