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

namespace ITP1_11_C
{
    class Dice
    {
        public Dice()
        {
            Top = 0;
            Front = 1;
            Right = 2;
        }

        public void RotateNorth()
        {
            var temp = Inverse(Top);
            Top = Front;
            Front = temp;
        }


        public void RotateSouth()
        {
            var temp = Inverse(Front);
            Front = Top;
            Top = temp;
        }


        public void RotateEast()
        {
            var temp = Inverse(Right);
            Right = Top;
            Top = temp;
        }


        public void RotateWest()
        {
            var temp = Inverse(Top);
            Top = Right;
            Right = temp;
        }


        public enum Surface { TOP, BOTTOM, FRONT, BACK, RIGHT, LEFT, NONE }

        public Surface Match(int surface)
        {
            if (surface == Top) return Surface.TOP;
            if (surface == Bottom) return Surface.BOTTOM;
            if (surface == Front) return Surface.FRONT;
            if (surface == Back) return Surface.BACK;
            if (surface == Right) return Surface.RIGHT;
            if (surface == Left) return Surface.LEFT;

            return Surface.NONE;
        }


        public bool RotateToTop(int top)
        {
            switch (Match(top))
            {
                case Surface.TOP: break;
                case Surface.BOTTOM: RotateNorth(); RotateNorth(); break;
                case Surface.FRONT: RotateNorth(); break;
                case Surface.BACK: RotateSouth(); break;
                case Surface.RIGHT: RotateWest(); break;
                case Surface.LEFT: RotateEast(); break;
            }

            return Top == top;
        }


        public bool RotateToTopAndFront(int top, int front)
        {
            if (RotateToTop(top) == false)
            {
                return false;
            }

            switch (Match(front))
            {
                case Surface.RIGHT: RotateRightOfZCoords(); break;
                case Surface.BACK: RotateRightOfZCoords(); RotateRightOfZCoords(); break;
                case Surface.LEFT: RotateLeftOfZCoords();  break;
            }

            return Top == top && Front == front;
        }


        public void RotateRightOfZCoords()
        {
            var temp = Back;
            Front = Right;
            Right = temp;
        }


        public void RotateLeftOfZCoords()
        {
            var temp = Left;
            Right = Front;
            Front = temp;
        }



        public int RightOf(int front)
        {
            switch (Match(front))
            {
                case Surface.FRONT: return Right;
                case Surface.RIGHT: return Back;
                case Surface.BACK: return Left;
                case Surface.LEFT: return Front;
            }
            return -1;
        }


        public int Top { get; private set; }


        public int Front { get; private set; }


        public int Right { get; private set; }


        public int Bottom { get { return Inverse(Top); } }


        public int Back { get { return Inverse(Front); } }


        public int Left { get { return Inverse(Right); } }



        public int Inverse(int surface)
        {
            return 5 - surface;
        }


        public IEnumerable<int> Surfaces()
        {
            yield return Top;
            yield return Front;
            yield return Right;
            yield return Left;
            yield return Back;
            yield return Bottom;
        }


        public static bool EqualsAliasOfNoDuplication(string[] alias1, string[] alias2)
        {
            var dice1 = new Dice();
            var dice2 = new Dice();

            var top = -1;
            var front = -1;
            for (var i = 0; i < alias1.Length; ++i)
            {
                if (alias1[0] == alias2[i])
                {
                    top = i;
                }
                if (alias1[1] == alias2[i])
                {
                    front = i;
                }
            }

            if (dice2.RotateToTopAndFront(top, front) == false)
            {
                return false;
            }

            var orderedAlias1 = dice1.Surfaces().Select(n => alias1[n]);
            var orderedAlias2 = dice2.Surfaces().Select(n => alias2[n]);
            return Enumerable.SequenceEqual(orderedAlias1, orderedAlias2);
        }


        public static bool EqualsAliasOfDiceHasDuplication(string[] alias1, string[] alias2)
        {
            var dice1 = new Dice();
            var dice2 = new Dice();

            var orderedAlias1 = dice1.Surfaces().Select(n => alias1[n]);
            var orderedAlias2 = dice2.Surfaces().Select(n => alias2[n]);

            for (var i = 0; i < 6; ++i)
            {
                dice2.RotateToTop(i);
                if (Enumerable.SequenceEqual(orderedAlias1, orderedAlias2)) return true;

                dice2.RotateLeftOfZCoords();
                if (Enumerable.SequenceEqual(orderedAlias1, orderedAlias2)) return true;

                dice2.RotateLeftOfZCoords();
                if (Enumerable.SequenceEqual(orderedAlias1, orderedAlias2)) return true;

                dice2.RotateLeftOfZCoords();
                if (Enumerable.SequenceEqual(orderedAlias1, orderedAlias2)) return true;
            }

            return false;
        }
    }



    class Program
    {
        static void Main(string[] args)
        {
            var a1 = Console.ReadLine().Split(' ');
            var a2 = Console.ReadLine().Split(' ');

            if (a1.Length != a2.Length)
            {
                return;
            }

            Func<string[], string[], bool> isSameDice = Dice.EqualsAliasOfNoDuplication;
            for (var i = 0; i < a1.Length; ++i)
            {
                if (1 < a1.Count(_ => _ == a1[i]) || 1 < a2.Count(_ => _ == a2[i]))
                {
                    isSameDice = Dice.EqualsAliasOfDiceHasDuplication;
                    break;
                }
            }

            Console.WriteLine(isSameDice(a1, a2) ? "Yes" : "No");
        }
    }
}

Measured memory_bytes: 19980