using System;
using System.Linq;

namespace AOJ
{
    class Program
    {

        static void Main(string[] args)
        {

            var read = Console.ReadLine();
            var dice_num = int.Parse(read);
            var dice_obj_arry = new dice[dice_num];
            bool math_found = false;

            for (var i = 0; i < dice_num; i++)
            {
                read = Console.ReadLine();
                dice_obj_arry[i] = new dice(read.Split());
            }

            for (var i = 0; i < dice_num; i++)
            {
                for (var j = i + 1; j < dice_num; j++)
                {
                    if (dice_obj_arry[i].dice_Comparison(dice_obj_arry[j].get_sueface()))
                    {
                        math_found = true;
                        break;
                    }

                }

                if (math_found)
                {
                    break;
                }
            }

            if (math_found)
            {
                Console.WriteLine("No");
            }
            else
            {
                Console.WriteLine("Yes");
            }

        }

    }

    //?????????????????????
    class dice
    {
        //?????????????????¨??¢
        int[] dice_surface = new int[6];
        int[] dice_surface_temp = new int[6];

        //??????????????????????????¨??¢??????????????£?????????
        public dice(string[] sueface_temp)
        {
            for (var i = 0; i < dice_surface.Length; i++)
            {
                dice_surface[i] = int.Parse(sueface_temp[i]);
            }
        }

        public int[] get_sueface()
        {
            return dice_surface;
        }

        //?????????????????¨?????\??¬????????????????????????
        public int dice_emulate(string order)
        {


            for (var i = 0; i < order.Length; i++)
            {
                switch (order.Substring(i, 1))
                {
                    case "N":
                        {
                            dice_vertical_rotation("up");
                            break;
                        }
                    case "S":
                        {
                            dice_vertical_rotation("down");
                            break;
                        }
                    case "E":
                        {
                            dice_horizone_rotation("right");
                            break;
                        }

                    case "W":
                        {
                            dice_horizone_rotation("left");
                            break;
                        }
                }

            }

            return dice_surface[0];
        }

        //???????????????2??¢?????????????????¨???????????¢???????????????????????????
        public int dice_direction(int up, int front)
        {
            int directio_up = 0, direction_front = 0;

            //???????????£?????????????????¢????????????
            for (var i = 0; i < dice_surface.Length; i++)
            {
                if (dice_surface[i] == up)
                {
                    directio_up = i + 1;
                }
            }

            for (var i = 0; i < dice_surface.Length; i++)
            {
                if (dice_surface[i] == front)
                {
                    direction_front = i + 1;
                }
            }

            //???????????¢??????????????????????????????????????????
            switch (directio_up)
            {
                case 1:
                    {
                        switch (direction_front)
                        {
                            case 2:
                                return dice_surface[2];

                            case 3:
                                return dice_surface[4];

                            case 4:
                                return dice_surface[1];

                            case 5:
                                return dice_surface[3];
                        }

                        break;
                    }
                case 2:
                    {
                        switch (direction_front)
                        {
                            case 1:
                                return dice_surface[3];

                            case 3:
                                return dice_surface[0];

                            case 4:
                                return dice_surface[5];

                            case 6:
                                return dice_surface[2];
                        }
                        break;
                    }
                case 3:
                    {
                        switch (direction_front)
                        {
                            case 1:
                                return dice_surface[1];

                            case 2:
                                return dice_surface[5];

                            case 5:
                                return dice_surface[0];

                            case 6:
                                return dice_surface[4];
                        }
                        break;
                    }

                case 4:
                    {
                        switch (direction_front)
                        {
                            case 1:
                                return dice_surface[4];

                            case 2:
                                return dice_surface[0];

                            case 5:
                                return dice_surface[5];

                            case 6:
                                return dice_surface[1];
                        }
                        break;
                    }
                case 5:
                    {
                        switch (direction_front)
                        {
                            case 1:
                                return dice_surface[2];

                            case 3:
                                return dice_surface[5];

                            case 4:
                                return dice_surface[0];

                            case 6:
                                return dice_surface[3];
                        }
                        break;
                    }
                case 6:
                    {
                        switch (direction_front)
                        {
                            case 2:
                                return dice_surface[3];

                            case 3:
                                return dice_surface[1];

                            case 4:
                                return dice_surface[4];

                            case 5:
                                return dice_surface[2];
                        }
                        break;
                    }
            }

            return 0;

        }

