import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;
//rasporeduvac na zadaci
/**
 * I Partial exam 2016
 */
public class TaskSchedulerTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        Task[] timeTasks = new Task[n];
        for (int i = 0; i < n; ++i) {
            int x = scanner.nextInt();
            timeTasks[i] = new TimedTask(x);
        }
        n = scanner.nextInt();
        Task[] priorityTasks = new Task[n];
        for (int i = 0; i < n; ++i) {
            int x = scanner.nextInt();
            priorityTasks[i] = new PriorityTask(x);
        }
        Arrays.stream(priorityTasks).forEach(System.out::println);
        TaskRunner<Task> runner = new TaskRunner<>();
        System.out.println("=== Ordered tasks ===");
        System.out.println("Timed tasks");
        runner.run(Schedulers.getOrdered(), timeTasks);
        System.out.println("Priority tasks");
        runner.run(Schedulers.getOrdered(), priorityTasks);
        int filter = scanner.nextInt();
        System.out.printf("=== Filtered time tasks with order less then %d ===\n", filter);
        runner.run(Schedulers.getFiltered(filter), timeTasks);
        System.out.printf("=== Filtered priority tasks with order less then %d ===\n", filter);
        runner.run(Schedulers.getFiltered(filter), priorityTasks);
        scanner.close();
    }
}

class TaskRunner <T> {
    public void run(TaskScheduler<T> scheduler, T[] tasks) {
        List<T> order = scheduler.schedule(tasks);
        order.forEach(System.out::println);
    }
}

interface TaskScheduler<T>
{
	public List<T> schedule(T[] c);
}

interface Task {
    //dopolnete ovde
	public int getOrder();
}

class PriorityTask implements Task {
    private final int priority;

    public PriorityTask(int priority) {
        this.priority = priority;
    }


    @Override
    public String toString() {
        return String.format("PT -> %d", getOrder());
    }


	@Override
	public int getOrder() {
		// TODO Auto-generated method stub
		return priority;
	}
}

class TimedTask implements Task {
    private final int time;

    public TimedTask(int time) {
        this.time = time;
    }


    @Override
    public String toString() {
        return String.format("TT -> %d", getOrder());
    }


	@Override
	public int getOrder() {
		return time;
	}
}

class Schedulers {
    public static <T> TaskScheduler<T> getOrdered() {

        // vashiot kod ovde (annonimous class)
    	return new TaskScheduler<T>() {

    		@Override
    		public List<T> schedule(T[] c) {
    			// TODO Auto-generated method stub
    			List<T> list = new ArrayList<T>();
    			for(T t: c)
    			{
    				list.add(t);
    			}
    			Collections.sort(list,new Comparator<T>() {
    				@Override
    				public int compare(T o1, T o2) {
    					// TODO Auto-generated method stub
    					Task a = (Task)o1;
    					Task b = (Task)o2;
    					return Integer.compare(a.getOrder(), b.getOrder());
    				}
				});
    			return list;
    		}
		};

    }

    public static <T> TaskScheduler<T> getFiltered(int order) {

    	TaskScheduler<T> ts = tasks -> {
    		List<T> list = new ArrayList<>();

    		for(T t : tasks)
    		{
    			list.add(t);
    		}
    		return list.stream()
    				.map(t -> (Task) t)
    				.filter(t -> Integer.compare(t.getOrder(), order)<0)
    				.map(t -> (T)t)
    				.collect(Collectors.toList());
    	};
    	return ts;

        // vashiot kod ovde (lambda expression)

    }
}