1. Abridged Problem Statement  
You have N tanks (numbered 1…N), each starting with 100 hit points (HP) and 0 score. You are given a log of M successful hits: each entry is (shooter, target). For each hit in order:  
- If the target’s HP before the hit was >0, the shooter gains 3 score points.  
- The target loses 8 HP (HP may go below zero).  
After processing all hits, every tank that still has HP>0 earns a bonus of ⌊HP/2⌋ points.  
Output for tanks 1 through N their final HP and final score.

2. Detailed Editorial  
We can directly simulate the battle in O(M+N) time and O(N) space, since N≤6 and M≤4000.  

Initialization  
- Create two arrays of length N:  
  hp[i] = 100 (hit points for tank i)  
  score[i] = 0 (score points for tank i)  

Processing each shot (shooter s, target t):  
- Convert to zero-based: s–; t–.  
- Check if target is still “alive,” i.e., hp[t] > 0. If so, the shooter earns +3 score points.  
- Subtract 8 from hp[t]: hp[t] -= 8. It is allowed for hp[t] to become negative; “dead” tanks stay dead.  
- We do not need to check the shooter’s HP for activity because the problem guarantees that only active tanks appear as shooters in the log.  

After all hits:  
- For each tank i with hp[i] > 0, add a bonus of floor(hp[i]/2) to score[i].  
- Print for each tank i (in order 1…N): hp[i] and score[i].  

Implementation details  
- Use 32-bit ints for HP and score (all intermediate values are small).  
- Reading input: first line N, M; then M lines of (s, t).  
- Direct array indexing and updates suffice.  

Complexities  
- Time: O(M + N)  
- Memory: O(N)
3. 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;
};

int n, m;
vector<pair<int, int>> shots;

void read() {
    cin >> n >> m;
    shots.resize(m);
    cin >> shots;
}

void solve() {
    // Direct simulation of the match log:
    //
    // - hit_points[i] starts at 100, score_points[i] at 0.
    //
    // - For each shot (shooter, target), if the target still had positive
    //   hit points before the shot the shooter gains 3 score points, then
    //   the target loses 8 hit points regardless.
    //
    // - At the end every tank with positive hit points additionally gains
    //   half of its remaining hit points as score.

    vector<int> hit_points(n, 100), score_points(n, 0);
    for(auto [shooter, target]: shots) {
        shooter--;
        target--;
        if(hit_points[target] > 0) {
            score_points[shooter] += 3;
        }

        hit_points[target] -= 8;
    }

    for(int i = 0; i < n; i++) {
        if(hit_points[i] > 0) {
            score_points[i] += hit_points[i] / 2;
        }
    }

    for(int i = 0; i < n; i++) {
        cout << hit_points[i] << ' ' << score_points[i] << '\n';
    }
}

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

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}
```

4. Python Solution with Detailed Comments  
```python
def process_match():
    # Read N (tanks) and M (shots)
    N, M = map(int, input().split())

    # Read the list of shots: each is (shooter, target)
    shots = [tuple(map(int, input().split())) for _ in range(M)]

    # Initialize hit points and scores
    hit_points = [100] * N   # All tanks start with 100 HP
    score_points = [0] * N   # All tanks start with 0 score

    # Simulate each shot in chronological order
    for shooter, target in shots:
        s = shooter - 1       # Convert to 0-based index
        t = target - 1

        # If target was alive (>0 HP) before the hit, shooter gets +3 points
        if hit_points[t] > 0:
            score_points[s] += 3

        # Apply damage: subtract 8 HP from the target
        hit_points[t] -= 8

    # After all shots, give bonus to tanks still alive
    for i in range(N):
        if hit_points[i] > 0:
            # Bonus is floor(hit_points / 2)
            score_points[i] += hit_points[i] // 2

    # Print the result: for each tank, its final HP and score
    for i in range(N):
        print(hit_points[i], score_points[i])

# Run the function
if __name__ == "__main__":
    process_match()
```

5. Compressed Editorial  
Simulate directly. Maintain `hp[i]`=100 and `score[i]`=0 for i=1…N. For each shot (s→t): if `hp[t]>0` then `score[s]+=3`; then `hp[t]-=8`. After all shots, for each alive tank add `hp[i]//2` to `score[i]`. Print `(hp[i], score[i])`. Time O(M+N).