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

namespace Equeue
{
    
    
    class Equeue
    {
      static Node[] Nodes;
        static void Main(string[] args)
        {
            long nil = 100000000000;
            //var N = long.Parse(Console.ReadLine());
            var ABQ = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
            var A = ABQ[0];
            var B = ABQ[1];
            var Q = ABQ[2];
            
            var temp = new long[A];
            var shri = new long[B];
            
            for(int i = 0;i < A;i++){
              temp[i] = long.Parse(Console.ReadLine());
            }
            
            for(int i = 0;i < B;i++){
              shri[i] = long.Parse(Console.ReadLine());
            }
           
            for(int i = 0;i < Q;i++){
              var ans = long.MaxValue;
              var query = long.Parse(Console.ReadLine());
              
              var tempW = LowerBound(temp,query+1)-1;
              long DisWesTemp = nil;
              if(tempW != -1){
                DisWesTemp = query-temp[tempW];
              }
              
              var shriW = LowerBound(shri,query+1)-1;
              long DisWesShri = nil;
              if(shriW != -1){
                DisWesShri = query-shri[shriW];
              }
              
              var tempE = LowerBound(temp,query);
              long DisEasTemp = nil;
              if(tempE != A){
                DisEasTemp = temp[tempE]-query;
              }
              
              var shriE = LowerBound(shri,query);
              long DisEasShri = nil;
              if(shriE != B){
                DisEasShri = shri[shriE]-query;
              }
              
              //西西のパターン
              long WW = Math.Max(DisWesTemp,DisWesShri);
              //東東パターン
              long RR = Math.Max(DisEasTemp,DisEasShri);
              //東西パターン
              long RW = 2*(DisEasTemp+DisWesShri)-Math.Max(DisEasTemp,DisWesShri);
              //西東パターン
              long WR = 2*(DisWesTemp+DisEasShri)-Math.Max(DisWesTemp,DisEasShri);
              Console.WriteLine(Math.Min(Math.Min(WW,RR),Math.Min(WR,RW)));
            }
            
            
            
            
           

            
        }
      
        public static int LowerBound<T>(T[] a, T v)
{ 
    return LowerBound(a, v, Comparer<T>.Default);
}

public static int LowerBound<T>(T[] a, T v, Comparer<T> cmp)
{
    var l = 0;
    var r = a.Length - 1;
    while (l <= r)
    {
        var mid = l + (r - l) / 2;
        var res = cmp.Compare(a[mid], v);
        if (res == -1) l = mid + 1;
        else r = mid - 1;
    }
    return l;
}
      
      
        static bool WFS(long st){
          var q = new Queue<Node>();
          var tmp = Nodes[st];
          tmp.loc = 100;
          q.Enqueue(tmp);
          
          while(q.Count > 0){
            tmp = q.Dequeue();
            foreach(KeyValuePair<long,long> item in tmp.adj) {
              var child = Nodes[item.Key];
              //Console.WriteLine(item.Key+" "+child.loc+" "+item.Value);
              if(child.loc != -1 && (child.loc != (item.Value+tmp.loc))){
                return false;
              }else if(child.loc == -1){
                child.loc = item.Value+tmp.loc;
                q.Enqueue(Nodes[item.Key]);
                //Console.WriteLine(item.Key+" "+child.loc+" "+item.Value);
              }
              
            }
          }
          return true;
        }      
      
    }
  


    public class Node{
      public long loc = -1;
      public Dictionary<long,long> adj = new Dictionary<long,long>();
    }
  
  
    public class PriorityQueue<T> : IEnumerable<T>
    {
        private readonly List<T> _data = new List<T>();
        private readonly IComparer<T> _comparer;
        private readonly bool _isDescending;

        public PriorityQueue(IComparer<T> comparer, bool isDescending = true)
        {
            _comparer = comparer;
            _isDescending = isDescending;
        }

        public PriorityQueue(Comparison<T> comparison, bool isDescending = true)
            : this(Comparer<T>.Create(comparison), isDescending)
        {
        }

        public PriorityQueue(bool isDescending = true)
            : this(Comparer<T>.Default, isDescending)
        {
        }

        public void Enqueue(T item)
        {
            _data.Add(item);
            var childIndex = _data.Count - 1;
            while (childIndex > 0)
            {
                var parentIndex = (childIndex - 1) / 2;
                if (Compare(_data[childIndex], _data[parentIndex]) >= 0)
                    break;
                Swap(childIndex, parentIndex);
                childIndex = parentIndex;
            }
        }

        public T Dequeue()
        {
            var lastIndex = _data.Count - 1;
            var firstItem = _data[0];
            _data[0] = _data[lastIndex];
            _data.RemoveAt(lastIndex--);
            var parentIndex = 0;
            while (true)
            {
                var childIndex = parentIndex * 2 + 1;
                if (childIndex > lastIndex)
                    break;
                var rightChild = childIndex + 1;
                if (rightChild <= lastIndex && Compare(_data[rightChild], _data[childIndex]) < 0)
                    childIndex = rightChild;
                if (Compare(_data[parentIndex], _data[childIndex]) <= 0)
                    break;
                Swap(parentIndex, childIndex);
                parentIndex = childIndex;
            }
            return firstItem;
        }

        public T Peek()
        {
            return _data[0];
        }

        private void Swap(int a, int b)
        {
            var tmp = _data[a];
            _data[a] = _data[b];
            _data[b] = tmp;
        }

        private int Compare(T a, T b)
        {
            return _isDescending ? _comparer.Compare(b, a) : _comparer.Compare(a, b);
        }

        public int Count => _data.Count;

        public IEnumerator<T> GetEnumerator()
        {
            return _data.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }
}


Measured memory_bytes: 18480