import bisect
from collections import defaultdict

def main():
    import sys
    input = sys.stdin.read
    data = input().split()
    ptr = 0

    N = int(data[ptr])
    ptr += 1

    a_dict = defaultdict(list)

    for _ in range(N):
        l = int(data[ptr])
        r = int(data[ptr + 1])
        a = int(data[ptr + 2])
        ptr += 3
        a_dict[a].append((l, r))

    # Preprocess each a's intervals: sort and merge
    for a in a_dict:
        intervals = a_dict[a]
        # Sort by l
        intervals.sort()
        # Merge intervals
        merged = []
        for l, r in intervals:
            if not merged:
                merged.append([l, r])
            else:
                last_l, last_r = merged[-1]
                if l <= last_r + 1:
                    # Overlapping or adjacent, merge
                    new_l = last_l
                    new_r = max(last_r, r)
                    merged[-1] = (new_l, new_r)
                else:
                    merged.append((l, r))
        a_dict[a] = merged

    Q = int(data[ptr])
    ptr += 1
    queries = list(map(int, data[ptr:ptr + Q]))
    ptr += Q

    for x in queries:
        m = 0
        while True:
            if m not in a_dict:
                mex = m
                break
            else:
                intervals = a_dict[m]
                # Extract l's for binary search
                l_list = [interval[0] for interval in intervals]
                idx = bisect.bisect_right(l_list, x) - 1
                if idx >= 0:
                    l, r = intervals[idx]
                    if x <= r:
                        # Covered, move to next m
                        m += 1
                        continue
                # Not covered, mex is m
                mex = m
                break
        print(mex)

if __name__ == "__main__":
    main()