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(ref 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 Traverser
        {
            // さいころの場合、三面が固定されないと同一と判定できない
            struct Snap
            {
                public string top;
                public string front;
                public string right;

                public override bool Equals(object obj)
                {
                    var rhs = obj as Snap?;
                    if (rhs == null) return false;
                    if (top.Equals(rhs.Value.top) == false) return false;
                    if (front.Equals(rhs.Value.front) == false) return false;
                    if (right.Equals(rhs.Value.right) == false) return false;
                    return true;
                }
                public override int GetHashCode()
                {
                    return top.GetHashCode() + front.GetHashCode() + right.GetHashCode();
                }
            }

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

            public string firstTop;
            public string top;
            public string front;
            public Dice dice;

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

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

                    ++checkCount;
                    if (dice.Top.Equals(top) && dice.Front.Equals(front))
                    {
                        return true;
                    }

                    var found = traverse(depth + 1);
                    if (found)
                    {
                        return true;
                    }

                    dice.MoveReverse(moves[i]);
                }

                return false;
            }
        }
        static bool getMachedDice(string top, string front, string[] indicesMapper, out Dice diceFound)
        {
            diceFound = null;

            var dice = new Dice();
            dice.SetNumberIndecesMap(ref indicesMapper);

            var traverser = new Traverser { dice = dice, firstTop = dice.Top, top = top, front = front };
            if (traverser.traverse(0) == false)
            {
                return false;
            }

            diceFound = traverser.dice;
            return true;
        }

        static void Main(string[] args)
        {
            var indexCharactorStrings = Console.In.ReadLine();
            var indicesMapper = indexCharactorStrings.Split(' ').ToArray();

            var count = int.Parse(Console.In.ReadLine());

            for (int i = 0; i < count; ++i)
            {
                var diceStrings = Console.In.ReadLine().Split(' ').ToArray();
                Dice dice;
                if (getMachedDice(diceStrings[0], diceStrings[1], indicesMapper, out dice) == false)
                {
                    throw new Exception("invalid input");
                }
                Console.Out.WriteLine(dice.Right);
            }
        }
    }
}



Measured memory_bytes: 18532