You will receive a batch of candidate FREE/USE pairs that survived source-line
ranking and structural call-relation filtering. Rank the pairs by priority for
deep manual or LLM use-after-free analysis.

Treat each pair as a sealed candidate. Never combine the FREE from one candidate
with the USE, call chain, object, or explanation from another candidate. Use only
the exact supplied evidence; do not mutate function names or invent operations.

Evaluate every pair in this exact order. An earlier failed gate cannot be
rescued by later structural evidence.

1. FREE gate

First judge the exact supplied FREE line itself.

A valid FREE line directly performs or triggers object lifetime reduction, such
as freeing memory, destroying or releasing an object, dropping a reference,
closing a resource, or invoking a project-specific lifetime helper. Calls with
names such as *_free, *_release, *_destroy, *_put, *_drop, *_unref, or *_close
are strong evidence only when the operation and argument plausibly identify the
released object.

The following are not FREE operations merely because they occur inside cleanup
code: function signatures, labels, goto/return statements, conditions, ordinary
assignments, status or flag assignments, initialization, lock/unlock operations,
response formatting, and arithmetic or bookkeeping.

If the exact FREE line is not plausibly lifetime-ending, assign the pair the
lowest evidence tier and rank it below every pair with a genuine FREE. Do not
allow call reachability to rescue it.

2. USE gate

Judge whether the exact USE line relies on a lifetime-sensitive object. Strong
USE evidence includes pointer or field dereferences, guarded field checks,
reading or writing through an object, passing a pointer-like value, indexing
through it, or checking its state, flags, locks, or reference count.

Response formatting, unrelated status handling, and bookkeeping on unrelated
request, response, configuration, length, offset, or count fields are weak USE
evidence.

3. Object relationship

Compare the concrete expressions appearing in the FREE operation and the USE
operation.

Rank higher when the supplied evidence shows that the USE plausibly touches:

- the same object passed to or affected by the FREE
- an obvious alias of that object
- a field or subobject of it
- its owner or containing object
- another object whose validity clearly depends on it

Useful evidence includes matching base expressions, shared object-bearing
identifiers, matching fields, explicit assignments or parameter flow, and
ownership relationships visible in the supplied code.

For example, releasing `obj` and later accessing `obj->field` is stronger
same-object evidence than releasing `obj` and later accessing an unrelated
`other->field`.

Do not infer an object relationship merely from similar function names, shared
file names, call-graph proximity, or generic identifiers such as `work`, `req`,
`rsp`, `ctx`, or `data`.

A real FREE with weak object correspondence is stronger than an invalid FREE,
but weaker than a real FREE paired with a clearly related USE.
