As an apprentice algorithms enthusiast, it is not a great surprise that Mike struggles to cope with overly complex systems. Unfortunately, this turned out to be a big problem in the company he is currently interning.
Mike’s assigned project involves tinkering with the company’s Intelligent Cluster for Parallel Computation. This is just a fancy name; in reality, the system is just a simple job scheduler, handling a total of n jobs. Some jobs might depend on successful execution of other jobs before being able to be executed. There are m such dependencies in total.
It is guaranteed that there are no (direct or indirect) circular dependencies between jobs.
When a run is started, the systems intelligently picks an order to execute these jobs so that all the dependencies are met (the order may change between different runs). After picking a valid ordering, it starts executing each of the n jobs in that order. When the system starts executing a job, it prints the id of the job to a log file.
Unfortunately, today was Mike’s first day interning at the company and he wasn’t very cautious. Consequently, he accidentally ran the system k times in parallel. The system started erratically launching jobs and printing to the log file. Now the log file contains n * k ids of all the jobs that were executed. The job ids from the same run have been printed in the order they were executed, but the outputs from different runs may appear interweaved arbitrarily.
Your task is to figure out which jobs were executed in each of the k runs from the information inside the log file.
The first line will contain three integers n, k, m (1 ≤ n, k ≤ 500 000, 0 ≤ m ≤ 250 000, n * k ≤ 500 000), the number of jobs in the system, the number of runs Mike had triggered, and the number of dependencies.
The following m lines will contain a pair
bi (1 ≤
bi ≤ n,
bi, for all 1 ≤ i ≤ m) describing a dependency of kind: “job
ai must be executed before job
Finally, the last line contains n * k integers
ci (1 ≤
ci ≤ n, for all 1 ≤ i ≤ n * k), the job ids that have been printed in the log file, in order.
Output a single line consisting of n * k integers
ri (1 ≤
ri ≤ k, for all 1 ≤ i ≤ n * k), the run id corresponding to each of the jobs in the log file. More specifically,
ri should be the run id corresponding to the i-th job, as it appears in the log file.
If multiple solutions are possible, any one is accepted. It is guaranteed that the input data is valid and that a solution always exists.
3 3 2 1 2 1 3 1 1 2 3 3 2 1 2 3
1 2 1 1 2 2 3 3 3