data/preview.md

# Dataset preview

Random sample of 6 examples (system prompt omitted for brevity).

## Example 1 — `switch_match` (c), 6 nodes

**User (input):**

```
1| const char* trim_value(int kind) {
2|   switch (kind) {
3|     case 0:
4|       return "first";
5|     case 1:
6|       return "second";
7|     case 2:
8|       return "third";
9|     default:
10|       return "other";
11|   }
12| }
```

**Assistant (target):**

```
<thinking>
1. Control structures: 1 decision point, 4 terminal branches.
2. Execution nodes in order: A Start: trim_value, B Which case applies?, C Return first label, D Return second label, E Return third label, F Return default label.
3. Source lines: A maps to line 1, B maps to line 2, C maps to line 4, D maps to line 6, E maps to line 8, F maps to line 10.
</thinking>
graph TD
    A[Start: trim_value]
    B{Which case applies?}
    C[Return first label]
    D[Return second label]
    E[Return third label]
    F[Return default label]
    A --> B
    B -- First case --> C
    B -- Second case --> D
    B -- Third case --> E
    B -- Default --> F
<linemap>
A: 1
B: 2
C: 4
D: 6
E: 8
F: 10
</linemap>
```

## Example 2 — `guard_return` (c), 4 nodes

**User (input):**

```
1| int aggregate(int found) {
2|   if (found) {
3|     return 0;
4|   }
5|   return 1;
6| }
```

**Assistant (target):**

```
<thinking>
1. Structural parse: 1 decision point, 2 terminal branches.
2. Execution nodes in order: A Start: aggregate, B Flag is set?, C Return false, D Return true.
3. Source lines: A maps to line 1, B maps to line 2, C maps to line 3, D maps to line 5.
</thinking>
graph TD
    A[Start: aggregate]
    B{Flag is set?}
    C[Return false]
    D[Return true]
    A --> B
    B -- True --> C
    B -- False --> D
<linemap>
A: 1
B: 2
C: 3
D: 5
</linemap>
```

## Example 3 — `dict_lookup` (javascript), 4 nodes

**User (input):**

```
1| function searchList(registry, field) {
2|   if (field in registry) {
3|     return registry[field];
4|   }
5|   return null;
6| }
```

**Assistant (target):**

```
<thinking>
1. Structural parse: 1 decision point, 2 terminal branches.
2. Nodes mapped chronologically: A Start: searchList, B Key exists in map?, C Return the mapped value, D Return nothing.
3. Source lines: A maps to line 1, B maps to line 2, C maps to line 3, D maps to line 5.
</thinking>
graph TD
    A[Start: searchList]
    B{Key exists in map?}
    C[Return the mapped value]
    D[Return nothing]
    A --> B
    B -- Found --> C
    B -- Missing --> D
<linemap>
A: 1
B: 2
C: 3
D: 5
</linemap>
```

## Example 4 — `try_except` (javascript), 4 nodes

**User (input):**

```
1| function formatName(line) {
2|   try {
3|     return parseInt(line);
4|   } catch (err) {
5|     return 0;
6|   }
7| }
```

**Assistant (target):**

```
<thinking>
1. Control structures: 1 decision point, 2 terminal branches.
2. Node sequence: A Start: formatName, B Conversion succeeds?, C Return the value, D Return zero.
3. Source lines: A maps to line 1, B maps to line 2, C maps to line 3, D maps to line 5.
</thinking>
graph TD
    A[Start: formatName]
    B{Conversion succeeds?}
    C[Return the value]
    D[Return zero]
    A --> B
    B -- Success --> C
    B -- Failure --> D
<linemap>
A: 1
B: 2
C: 3
D: 5
</linemap>
```

## Example 5 — `for_search` (javascript), 5 nodes

**User (input):**

```
1| function lookup(results, wanted) {
2|   for (let i = 0; i < results.length; i++) {
3|     if (results[i] === wanted) {
4|       return i;
5|     }
6|   }
7|   return -1;
8| }
```

**Assistant (target):**

```
<thinking>
1. Structural parse: 1 decision point, 1 loop, 2 terminal branches.
2. Execution nodes in order: A Start: lookup, B Iterate over collection, C Item matches target?, D Return the index, E Return not found.
3. Source lines: A is line 1, B is line 2, C is line 3, D is line 4, E is line 7.
</thinking>
graph TD
    A[Start: lookup]
    B[Iterate over collection]
    C{Item matches target?}
    D[Return the index]
    E[Return not found]
    A --> B
    B -- For each --> C
    B -- No more items --> E
    C -- Match --> D
    C -- No match --> B
<linemap>
A: 1
B: 2
C: 3
D: 4
E: 7
</linemap>
```

## Example 6 — `dict_lookup` (python), 4 nodes

**User (input):**

```
1| def lookup(mapping, user_id):
2|     if user_id in mapping:
3|         return mapping[user_id]
4|     return None
```

**Assistant (target):**

```
<thinking>
1. Structural parse: 1 decision point, 2 terminal branches.
2. Node sequence: A Start: lookup, B Key exists in map?, C Return the mapped value, D Return nothing.
3. Source lines: A maps to line 1, B maps to line 2, C maps to line 3, D maps to line 4.
</thinking>
graph TD
    A[Start: lookup]
    B{Key exists in map?}
    C[Return the mapped value]
    D[Return nothing]
    A --> B
    B -- Found --> C
    B -- Missing --> D
<linemap>
A: 1
B: 2
C: 3
D: 4
</linemap>
```