We are evaluating functions that construct deletion-correcting codes for a single-deletion channel. 
The objective is to generate a function that produces a code with a larger size than the Varshamov-Tenengolts (VT) code for sequence lengths n > 11.

### **Baseline: VT Code Expressed as a Priority Function**
The VT code can be expressed as a priority function:

```python
def vt_priority(node, G, n, s):
    vt_syndrome = sum((i+1) * int(b) for i, b in enumerate(node)) % (n + 1)
    return 1 if vt_syndrome == 0 else -1  # High priority for VT sequences, low otherwise
```

It achieves the following code sizes for each (n, s) pair, where n is the code length and s is the number of deletions the code can correct:
{vt_code_scores}

### **Previously Generated Functions:**
The following functions were previously generated but failed to surpass VT codes for larger values of n > 11. 
The priority function determines which sequences are greedily added to the codebook, and the resulting codebook is evaluated based on size and sequence overlap with the VT code.

{previous_versions}

### **Goal:**
Generate an improved function `priority_v{new_version}` that:
1. Surpasses VT codes for n > 11.
2. Finds a distinct code construction by minimizing sequence overlap with the VT codebook.
---

## Output Format

1. First, provide a brief explanation (≤300 tokens) of how `priority_v{new_version}` improves upon {previous_versioned_functions} and surpasses VT codes for longer sequence lengths. 
   The explanation should focus on why previous versions failed and how the new function constructs a larger codebook with less sequence overlap with VT codes.
2. Then, return `priority_v{new_version}` as valid Python code. 
   All necessary logic, including helper functions, must be inside `priority_v{new_version}`. 
   Do not define helper functions separately. 