using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace ProjEuler
{
    public class ACM2008_LSU_Problem8
    {
        public static void Main()
        {
            using(TextWriter writer=new StreamWriter("output.txt"))
            using (TextReader reader = new StreamReader("input.txt"))
            {
                Console.SetOut(writer);
                int n = ReadInt(reader);
                for (int i = 0; i < n; i++)
                    ProcessProblem(i+1, reader);
            }
        }

        public static void ProcessProblem(int id, TextReader input)
        {
            Console.Error.WriteLine(id);
            Console.WriteLine("DATA SET #" + id);
            Timeline timeline = new Timeline();
            int wormHoleCount = ReadInt(input);
            for (int i = 0; i < wormHoleCount; i++)
                timeline.AddWormhole(ReadInts(input));

            int startingYear = ReadInt(input);
            int missionCount = ReadInt(input);
            List<int> missions = new List<int>();
            for (int m = 0; m < missionCount; m++)
                missions.Add(ReadInt(input));
            
            List<int> years = new List<int>(missions);
            years.Add(startingYear);
            int[,] distances = timeline.AllPairs(years, out years);

            foreach(int destination in missions)
            {
                int i = years.IndexOf(startingYear);
                int j = years.IndexOf(destination);
                int toDistance = distances[i, j];
                int fromDistance = distances[j, i];
                if(toDistance==Int32.MaxValue || fromDistance==Int32.MaxValue)
                    Console.WriteLine("IMPOSSIBLE");
                else
                    Console.WriteLine(toDistance+fromDistance);
            }
        }

        private static int ReadInt(TextReader reader)
        {
            return Int32.Parse(reader.ReadLine());
        }

        private static int[] ReadInts(TextReader reader)
        {
            string text = reader.ReadLine();
            string[] numbers = text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            int[] result=new int[numbers.Length];
            for (int i = 0; i < numbers.Length; i++) 
                result[i] = Int32.Parse(numbers[i]);
            return result;
        }
    }

    class Timeline
    {
        private List<int[]> wormholes=new List<int[]>();

        public void AddWormhole(int[] wormhole) 
        { 
            wormholes.Add(wormhole); 
        }

        public int[,] AllPairs(List<int> missionYears, out List<int> distinctVerticies)
        {
            distinctVerticies = BuildDistinctVerticies(missionYears);
            int[,] currentWeights = BuildInitialWeights(distinctVerticies);
            int[,] nextWeights = new int[distinctVerticies.Count, distinctVerticies.Count];
            for (int i = 0; i < distinctVerticies.Count; i++)
            {
                Extend(currentWeights, nextWeights, i);
                int[,] temp = currentWeights;
                currentWeights = nextWeights;
                nextWeights = temp;
            }
            return currentWeights;
        }

        public void Extend(int[,] previosLevel, int[,] thisLevel, int k)
        {
            for(int i=0; i<previosLevel.GetLength(0); i++)
                for(int j=0; j<previosLevel.GetLength(1); j++)
                {
                    int iToJ = previosLevel[i,j];
                    int iToK = previosLevel[i,k];
                    int kToJ = previosLevel[k,j];
                    if (iToK != Int32.MaxValue && kToJ != Int32.MaxValue)
                        thisLevel[i,j] = Math.Min(iToJ, iToK + kToJ);
                    else thisLevel[i,j] = iToJ;
                }
        }

        public List<int> BuildDistinctVerticies(List<int> addedYears)
        {
            List<int> years = new List<int>(addedYears);
            foreach (int[] wormhole in wormholes)
            {
                years.Add(wormhole[0]);
                years.Add(wormhole[1]);
            }
            years.Sort();
            for (int i = 1; i < years.Count; i++)
                if (years[i - 1] == years[i])
                    years.RemoveAt(i--);
            return years;
        }

        public int[,] BuildInitialWeights(List<int> distinctVerticies)
        {
            int[,] weights = new int[distinctVerticies.Count, distinctVerticies.Count];
            for(int i=0; i<distinctVerticies.Count; i++)
                for(int j=0; j<distinctVerticies.Count; j++)
                {
                    if (i == j) weights[i,j] = 0;
                    else weights[i,j] = Int32.MaxValue;
                }

            //assumes vertices are in order, from first year to last
            for (int i = 1; i < distinctVerticies.Count; i++)
            {
                int start = distinctVerticies[i - 1];
                int end = distinctVerticies[i];
                weights[i-1, i] = end - start;
            }
            foreach (int[] years in wormholes)
            {
                int i = distinctVerticies.IndexOf(years[0]);
                int j = distinctVerticies.IndexOf(years[1]);
                int weight;
                if (years[1] > years[0]) weight = (years[1] - years[0]) / 2;
                else weight = (years[1] - years[0]) / 4;
                weights[i, j] = weight;
            }
            return weights;
        }
    }
}