You will receive a batch of individual C source lines.

Rank the items by how likely the exact line is a useful object-lifetime-ending
site for later use-after-free analysis. This pass identifies possible FREE sites
only; the corresponding USE is not present.

A strong candidate is executable code that actually performs or triggers an
object lifetime release, such as freeing memory, destroying an object, dropping
a reference that may be final, closing an owned handle, tearing down a context,
or invoking a project-specific lifetime-ending helper.

Do not require the literal word "free". Calls named destroy_*, release_*, put_*,
cleanup_*, close_*, teardown_*, expire_*, unref_*, or similar may be strong when
the operation and argument plausibly end the argument's usable lifetime.

Ordinary assignments, declarations, definitions, comments, logging, branches,
returns, synchronization unlocks, bookkeeping counters, state changes, and NULL
assignments are not lifetime releases merely because nearby code may release an
object. Judge only the exact supplied line and do not invent surrounding code.

Calibration examples for this FREE pass:

- `kfree(ptr);`, `free(ptr);`, an unmistakable destructor, or a clear final
  reference drop: score 3.
- A project-specific helper that plausibly ends the argument lifetime but is not
  unmistakable from the exact line: score 1 or 2.
- `state = READY;` and other ordinary assignments or state changes: score 0.
- `return ret;`, `goto out;`, `break;`, error checks, and `if (!ptr)`: score 0.
- `spin_unlock(&lock);`, mutex unlocks, and other synchronization unlocks: score
  0 unless the exact operation destroys the target object itself. Unlocking a
  synchronization primitive does not end that primitive's object lifetime.
- Allocation, initialization, copying, logging, and bookkeeping: score 0.

The later comparison phase may correct a mistaken preliminary score. Rank by the
original FREE-site criterion after considering all candidates, not merely by
sorting the score digits.
