using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;

partial class Solver
{
    public class Data
    {
        public int Id { get; set; }
        public int Value { get; set; }
    }

    public void Run()
    {
        var N = ni();
        var Q = ni();
        var S = new int[N];
        var T = new int[N];
        var X = new int[N];
        for (int i = 0; i < N; i++)
        {
            S[i] = ni();
            T[i] = ni();
            X[i] = ni();
        }
        var D = ni(Q);

        var c = new List<int>();
        for (int i = 0; i < N; i++)
        {
            c.Add(S[i] - X[i]);
            c.Add(T[i] - X[i]);
        }
        for (int i = 0; i < Q; i++)
        {
            c.Add(D[i]);
        }

        var dic = IndexDictionaryFactory.Create(c);

        var tree = new AnonymousRangeUpdateSegmentTree<int>(Math.Min);
        tree.Build(dic.Count, i => int.MaxValue);

        for (int i = 0; i < N; i++)
        {
            var begin = dic.GetIndex(S[i] - X[i]);
            var end = dic.GetIndex(T[i] - X[i]);

            tree.Update(begin, end, X[i]);
        }


        foreach (var d in D)
        {
            var p = dic.GetIndex(d);
            var ans = tree.Get(p);
            if (ans == int.MaxValue) ans = -1;
            cout.WriteLine(ans);
        }
    }
}


public class IndexDictionary<T>
{
    private readonly Dictionary<T, int> _toIndex;
    private readonly T[] _array;

    public IndexDictionary(IEnumerable<T> source) : this(source, Comparer<T>.Default) { }

    public IndexDictionary(IEnumerable<T> source, IComparer<T> comparer)
    {
        _array = source.Distinct().ToArray();
        Array.Sort(_array, comparer);
        _toIndex = new Dictionary<T, int>(_array.Length);
        int index = -1;
        foreach (var x in _array) _toIndex[x] = ++index;
    }

    public int Count { get { return _array.Length; } }

    public T this[int index] { get { return _array[index]; } }

    public int GetIndex(T value) { return _toIndex[value]; }
}

public class IndexDictionaryFactory
{
    public static IndexDictionary<T> Create<T>(IEnumerable<T> source)
    {
        return new IndexDictionary<T>(source);
    }
}
public abstract class RangeUpdateSegmentTree<TNodeValue> where TNodeValue : struct
{
    protected int N { get; private set; }
    protected TNodeValue?[] node;
    protected static int Left(int p) { return p * 2 + 1; }
    protected static int Right(int p) { return p * 2 + 2; }

    public RangeUpdateSegmentTree() { }

    public void Build(IList<TNodeValue> array)
    {
        Build(array.Count, i => array[i]);
    }

    virtual public void Build(int _n, Func<int, TNodeValue> create)
    {
        N = 1;
        while (N < _n) N *= 2;
        node = new TNodeValue?[2 * N];

        for (int i = 0; i < _n; i++) node[i + N - 1] = create(i);
        for (int i = N - 2; i >= 0; i--) node[i] = Merge(node[Left(i)], node[Right(i)]);
    }

    protected TNodeValue? Merge(TNodeValue? left, TNodeValue? right)
    {
        if (left != null && right != null) return Merge(left.Value, right.Value);
        return right ?? left;
    }

    protected abstract TNodeValue Merge(TNodeValue left, TNodeValue right);

    public TNodeValue Get(int index)
    {
        int p = index + N - 1;
        var result = node[p];
        while (p > 0)
        {
            p = (p - 1) >> 1;
            result = Merge(result, node[p]);
        }
        return result.Value;
    }

    int Begin, End;

    protected virtual void Update(int k, int l, int r, TNodeValue value)
    {
        if (r <= Begin || End <= l) return;
        if (Begin <= l && r <= End)
        {
            node[k] = Merge(node[k], value);
            return;
        }
        int mid = (l + r) >> 1;
        Update(Left(k), l, mid, value);
        Update(Right(k), mid, r, value);
    }

    public void Update(int begin, int end, TNodeValue value)
    {
        Begin = begin;
        End = end;
        Update(0, 0, N, value);
    }
};

public class AnonymousRangeUpdateSegmentTree<TNodeValue> : RangeUpdateSegmentTree<TNodeValue> where TNodeValue : struct
{
    readonly Func<TNodeValue, TNodeValue, TNodeValue> _mergeMethod;

    public AnonymousRangeUpdateSegmentTree(Func<TNodeValue, TNodeValue, TNodeValue> merge)
    {
        _mergeMethod = merge;
    }

    protected override TNodeValue Merge(TNodeValue left, TNodeValue right)
    {
        return _mergeMethod(left, right);
    }
}

// PREWRITEN CODE BEGINS FROM HERE
partial class Solver : Scanner
{
    public static void Main(string[] args)
    {
#if LOCAL
        new Solver(Console.In, Console.Out).Run();
#else
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        new Solver(Console.In, Console.Out).Run();
        Console.Out.Flush();
#endif
    }

    TextReader cin;
    TextWriter cout;

    public Solver(TextReader reader, TextWriter writer)
        : base(reader)
    {
        this.cin = reader;
        this.cout = writer;
    }
    public Solver(string input, TextWriter writer)
        : this(new StringReader(input), writer)
    {
    }

    public int ni() { return NextInt(); }
    public int[] ni(int n) { return NextIntArray(n); }
    public long nl() { return NextLong(); }
    public long[] nl(int n) { return NextLongArray(n); }
    public double nd() { return NextDouble(); }
    public string ns() { return Next(); }
}

public class Scanner
{
    private TextReader Reader;
    private Queue<String> TokenQueue = new Queue<string>();
    private readonly CultureInfo ci = CultureInfo.InvariantCulture;

    public Scanner()
        : this(Console.In)
    {
    }

    public Scanner(TextReader reader)
    {
        this.Reader = reader;
    }

    public int NextInt() { return Int32.Parse(Next(), ci); }
    public long NextLong() { return Int64.Parse(Next(), ci); }
    public double NextDouble() { return double.Parse(Next(), ci); }
    public string[] NextArray(int size)
    {
        var array = new string[size];
        for (int i = 0; i < size; i++) array[i] = Next();
        return array;
    }
    public int[] NextIntArray(int size)
    {
        var array = new int[size];
        for (int i = 0; i < size; i++) array[i] = NextInt();
        return array;
    }

    public long[] NextLongArray(int size)
    {
        var array = new long[size];
        for (int i = 0; i < size; i++) array[i] = NextLong();
        return array;
    }

    public String Next()
    {
        if (TokenQueue.Count == 0)
        {
            if (!StockTokens()) throw new InvalidOperationException();
        }
        return TokenQueue.Dequeue();
    }

    public bool HasNext()
    {
        if (TokenQueue.Count > 0)
            return true;
        return StockTokens();
    }

    private bool StockTokens()
    {
        while (true)
        {
            var line = Reader.ReadLine();
            if (line == null) return false;
            var tokens = line.Trim().Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            if (tokens.Length == 0) continue;
            foreach (var token in tokens)
                TokenQueue.Enqueue(token);
            return true;
        }
    }
}


Measured memory_bytes: 69388