# Batch 5 -- closing the `Wait()` gap + compound-expression stress test

9 files. Same drill: Build each `.mbs` in RoborunPlus, export as `.hex` with
the same base name, save back in this folder.

Two different motivations behind this batch:

1. **`Wait()` was never tested in batches 1-4**, despite being used 2-3
   times in every one of your real pump-controller scripts. That's a real
   gap that needs closing before those real scripts can be used as
   end-to-end validation for the compiler.
2. **Every prior test isolated one construct at a time.** Real code
   combines them -- operator precedence across a multi-term expression,
   `ElseIf` chains, nested control flow, a function-call result feeding
   straight into arithmetic and a shift. None of that has been exercised
   yet, and it's exactly the kind of thing that could reveal a wrong
   assumption that isolated tests wouldn't catch.

## Files

- **`83_wait.mbs`** -- `Wait(500)` alone.
- **`84`/`85`/`86`** -- precedence and associativity: `z = x + y * 2`
  (does `*` bind tighter than `+`?), `z = (x + y) * 2` (does an explicit
  paren override that?), `z = x - y - 1` (left-associative, i.e. `(x-y)-1`
  not `x-(y-1)` -- these give different results so the byte sequence has to
  pick one).
- **`87_if_elseif_else.mbs`** -- a real 3-way branch, not just `If`/`Else`.
  Checks whether `ElseIf` chains reuse the same branch pattern per clause or
  do something structurally different.
- **`88_logical_precedence.mbs`** -- `If x=1 And y=1 Or Not z=1 Then...`,
  mixing `And`/`Or`/`Not` in one condition with no parens. The manual
  doesn't spell out precedence among these; this reveals whatever the real
  compiler actually does with it.
- **`89_nested_if_in_while.mbs`** -- an `If`/`Else` fully inside a `While`
  body, to check that nested branch/loop addressing still resolves
  correctly when the two aren't tested in isolation.
- **`90_expr_shift_getvalue.mbs`** -- `x = (getvalue(_VAR, 1) - y) >> 2`,
  modeled directly on real code from your scripts (e.g.
  `(getvalue(_AI,3) - pf) >> fs`). Function-call result -> arithmetic ->
  shift, all in one expression.
- **`91_mini_realistic.mbs`** -- a small but structurally complete version
  of your actual control-loop pattern: a `GoTo`-based loop with a labeled
  top, an `If`/`Else` inside it, `GetValue`/`SetCommand`, `Print`, and
  `Wait`, all together. This is the closest thing to a real script in the
  corpus so far, specifically to catch any address-computation surprise
  that only shows up when several constructs interact.