<|instruction|>
Solve the below problem. The solution should start with an abridged problem statement. Then key observations. Then full solution based on the observations. Then C++ and Python implementations with comments.

376. Berland All-Round Competitions
Time limit per test: 0.5 second(s)
Memory limit: 65536 kilobytes
input: standard
output: standard



The Berland has a tradition of all-round competitions. The rules of those competitions are the following. The first stage is swimming some distance, then there are K stages of horse riding. There are N horses located at the start of each of the riding stages (N is the number of participatnts). For each horse, its ridingness Sj is known. The more the ridingness is, the faster the horse finishes the stage. For each participant, there are three parameters: swimming skill Wi, riding skill Ri and strength Pi. Participant who reaches the start of some riding stage (which is the finish of the previous stage) takes the horse with maximal ridingness from those who are still at the start of this stage. Each horse can participate only in one stage. If two participants reach the start of any stage simoultaneously, the one with the most strength takes the better horse. All participants have different strengths. Time required to complete the riding stage for i-th participant is equal to 2· 107 - Ri - Sj, for the swimming stage the time is 2 · 107 - Wi. After the start of the competition (i. e. the start of the swimming stage) there are no pauses and changing or taking the horse requires no time.

Petya knows all characteristics of participants. Also he knows that the jury picks horses in such a way that on i-th stage (1 ≤ i ≤ K) the ridingness of j-th horse (1 ≤ j≤ N) is equal to f(i, j) = 3Ai2 + 5Ai Bj + 2Bj2, where all Ai and Bj are also known.

Now Peter wants to know the order of the participants on the finish line. Help him.

Input
The first line of the input contains two integers N and K (1≤ N≤ 103, 1≤ K≤ 103). N lines follow, containing three integers each: Wi, Ri and Pi (1 ≤ Wi, Ri, Pi ≤ 106). Then there are two lines: the first is for A, which contains K natural numbers not greater then 103, the second is for B, which contains N natural numbers not greater than 103.

Output
Output the space-separated transposition of N numbers — the order of participants. If two participants reach the finish simultaneously, they use armwrestling to determine the winner, and the participant with higher strength takes the better place.

Example(s)
sample input
sample output
4 2
2 5 3
3 1 4
3 4 1
2 2 2
2 3
4 5 6 7
2 3 1 4

<|response|>
## 1) Abridged problem statement

There are **N** participants and **K** horse-riding stages after an initial swimming stage.

- Participant *i* has swimming skill **Wi**, riding skill **Ri**, and strength **Pi** (all **Pi** are distinct).
- Swimming time: `Tswim(i) = 2·10^7 - Wi`.
- On each riding stage, there are **N horses** available at that stage's start, and **each horse can be used at most once** on that stage (i.e., each participant gets exactly one horse per stage).
- If multiple participants reach a stage simultaneously, the higher **Pi** chooses first.
- The participant who chooses first takes the remaining horse with **maximum ridingness Sj**.
- Riding time for participant *i* using a horse with ridingness **Sj**:
  `Tride(i, j) = 2·10^7 - Ri - Sj`.

Horse ridingness values are not given directly: for stage `s` (1..K) and horse index `j` (1..N):
`Sj = f(s, j) = 3·A_s^2 + 5·A_s·B_j + 2·B_j^2`,
where arrays **A** (length K) and **B** (length N) are given.

Output the **finish order** (participant IDs 1..N), sorting by total time ascending; ties are broken by higher strength **Pi**.

Constraints: `1 ≤ N, K ≤ 1000`.

---

## 2) Key observations

1. **Horse assignment on a stage is purely rank-based.**
   If you sort participants by:
   - arrival time ascending
   - strength descending (tie-break)

   then the 1st participant gets the best horse, 2nd gets the 2nd best, etc.

2. **For each stage, horses can be precomputed and sorted once.**
   For a fixed stage `s`, compute all `N` values `f(s, j)` and sort them in descending order.

3. **We can simulate stage-by-stage using only "arrival times".**
   Let `arrival[i]` be the time when participant `i` reaches the start of the current stage.
   - Initially: `arrival[i] = 2·10^7 - Wi` (after swimming).
   - After assigning a horse of value `H` on a stage:
     `arrival[i] += (2·10^7 - Ri) - H`

4. Complexity is fine:
   Each stage needs:
   - sort participants: `O(N log N)`
   - sort horses: `O(N log N)` (or precompute per stage)

   Total: `O(K N log N)` for `N, K ≤ 1000`.

---

## 3) Full solution approach

1. **Read input** and store for each participant:
   - `swim_time = 2e7 - Wi`
   - `ride_base = 2e7 - Ri` (later subtract horse value)
   - `strength = Pi`
   - `id` (1-based)

2. **Precompute horses for each stage**:
   For every stage `s = 0..K-1`:
   - compute `horse[j] = 3*A[s]^2 + 5*A[s]*B[j] + 2*B[j]^2` for `j=0..N-1`
   - sort `horse` descending
   Store as `stage_horses[s]`.

3. **Initialize arrival times** after swimming:
   `arrival[i] = swim_time[i]`

4. **Simulate each riding stage** `s = 0..K-1`:
   - Create an array `order = [0..N-1]`
   - Sort `order` by `(arrival[i], -strength[i])`
   - For each position `pos` in `0..N-1`:
     - participant index `p = order[pos]`
     - horse value `H = stage_horses[s][pos]` (pos-th best horse)
     - ride time on this stage: `ride_base[p] - H`
     - new arrival: `arrival[p] + (ride_base[p] - H)`
   - Replace `arrival` with the new values.

