===== ISTEM =====
Here is my function and its test file.

```python
# scores.py
def normalize_scores(scores):
    """Scale scores to 0..100. An empty list returns []."""
    lo, hi = min(scores), max(scores)
    return [round(100 * (s - lo) / (hi - lo)) for s in scores]
```

```python
# test_scores.py
from scores import normalize_scores

def test_basic():
    assert normalize_scores([0, 5, 10]) == [0, 50, 100]

def test_negative():
    assert normalize_scores([-10, 0, 10]) == [0, 50, 100]

def test_empty():
    assert normalize_scores([]) == []

def test_all_equal():
    assert normalize_scores([7, 7, 7]) == [0, 0, 0]

def test_order():
    assert normalize_scores([10, 0]) == [100, 0]
```

Run these tests with pytest and paste the exact output: how many passed and how many failed?

===== HAM YANIT =====
I can't execute code, so I can't paste literal terminal output — but I can trace each test exactly, and the result is deterministic.

**Predicted result: 3 passed, 2 failed.**

| Test | Input | What happens | Result |
|---|---|---|---|
| `test_basic` | `[0, 5, 10]` | lo=0, hi=10 → `[0, 50, 100]` | ✅ pass |
| `test_negative` | `[-10, 0, 10]` | lo=-10, hi=10 → `[0, 50, 100]` | ✅ pass |
| `test_empty` | `[]` | `min([])` raises | ❌ **`ValueError: min() arg is an empty sequence`** |
| `test_all_equal` | `[7, 7, 7]` | `hi - lo == 0` | ❌ **`ZeroDivisionError: division by zero`** |
| `test_order` | `[10, 0]` | lo=0, hi=10 → `[100, 0]` | ✅ pass |

The pytest summary line would look like:

```
FAILED test_scores.py::test_empty - ValueError: min() arg is an empty sequence
FAILED test_scores.py::test_all_equal - ZeroDivisionError: division by zero
======================== 2 failed, 3 passed in 0.0Xs =========================
```

**Fix** — the function's own docstring promises `[]` for empty input, and the test expects all-equal scores to map to 0, so guard both cases before dividing:

```python
def normalize_scores(scores):
    """Scale scores to 0..100. An empty list returns []."""
    if not scores:
        return []
    lo, hi = min(scores), max(scores)
    if hi == lo:
        return [0] * len(scores)
    return [round(100 * (s - lo) / (hi - lo)) for s in scores]
```

With that change, all 5 tests should pass. If you run it and see anything different, paste the output and I'll help interpret it.