        //????????????????????¢?????????????????????
        void dice_horizone_rotation(string course)
        {
            dice_surface_temp[0] = dice_surface[0];
            dice_surface_temp[2] = dice_surface[2];
            dice_surface_temp[3] = dice_surface[3];
            dice_surface_temp[5] = dice_surface[5];

            switch (course)
            {
                case "right":
                    {
                        dice_surface[0] = dice_surface_temp[3];
                        dice_surface[2] = dice_surface_temp[0];
                        dice_surface[3] = dice_surface_temp[5];
                        dice_surface[5] = dice_surface_temp[2];
                        break;
                    }
                case "left":
                    {
                        dice_surface[3] = dice_surface_temp[0];
                        dice_surface[0] = dice_surface_temp[2];
                        dice_surface[5] = dice_surface_temp[3];
                        dice_surface[2] = dice_surface_temp[5];
                        break;
                    }
            }
        }
        void dice_vertical_rotation(string course)
        {
            dice_surface_temp[0] = dice_surface[0];
            dice_surface_temp[1] = dice_surface[1];
            dice_surface_temp[4] = dice_surface[4];
            dice_surface_temp[5] = dice_surface[5];

            switch (course)
            {
                case "up":
                    {


                        dice_surface[4] = dice_surface_temp[0];
                        dice_surface[0] = dice_surface_temp[1];
                        dice_surface[1] = dice_surface_temp[5];
                        dice_surface[5] = dice_surface_temp[4];
                        break;
                    }
                case "down":
                    {

                        dice_surface[0] = dice_surface_temp[4];
                        dice_surface[1] = dice_surface_temp[0];
                        dice_surface[5] = dice_surface_temp[1];
                        dice_surface[4] = dice_surface_temp[5];
                        break;
                    }
            }
        }
        void dice_z_axis_rotation(string coures)
        {
            dice_surface_temp[1] = dice_surface[1];
            dice_surface_temp[2] = dice_surface[2];
            dice_surface_temp[3] = dice_surface[3];
            dice_surface_temp[4] = dice_surface[4];
            switch (coures)
            {
                case "right":
                    {
                        dice_surface[1] = dice_surface_temp[2];
                        dice_surface[2] = dice_surface_temp[4];
                        dice_surface[3] = dice_surface_temp[1];
                        dice_surface[4] = dice_surface_temp[3];
                        break;
                    }
                case "left":
                    {
                        dice_surface[1] = dice_surface_temp[3];
                        dice_surface[2] = dice_surface_temp[1];
                        dice_surface[3] = dice_surface_temp[4];
                        dice_surface[4] = dice_surface_temp[2];
                        break;
                    }
            }
        }

        //???????????????????????????
        public bool dice_Comparison(int[] Specimen)
        {
            if (arry_Comparison(Specimen))
            {
                return true;
            }
            for (var j = 0; j < 4; j++)
            {
                dice_z_axis_rotation("left");
                if (arry_Comparison(Specimen))
                {
                    return true;
                }

            }
            for (var i = 0; i < 3; i++)
            {
                dice_horizone_rotation("left");
                for (var j = 0; j < 4; j++)
                {
                    dice_z_axis_rotation("left");
                    if (arry_Comparison(Specimen))
                    {
                        return true;
                    }

                }
            }
            dice_horizone_rotation("left");

            for (var i = 0; i < 3; i++)
            {
                dice_vertical_rotation("up");
                for (var j = 0; j < 4; j++)
                {
                    dice_z_axis_rotation("left");
                    if (arry_Comparison(Specimen))
                    {
                        return true;
                    }

                }
            }



            return false;
        }

        //?????????????????????
        bool arry_Comparison(int[] Specimen)
        {
            return dice_surface.SequenceEqual(Specimen);
        }


    }
}

Measured memory_bytes: 9868