5. **Final ranking**:
   - Sort participants by `(arrival[i], -strength[i])` (arrival now equals total time)
   - Output their 1-based IDs.

---

## 4) C++ Solution

```cpp
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

struct participant {
    int id;
    int64_t swim;
    int64_t ride;
    int64_t strength;
    int64_t total_time = 0;
};

int n, k;
vector<participant> parts;
vector<int> a, b;

void read() {
    cin >> n >> k;

    parts.resize(n);
    for(int i = 0; i < n; i++) {
        int w, r, p;
        cin >> w >> r >> p;
        parts[i].id = i + 1;
        parts[i].swim = 20000000 - w;
        parts[i].ride = 20000000 - r;
        parts[i].strength = p;
    }

    a.resize(k);
    cin >> a;
    b.resize(n);
    cin >> b;
}

void solve() {
    // This is solution is fairly straight forward: we can do a direct
    // simulation of the process with priority queue, or by iterating through
    // the stages and sorting the people at each stage (each person will be at
    // each stage exactly once which defines the mapping to the horses too).

    vector<vector<int64_t>> stage_horses(k, vector<int64_t>(n));
    for(int i = 0; i < k; i++) {
        for(int j = 0; j < n; j++) {
            int64_t ai = a[i];
            int64_t bj = b[j];
            stage_horses[i][j] = 3 * ai * ai + 5 * ai * bj + 2 * bj * bj;
        }
        sort(stage_horses[i].rbegin(), stage_horses[i].rend());
    }

    vector<int64_t> arrival(n);
    for(int i = 0; i < n; i++) {
        arrival[i] = parts[i].swim;
        parts[i].total_time = parts[i].swim;
    }

    for(int stage = 0; stage < k; stage++) {
        vector<int> order(n);
        iota(order.begin(), order.end(), 0);

        sort(order.begin(), order.end(), [&](int x, int y) {
            if(arrival[x] != arrival[y]) {
                return arrival[x] < arrival[y];
            }
            return parts[x].strength > parts[y].strength;
        });

        vector<int64_t> new_arrival(n);
        for(int pos = 0; pos < n; pos++) {
            int p = order[pos];
            int64_t horse = stage_horses[stage][pos];
            int64_t ride_time = parts[p].ride - horse;
            int64_t finish_this_stage = arrival[p] + ride_time;
            new_arrival[p] = finish_this_stage;
            parts[p].total_time = finish_this_stage;
        }

        arrival = new_arrival;
    }

    vector<int> final_order(n);
    iota(final_order.begin(), final_order.end(), 0);

    sort(final_order.begin(), final_order.end(), [&](int x, int y) {
        if(parts[x].total_time != parts[y].total_time) {
            return parts[x].total_time < parts[y].total_time;
        }
        return parts[x].strength > parts[y].strength;
    });

    for(int i = 0; i < n; i++) {
        if(i > 0) {
            cout << " ";
        }
        cout << parts[final_order[i]].id;
    }
    cout << endl;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        solve();
    }

    return 0;
}
```

---

## 5) Python implementation (detailed comments)

```python
import sys

def solve() -> None:
    data = list(map(int, sys.stdin.buffer.read().split()))
    it = iter(data)

    n = next(it)
    k = next(it)

    # Store participant fields in parallel arrays for speed.
    # id is 1..n
    swim = [0] * n        # swim time = 2e7 - Wi
    ride_base = [0] * n   # ride base = 2e7 - Ri (horse value is subtracted)
    strength = [0] * n    # Pi
    total = [0] * n       # total time so far

    for i in range(n):
        w = next(it)
        r = next(it)
        p = next(it)
        swim[i] = 20_000_000 - w
        ride_base[i] = 20_000_000 - r
        strength[i] = p
        total[i] = swim[i]

    # Read arrays A (size K) and B (size N)
    A = [next(it) for _ in range(k)]
    B = [next(it) for _ in range(n)]

    # Precompute sorted horse values per stage (descending).
    # stage_horses[s][pos] = pos-th best horse value at stage s.
    stage_horses = []
    for s in range(k):
        a = A[s]
        horses = []
        # Compute f(s, j) for all j
        for bj in B:
            horses.append(3*a*a + 5*a*bj + 2*bj*bj)
        horses.sort(reverse=True)
        stage_horses.append(horses)

    # arrival time at current stage start (initially after swim)
    arrival = swim[:]

    # Simulate each riding stage
    for s in range(k):
        # Order participants by arrival asc, strength desc
        order = list(range(n))
        order.sort(key=lambda i: (arrival[i], -strength[i]))

        new_arrival = [0] * n
        horses = stage_horses[s]

        # Assign pos-th horse to pos-th participant in that order
        for pos, pi in enumerate(order):
            horse_val = horses[pos]
            ride_time = ride_base[pi] - horse_val
            finish = arrival[pi] + ride_time
            new_arrival[pi] = finish
            total[pi] = finish

        arrival = new_arrival

    # Final ranking: total time asc, strength desc
    final_order = list(range(n))
    final_order.sort(key=lambda i: (total[i], -strength[i]))

    # Output participant IDs (1-based)
    ans = [str(i + 1) for i in final_order]
    sys.stdout.write(" ".join(ans))

if __name__ == "__main__":
    solve()
```
