@portll/cobolwork 0.2.76 → 0.2.140

package/lib/control.mjs

@@ -20,6 +20,7 @@
 // entered holding no facts at all, which can only withhold credit. ALTER makes a GO TO reach every
 // paragraph, for the same reason.
 import { segmentEnd } from './parser.mjs';
+import { parser, attempt, candidates, leaves, storedRange } from './arith.mjs';
 
 const WORD = (t, u) => t && t.t === 'word' && t.u === u;
 const PHRASED = new Set(['READ', 'WRITE', 'REWRITE', 'DELETE', 'START', 'RETURN', 'CALL', 'COMPUTE', 'ADD', 'SUBTRACT',
@@ -28,6 +29,8 @@ const PHRASE_WORDS = new Set(['END', 'INVALID', 'EXCEPTION', 'OVERFLOW', 'END-OF
 // One copy of every node's facts. The analysis keeps a few, so this is a quarter of what it may use.
 const FACT_BUDGET_BYTES = 256 * 1024 * 1024;
 const SETTLE_BUDGET = 20 * 1000 * 1000;
+// Statements times fact words past which arithmetic intervals are not iterated.
+const ARITH_WORK = 40 * 1000 * 1000;
 // Routines whose only effect is to end the run with an abend.
 const ABEND_ROUTINE = /^(CEE3ABD|CEE3AB2|ILBOABN0|ILBOABN)$/i;
 
@@ -50,6 +53,8 @@ function meet(a, b) {
   if (a.set && b.set) out.set = new Set([...a.set].filter((v) => b.set.has(v)));
   else if (a.set || b.set) out.set = new Set(a.set || b.set);
   if (a.numeric || b.numeric) out.numeric = true;
+  if (!a.dep !== !b.dep) out.dep = a.dep || b.dep;
+  if (a.viaExpr && b.viaExpr) out.viaExpr = true;
   if (a.alpha || b.alpha) out.alpha = true;
   const lo = pick(a, b, 'lo', Math.max);
   const hi = pick(a, b, 'hi', Math.min);
@@ -67,9 +72,10 @@ function join(a, b) {
   if (a.set && b.set) out.set = new Set([...a.set, ...b.set]);
   if (a.numeric && b.numeric) out.numeric = true;
   if (a.alpha && b.alpha) out.alpha = true;
+  if (a.viaExpr || b.viaExpr) out.viaExpr = true;
   if (a.lo != null && b.lo != null) { out.lo = Math.min(a.lo, b.lo); out.loInc = a.lo === out.lo ? a.loInc : b.loInc; }
   if (a.hi != null && b.hi != null) { out.hi = Math.max(a.hi, b.hi); out.hiInc = a.hi === out.hi ? a.hiInc : b.hiInc; }
-  return Object.keys(out).length ? out : null;
+  return Object.keys(out).some((k) => k !== 'viaExpr') ? out : null;
 }
 // Whether a known value meets what a check's outcome says of its field.
 function satisfies(cons, v) {
@@ -99,6 +105,9 @@ function pick(a, b, k, better) {
   return v === av.v ? av : bv;
 }
 
+const INDEX_SINKS = new Set(['subscript', 'reference-modification', 'occurs-depending-count', 'loop-bound']);
+const atLeastOne = (cons) => cons.lo != null && (cons.lo >= 1 || (cons.lo >= 0 && !cons.loInc));
+
 // Whether a constraint makes a value safe for what the sink does with it. A value that can only be
 // one of a set of literals is safe everywhere. Digits alone cannot carry a command, a statement, a
 // script or a job, and are exactly what arithmetic needs. Letters and spaces cannot carry markup or a
@@ -109,12 +118,16 @@ export function stops(cons, sinkKind) {
   const allDigits = set && [...cons.set].every((v) => /^[+-]?\d+(\.\d+)?$/.test(v));
   switch (sinkKind) {
     case 'arithmetic': return cons.numeric === true || allDigits;
-    case 'subscript': case 'reference-modification': case 'occurs-depending-count': case 'loop-bound':
+    // A subscript and a reference-modification start count from 1, so 0 is out of range too; a
+    // count or a loop bound of 0 is not.
+    case 'subscript': case 'reference-modification':
+      return (cons.hi != null && atLeastOne(cons)) || (allDigits && [...cons.set].every((v) => Number(v) >= 1));
+    case 'occurs-depending-count': case 'loop-bound': case 'storage-length':
       return cons.hi != null || allDigits;
     case 'dynamic-sql': case 'internal-reader': return set || cons.numeric === true;
     case 'web-response': case 'http-header': case 'log': return set || cons.numeric === true || cons.alpha === true;
     case 'os-command': case 'dynamic-program-load': case 'cics-dynamic-transfer': case 'dynamic-file-path':
-    case 'queue-name': case 'outbound-host': return set;
+    case 'queue-name': case 'outbound-host': case 'connection-target': case 'cics-sysid': case 'cics-system-resource': return set;
     default: return false;
   }
 }
@@ -127,6 +140,8 @@ const SIGN = new Set(['POSITIVE', 'NEGATIVE', 'ZERO', 'ZEROS', 'ZEROES']);
 const FIGURATIVE = { SPACE: ' ', SPACES: ' ', ZERO: '0', ZEROS: '0', ZEROES: '0', 'LOW-VALUE': '\u0000', 'LOW-VALUES': '\u0000', 'HIGH-VALUE': 'ÿ', 'HIGH-VALUES': 'ÿ', QUOTE: '"', QUOTES: '"' };
 const NEGATE = { '=': '<>', '<>': '=', '>': '<=', '<=': '>', '<': '>=', '>=': '<' };
 const FLIP = { '=': '=', '<>': '<>', '>': '<', '<': '>', '>=': '<=', '<=': '>=' };
+// Past this an expression's intermediate value may not be held exactly, and no bound is drawn from it.
+const EXPR_LIMIT = 1e15;
 const RESTRICTING_OPS = new Set(['>', '<', '>=', '<=']);
 
 // A condition as a tree of AND, OR and NOT over atoms. It reads what COBOL writes - class and sign
@@ -233,6 +248,7 @@ export function parseCondition(toks, resolve) {
 export function buildControl(prog, resolve, { extra = null } = {}) {
   if (!prog.proc) return null;
   const { tokens, from, to } = prog.proc;
+  const loopBody = new Map();
   const stmtAt = new Map();
   for (const st of prog.statements) if (st.at != null && st.verb !== 'WHEN') stmtAt.set(st.at, st);
   const labelAt = new Map();
@@ -357,6 +373,10 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
         // A name that is neither a paragraph nor data nor a loop word is a paragraph the parse missed.
         if (first && first.t === 'word' && !stmtAt.has(st.at + 1) && !LOOP_START.has(first.u) && !/^\d+$/.test(first.v) && !resolve(first)) unknownLabel = true;
         const body = parseList(new Set([...stops, 'END-PERFORM']));
+        // Where an inline body lies in the tokens, and whether it can run code outside them.
+        let leaves = false;
+        for (let j = st.end; j < k; j++) if (isWord(j, 'GO') || (isWord(j, 'PERFORM') && tokens[j + 1] && tokens[j + 1].t === 'word' && labelNames.has(tokens[j + 1].u))) leaves = true;
+        loopBody.set(st, { from: st.at, to: k, leaves });
         if (isWord(k, 'END-PERFORM')) k++;
         return { k: 'inline', st, body, loop, testAfter };
       }
@@ -469,6 +489,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   const sectionEnd = new Map();
   for (const p of paras) if (p.section) sectionEnd.set(p.section, p.end);
   const tests = [];
+  const loopHeads = [];
 
   function lowerList(list, next, ctx) {
     let cont = next;
@@ -553,6 +574,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
         const body = n.k === 'perform' ? add('call', { st: n.st, range: rangeOf(n.target, n.thru), succ: [step] }) : lowerList(n.body, step, loopCtx);
         nodes[t].succ = [outcome(t, true, next), outcome(t, false, body)];
         nodes[head].succ = [n.testAfter ? body : t];
+        if (n.st.loops) loopHeads.push({ head, step, loops: n.st.loops, test: t, testAfter: n.testAfter, body: n.k === 'inline' ? n.body : null });
         return head;
       }
       case 'goto': {
@@ -601,6 +623,64 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     return top;
   };
   const fieldKey = (f) => (f.index ? `IX:${f.index}` : f);
+  const overlaps = (w, f) => {
+    if (w === f) return true;
+    if (w.index || f.index) return w.index && f.index && w.index === f.index;
+    if (w.level === 66 || f.level === 66) return true;
+    if (itemsInRecord(w) !== itemsInRecord(f)) return false;
+    if (w.offset == null || f.offset == null || w.size == null || f.size == null) return true;
+    const wEnd = w.offset + (w.contributes || w.size);
+    const fEnd = f.offset + (f.contributes || f.size);
+    return w.offset < fEnd && f.offset < wEnd;
+  };
+  const writtenBy = (n) => {
+    const out = [];
+    const add = (tok) => { const f = tok ? resolve(tok) : null; if (f) out.push(f.level === 88 && f.parent ? f.parent : f); };
+    if (n.st) {
+      for (const t of n.st.targets || []) add(t);
+      if (n.st.verb === 'CALL' || n.st.verb === 'READ' || n.st.verb === 'RETURN') {
+        // A callee may write what it is passed by reference, and a READ fills the file's records.
+        for (const t of n.st.sources || []) {
+          const f = resolve(t);
+          if (!f) continue;
+          if (f.records) for (const r of f.records) out.push(r);
+          else if (n.st.verb === 'CALL') out.push(f);
+        }
+      }
+    }
+    if (n.e && n.e.kind === 'SQL') {
+      // A statement fills the host variables of its INTO list and reads the rest.
+      const toks = n.e.toks;
+      const into = toks.findIndex((t) => WORD(t, 'INTO'));
+      if (into >= 0) {
+        for (let i = into + 1; i < toks.length && !WORD(toks[i], 'FROM'); i++) {
+          if (toks[i].t === 'op' && toks[i].v === ':' && toks[i + 1]) add(toks[i + 1]);
+        }
+      }
+    } else if (n.e) {
+      // A command may fill what any option is given directly, except what it sends FROM. A name
+      // inside that argument's own parentheses - a subscript, a reference modification - is read.
+      let depth = 0;
+      let option = null;
+      for (let i = 0; i < n.e.toks.length; i++) {
+        const t = n.e.toks[i];
+        if (t.t === 'sep') { depth += t.v === '(' ? 1 : -1; continue; }
+        if (depth === 0) { option = t.t === 'word' ? t.u : option; continue; }
+        if (depth === 1 && t.t === 'word' && option !== 'FROM') add(t);
+      }
+    }
+    return out;
+  };
+  // A VALUE holds for the whole run only if no statement writes storage that overlaps the item.
+  let writtenItems = null;
+  const neverWritten = (it) => {
+    if (it.external) return false;
+    if (!writtenItems) {
+      writtenItems = [];
+      for (const n of nodes) if (n.kind === 'stmt' || n.kind === 'exec' || n.kind === 'step' || n.kind === 'call') writtenItems.push(...writtenBy(n));
+    }
+    return !writtenItems.some((w) => overlaps(w, it));
+  };
   const constValue = (toks) => {
     if (toks.length === 3 && WORD(toks[0], 'LENGTH') && WORD(toks[1], 'OF')) {
       const it = resolve(toks[2]);
@@ -613,7 +693,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     if (t.t === 'word' && FIGURATIVE[t.u] != null) return FIGURATIVE[t.u];
     const it = resolve(t);
     // A level-78 constant, or a field with a VALUE that no statement writes, stands for its value.
-    if (it && !it.index && (it.level === 78 || it.constant || (!it.receiving && it.values && it.values.length === 1))) {
+    if (it && !it.index && (it.level === 78 || it.constant || (!it.receiving && it.values && it.values.length === 1 && neverWritten(it)))) {
       const v = it.values[0];
       if (v && v.t === 'lit') return String(v.v).trimEnd();
       if (v && (v.t === 'num' || /^[+-]?\d+(\.\d+)?$/.test(v.v))) return String(Number(v.v));
@@ -660,6 +740,157 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     if (range) return join(range, { set: new Set(vals) }) || null;
     return vals.length ? { set: new Set(vals) } : null;
   };
+  const pictureOf = (field) => String(field.picture || '').toUpperCase().replace(/(\w)\((\d+)\)/g, (_, ch, n) => ch.repeat(Number(n)));
+  const categories = new Map();
+  const categoryOf = (field) => {
+    if (categories.has(field)) return categories.get(field);
+    const usage = String(field.effectiveUsage || 'DISPLAY').replace('COMPUTATIONAL', 'COMP');
+    const pic = pictureOf(field);
+    const cat = (field.children || []).some((c) => c.level !== 88) ? { k: 'A' }
+      : /^[XA]+$/.test(pic) && usage === 'DISPLAY' ? { k: 'A' }
+        : /^S?9+(V9*)?$/.test(pic) && /^(DISPLAY|COMP|COMP-3|COMP-4|COMP-5|BINARY|PACKED-DECIMAL)$/.test(usage) ? { k: 'N', digits: pic.split('V')[0].replace(/[^9]/g, '').length }
+          : null;
+    categories.set(field, cat);
+    return cat;
+  };
+  // An unsigned whole number, for which "not zero" is "at least one".
+  const unsignedInteger = (field) => !!field && !field.index && categoryOf(field)?.k === 'N' && /^9+$/.test(pictureOf(field));
+  // What a numeric item's picture and storage allow: an unsigned item is not negative, a signed one
+  // has no known lower end, and a binary item may fill its bytes. Null for anything else.
+  const picRange = (f) => {
+    if (!f || f.index || f.level === 88 || f.level === 66 || categoryOf(f)?.k !== 'N') return null;
+    const pic = pictureOf(f);
+    let hi = 10 ** pic.split('V')[0].replace(/[^9]/g, '').length - (pic.includes('V') ? 0 : 1);
+    if (/^(COMP|COMP-4|COMP-5|BINARY)$/.test(String(f.effectiveUsage || '').replace('COMPUTATIONAL', 'COMP')) && f.size > 0) hi = Math.max(hi, 2 ** (8 * f.size) - 1);
+    return { lo: pic.startsWith('S') ? -Infinity : 0, hi };
+  };
+  const variableLength = (it) => !!it.dependingOn || (it.children || []).some(variableLength);
+  const linAdd = (a, b, sign) => {
+    if (!a || !b) return null;
+    const terms = new Map(a.terms);
+    for (const [f, c] of b.terms) { const n = (terms.get(f) || 0) + sign * c; if (n) terms.set(f, n); else terms.delete(f); }
+    const r = { terms, lo: a.lo + (sign > 0 ? b.lo : -b.hi), hi: a.hi + (sign > 0 ? b.hi : -b.lo) };
+    return Math.abs(r.lo) > EXPR_LIMIT || Math.abs(r.hi) > EXPR_LIMIT ? null : r;
+  };
+  // An arithmetic expression as `terms` (a coefficient per numeric field) plus a `lo`..`hi` interval
+  // for its constants, or null for what it cannot read exactly: division, a power, a product of two
+  // unknowns, a subscript, a non-numeric name, or a number past EXPR_LIMIT where the compiler's
+  // intermediate precision could give way.
+  const linearOf = (toks) => {
+    let i = 0;
+    const isOp = (v) => toks[i] && toks[i].t === 'op' && toks[i].v === v;
+    const isSep = (v) => toks[i] && toks[i].t === 'sep' && toks[i].v === v;
+    const constant = (n) => (Math.abs(n) > EXPR_LIMIT ? null : { terms: new Map(), lo: n, hi: n });
+    // LENGTH OF is the item's size, which a table that varies in length only bounds.
+    const sized = (tok) => {
+      const it = tok && tok.t === 'word' ? resolve(tok) : null;
+      if (!it || it.index || it.level === 88 || it.size == null || it.size > EXPR_LIMIT) return null;
+      return { terms: new Map(), lo: variableLength(it) ? 0 : it.size, hi: it.size };
+    };
+    const times = (a, b) => {
+      if (!a || !b) return null;
+      const scalar = (e) => (!e.terms.size && e.lo === e.hi ? e.lo : null);
+      const k = scalar(a) ?? scalar(b);
+      const e = scalar(a) != null ? b : a;
+      if (k == null && (a.terms.size || b.terms.size)) return null;
+      if (k == null) {
+        const ends = [a.lo * b.lo, a.lo * b.hi, a.hi * b.lo, a.hi * b.hi];
+        const r = { terms: new Map(), lo: Math.min(...ends), hi: Math.max(...ends) };
+        return Math.abs(r.lo) > EXPR_LIMIT || Math.abs(r.hi) > EXPR_LIMIT ? null : r;
+      }
+      const terms = new Map();
+      for (const [f, c] of e.terms) if (c * k) terms.set(f, c * k);
+      const ends = [e.lo * k, e.hi * k];
+      const r = { terms, lo: Math.min(...ends), hi: Math.max(...ends) };
+      return Math.abs(r.lo) > EXPR_LIMIT || Math.abs(r.hi) > EXPR_LIMIT ? null : r;
+    };
+    const primary = () => {
+      const t = toks[i];
+      if (!t) return null;
+      if (isSep('(')) {
+        i++;
+        const e = sum();
+        if (!isSep(')')) return null;
+        i++;
+        return e;
+      }
+      if (t.t !== 'word' && t.t !== 'num') return null;
+      if (WORD(t, 'LENGTH') && WORD(toks[i + 1], 'OF')) { const e = sized(toks[i + 2]); i += 3; return e; }
+      if (WORD(t, 'FUNCTION') && WORD(toks[i + 1], 'LENGTH') && toks[i + 2] && toks[i + 2].v === '(') {
+        const e = sized(toks[i + 3]);
+        if (!toks[i + 4] || toks[i + 4].v !== ')') return null;
+        i += 5;
+        return e;
+      }
+      i++;
+      while ((WORD(toks[i], 'OF') || WORD(toks[i], 'IN')) && toks[i + 1] && toks[i + 1].t === 'word') i += 2;
+      if (isSep('(')) return null;
+      const n = numberOf(constValue([t]));
+      if (n != null) return constant(n);
+      const f = t.t === 'word' ? resolve(t) : null;
+      return picRange(f) ? { terms: new Map([[f, 1]]), lo: 0, hi: 0 } : null;
+    };
+    const factor = () => {
+      if (isOp('-')) { i++; return times(constant(-1), primary()); }
+      if (isOp('+')) i++;
+      return primary();
+    };
+    const product = () => {
+      let e = factor();
+      while (e && isOp('*')) { i++; e = times(e, factor()); }
+      return e;
+    };
+    function sum() {
+      let e = product();
+      while (e && (isOp('+') || isOp('-'))) { const sign = toks[i].v === '+' ? 1 : -1; i++; e = linAdd(e, product(), sign); }
+      return e;
+    }
+    const e = sum();
+    return e && i === toks.length ? e : null;
+  };
+  // What `left op right` says of each field in it that has coefficient 1 or -1, from the rest of the
+  // expression: X + Y <= K gives X <= K - Y, and Y unsigned gives X <= K. The other operand counts by
+  // what its picture rules out (a sign) and by constants alone; a bound it has only from checks is
+  // left as `dep`, for the second pass to join to those checks. Only what narrows the field is kept.
+  const exprCons = (left, op, right) => {
+    const l = linearOf(left), r = linearOf(right);
+    const e = l && r ? linAdd(l, r, -1) : null;
+    const out = new Map();
+    if (!e || !['<', '<=', '>', '>='].includes(op)) return out;
+    const upper = op === '<' || op === '<=';
+    const inc = op === '<=' || op === '>=';
+    for (const [x, c] of e.terms) {
+      if (Math.abs(c) !== 1) continue;
+      const own = picRange(x);
+      // c*x + sum(d*g) + R op 0, R in [e.lo, e.hi]: x is on the `side` of the sum of m*g, plus b.
+      const side = upper === (c > 0) ? 'hi' : 'lo';
+      const b = -c * (upper ? e.lo : e.hi);
+      const open = [];
+      const soft = [];
+      for (const [g, d] of e.terms) {
+        if (g === x) continue;
+        const m = -c * d;
+        const needs = side === 'hi' ? (m > 0 ? 'hi' : 'lo') : (m > 0 ? 'lo' : 'hi');
+        if (!(needs === 'lo' && picRange(g).lo === 0)) open.push({ g, m, needs }); else soft.push({ g, m, needs });
+      }
+      if (open.length > 1) continue;
+      const c1 = { viaExpr: true };
+      // An operand whose picture gives 0 for its low end may have a higher one from a check: the picture's bound stands, and the check's tightens it.
+      if (!open.length) {
+        c1[side] = b; c1[`${side}Inc`] = inc;
+        if (soft.length === 1) c1.dep = { g: soft[0].g, m: soft[0].m, needs: soft[0].needs, side, b, inc };
+      } else c1.dep = { g: open[0].g, m: open[0].m, needs: open[0].needs, side, b, inc };
+      const narrows = c1[side] != null && (side === 'hi' ? c1.hi < own.hi || (c1.hi === own.hi && !inc) : c1.lo > own.lo || (c1.lo === own.lo && !inc));
+      if (narrows || c1.dep) out.set(fieldKey(x), c1);
+    }
+    return out;
+  };
+  // A constraint without its `dep`, or null where nothing else is left.
+  const plainCons = (c) => {
+    if (!c || !c.dep) return c || null;
+    const { dep, ...rest } = c;
+    return Object.keys(rest).some((k) => k !== 'viaExpr') ? rest : null;
+  };
   // What a condition says each field holds when it is `outcome`, and which fields it tests.
   function consOf(tree, outcome) {
     switch (tree.k) {
@@ -674,7 +905,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       case 'sign': {
         const f = fieldOf(tree.subject);
         if (!f) return new Map();
-        const c = tree.sign === 'ZERO' ? (outcome ? { set: new Set(['0']) } : null)
+        const c = tree.sign === 'ZERO' ? (outcome ? { set: new Set(['0']) } : unsignedInteger(f) ? { lo: 1, loInc: true } : null)
           : tree.sign === 'POSITIVE' ? (outcome ? { lo: 0, loInc: false } : { hi: 0, hiInc: true })
             : (outcome ? { hi: 0, hiInc: false } : { lo: 0, loInc: true });
         return c ? new Map([[fieldKey(f), c]]) : new Map();
@@ -686,9 +917,10 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
         if (!f || v == null) {
           const g = fieldOf(tree.right);
           const w = constValue(tree.left);
-          if (g && w != null) { f = g; v = w; op = FLIP[op]; } else return new Map();
+          if (g && w != null) { f = g; v = w; op = FLIP[op]; } else return exprCons(tree.left, outcome ? tree.op : NEGATE[tree.op], tree.right);
         }
-        const c = relCons(outcome ? op : NEGATE[op], v);
+        const eff = outcome ? op : NEGATE[op];
+        const c = eff === '<>' && numberOf(v) === 0 && unsignedInteger(f) ? { lo: 1, loInc: true } : relCons(eff, v);
         return c ? new Map([[fieldKey(f), c]]) : new Map();
       }
       case 'cond': {
@@ -787,7 +1019,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     for (const key of keys) {
       const field = restricts.get(key) || (typeof key === 'string' ? { index: key.slice(3) } : key);
       noteField(key, field);
-      const c = { id: checks.length, key, field, file: where.file, line: where.line, tCons: whenTrue.get(key) || null, fCons: whenFalse.get(key) || null, restricts: restricts.has(key) };
+      const c = { id: checks.length, key, field, file: where.file, line: where.line, test: id, tCons: plainCons(whenTrue.get(key)), fCons: plainCons(whenFalse.get(key)), tDep: whenTrue.get(key)?.dep || null, fDep: whenFalse.get(key)?.dep || null, restricts: restricts.has(key) };
       checks.push(c);
       mine.push(c);
     }
@@ -835,6 +1067,25 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     a.c = { id: checks.length, key, field: a.field, file: a.n.st.file, line: a.n.st.line, tCons: { set: new Set([a.value]) }, fCons: null, restricts: false, assigned: true };
     checks.push(a.c);
   }
+  // One fact per distinct constant v moved into a whole number: "it holds a constant from 1 to v", set by every MOVE of one that small, so it survives a join only where every route moved one.
+  const moved = new Map();
+  for (const a of assigns) {
+    const cat = a.field.level === 88 ? null : categoryOf(a.field);
+    const v = numberOf(a.value);
+    if (!cat || cat.k !== 'N' || v == null || !Number.isInteger(v) || v < 1 || String(v).length > cat.digits) continue;
+    if (!moved.has(a.field)) moved.set(a.field, []);
+    moved.get(a.field).push(a);
+  }
+  for (const [field, list] of moved) {
+    const key = fieldKey(field);
+    noteField(key, field);
+    for (const hi of new Set(list.map((a) => Number(a.value)))) {
+      const bounds = { lo: 1, hi };
+      const c = { id: checks.length, key, field, file: list[0].n.st.file, line: list[0].n.st.line, tCons: { numeric: true, lo: 1, loInc: true, hi, hiInc: true }, fCons: null, restricts: false, assigned: true, bounds };
+      checks.push(c);
+      for (const a of list) if (Number(a.value) <= hi) (a.upTo ||= []).push(c);
+    }
+  }
   // Fact numbers: for each check, `x` that it ran (only a restricting one), `t` and `f` that it came
   // out true or false with something to say about its field.
   let nFacts = 0;
@@ -842,6 +1093,8 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     c.x = c.restricts ? nFacts++ : null;
     c.t = c.tCons ? nFacts++ : null;
     c.f = c.fCons ? nFacts++ : null;
+    c.rt = c.tDep ? nFacts++ : null;
+    c.rf = c.fDep ? nFacts++ : null;
   }
   for (const id of tests) {
     const n = nodes[id];
@@ -849,6 +1102,8 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       if (c.x != null) { n.gen.true.push(c.x); n.gen.false.push(c.x); }
       if (c.t != null) n.gen.true.push(c.t);
       if (c.f != null) n.gen.false.push(c.f);
+      if (c.rt != null) n.gen.true.push(c.rt);
+      if (c.rf != null) n.gen.false.push(c.rf);
     }
   }
   // A constant also makes true every outcome it satisfies of a check on the same field, so a length
@@ -865,6 +1120,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   for (const a of assigns) {
     const gen = (a.n.genStmt ||= []);
     gen.push(a.c.t);
+    for (const c of a.upTo || []) gen.push(c.t);
     for (const c of checksOf.get(a.c.key) || []) {
       if (c.t != null && satisfies(c.tCons, a.value)) gen.push(c.t);
       if (c.f != null && satisfies(c.fCons, a.value)) gen.push(c.f);
@@ -896,6 +1152,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     return it && !it.index && it.level !== 88 && it.size != null ? it.size : null;
   };
   const writesRecordOf = (st, item) => (st.targets || []).some((t) => { const it = resolve(t); return it && !it.index && itemsInRecord(it) === itemsInRecord(item); });
+  const tallies = [];
   const tallyIn = (seq) => {
     for (let j = 0; j < seq.length; j++) {
       const el = seq[j];
@@ -921,6 +1178,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
             const bounds = { lo: start, hi: start + size };
             const c = { id: checks.length, key, field: count, file: el.st.file, line: el.st.line, tCons: { numeric: true, lo: bounds.lo, loInc: true, hi: bounds.hi, hiInc: true }, fCons: null, restricts: false, x: null, t: nFacts++, f: null, bounds };
             checks.push(c);
+            tallies.push(c);
             (n.genStmt ||= []).push(c.t);
           }
           break;
@@ -950,19 +1208,6 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   // A flag's values are compared only where nothing but the literal decides the comparison: an
   // alphanumeric literal against an alphanumeric item, which a value it is given must fill so that
   // JUSTIFIED cannot move it, and an integer against a numeric item with room for its digits.
-  const pictureOf = (field) => String(field.picture || '').toUpperCase().replace(/(\w)\((\d+)\)/g, (_, ch, n) => ch.repeat(Number(n)));
-  const categories = new Map();
-  const categoryOf = (field) => {
-    if (categories.has(field)) return categories.get(field);
-    const usage = String(field.effectiveUsage || 'DISPLAY').replace('COMPUTATIONAL', 'COMP');
-    const pic = pictureOf(field);
-    const cat = (field.children || []).some((c) => c.level !== 88) ? { k: 'A' }
-      : /^[XA]+$/.test(pic) && usage === 'DISPLAY' ? { k: 'A' }
-        : /^S?9+(V9*)?$/.test(pic) && /^(DISPLAY|COMP|COMP-3|COMP-4|COMP-5|BINARY|PACKED-DECIMAL)$/.test(usage) ? { k: 'N', digits: pic.split('V')[0].replace(/[^9]/g, '').length }
-          : null;
-    categories.set(field, cat);
-    return cat;
-  };
   const plainLiteral = (tok) => tok && tok.t === 'lit' && !tok.prefix;
   const integerOf = (tok) => (tok && (tok.t === 'num' || tok.t === 'word') && /^\d+$/.test(tok.v) ? tok.v : null);
   const heldAs = (field, tok) => {
@@ -980,7 +1225,15 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     return digits != null ? `N:${Number(digits)}` : null;
   };
   const heldBy = new Map();
-  const held = (a) => { if (!heldBy.has(a)) heldBy.set(a, heldAs(a.field, a.tok)); return heldBy.get(a); };
+  // A flag moved from a constant item holds that item's value, when the item fills the flag exactly.
+  const heldTok = (a) => {
+    const t = a.tok;
+    if (!t || t.t !== 'word' || /^\d+$/.test(t.v)) return t;
+    const src = resolve(t);
+    if (!src || src.index || (src.level !== 78 && src.size !== a.field.size)) return t;
+    return { t: 'lit', v: a.value };
+  };
+  const held = (a) => { if (!heldBy.has(a)) heldBy.set(a, heldAs(a.field, heldTok(a))); return heldBy.get(a); };
   const flagFields = (tree, out = new Set()) => {
     if (tree.k === 'not') flagFields(tree.a, out);
     else if (tree.k === 'and' || tree.k === 'or') { flagFields(tree.a, out); flagFields(tree.b, out); }
@@ -1074,6 +1327,733 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       }
     }
   }
+  // A lower bound survives an increment. A field set to a constant of 1 or more, or varied from one,
+  // stays at 1 or more through ADD, SET UP BY, COMPUTE X = X + n and a VARYING step, where n is
+  // never negative. The upper bound is lost, and the lower bound survives only where the sum cannot
+  // wrap past the field's capacity to a small number: an upper bound live before the increment that
+  // leaves room for n, or ON SIZE ERROR, which leaves the field as it was. Any other write kills it.
+  const intCap = (f) => {
+    if (!f || f.index || f.level === 88 || inTable(f)) return null;
+    const cat = categoryOf(f);
+    return cat && cat.k === 'N' && /^S?9+$/.test(pictureOf(f)) ? 10 ** cat.digits - 1 : null;
+  };
+  // The most a token can add: a literal or constant that is not negative, or an unsigned number.
+  const addend = (tok) => {
+    if (!tok || (tok.t !== 'word' && tok.t !== 'num')) return null;
+    const v = numberOf(constValue([tok]));
+    if (v != null) return v >= 0 ? Math.ceil(v) : null;
+    const f = tok.t === 'word' ? resolve(tok) : null;
+    const cat = f && !f.index && f.level !== 88 && !inTable(f) ? categoryOf(f) : null;
+    return cat && cat.k === 'N' && /^9+(V9*)?$/.test(pictureOf(f)) ? 10 ** cat.digits : null;
+  };
+  // The least a token adds: its value where it is a constant, else nothing.
+  const least = (tok) => { const v = numberOf(constValue([tok])); return v != null && v > 0 ? Math.floor(v) : 0; };
+  const PHRASE_AT = (t) => WORD(t, 'ON') || WORD(t, 'NOT') || WORD(t, 'SIZE') || (t.t === 'word' && t.u.startsWith('END-'));
+  const sizeErrorGuarded = (seg) => seg.some((t, i) => WORD(t, 'SIZE') && WORD(seg[i + 1], 'ERROR') && !WORD(seg[i - 1], 'NOT'));
+  // The fields a statement only ever raises, and by how much at most.
+  const increments = (st) => {
+    const seg = segOf(st);
+    let max = 0;
+    let min = 0;
+    let fields = [];
+    if (st.verb === 'ADD') {
+      const to = seg.findIndex((t) => WORD(t, 'TO'));
+      if (to < 1 || seg.some((t) => WORD(t, 'GIVING') || WORD(t, 'CORRESPONDING') || WORD(t, 'CORR'))) return null;
+      for (const t of seg.slice(0, to)) { const m = addend(t); if (m == null) return null; max += m; min += least(t); }
+      const end = seg.findIndex((t, i) => i > to && PHRASE_AT(t));
+      if (seg.slice(to + 1, end < 0 ? seg.length : end).some((t) => t.t === 'sep')) return null;
+      fields = (st.targets || []).map((t) => resolve(t));
+    } else if (st.verb === 'SET') {
+      const up = seg.findIndex((t) => WORD(t, 'UP'));
+      if (up < 1 || !WORD(seg[up + 1], 'BY') || seg.length !== up + 3 || seg.slice(0, up).some((t) => t.t !== 'word')) return null;
+      max = addend(seg[up + 2]);
+      if (max == null) return null;
+      min = least(seg[up + 2]);
+      fields = (st.targets || []).map((t) => resolve(t));
+    } else if (st.verb === 'COMPUTE') {
+      const eq = seg.findIndex((t) => t.t === 'op' && t.v === '=');
+      const lhs = seg.slice(0, eq).filter((t) => !WORD(t, 'ROUNDED'));
+      if (eq < 1 || lhs.length !== 1 || lhs[0].t !== 'word') return null;
+      const target = resolve(lhs[0]);
+      const end = seg.findIndex((t, i) => i > eq && PHRASE_AT(t));
+      const parts = [[]];
+      for (const t of seg.slice(eq + 1, end < 0 ? seg.length : end)) { if (t.t === 'op' && t.v === '+') parts.push([]); else parts[parts.length - 1].push(t); }
+      if (parts.length < 2 || parts.some((p) => p.length !== 1)) return null;
+      const self = parts.filter((p) => p[0].t === 'word' && resolve(p[0]) === target);
+      if (self.length !== 1) return null;
+      for (const p of parts) { if (p === self[0]) continue; const m = addend(p[0]); if (m == null) return null; max += m; min += least(p[0]); }
+      fields = [target];
+    } else return null;
+    fields = [...new Set(fields.filter((f) => intCap(f) != null))];
+    return fields.length ? { fields, max, min, sizeError: sizeErrorGuarded(seg) } : null;
+  };
+  // Facts of the form "at least k", one per field and k so that routes which reach it by different
+  // statements agree. They are kept apart because an increment does not kill them.
+  const loOf = new Map();
+  const newLo = (field, lo, at) => {
+    const key = fieldKey(field);
+    const had = (loOf.get(field) || []).find((c) => c.tCons.lo === lo);
+    if (had) return had;
+    noteField(key, field);
+    const c = { id: checks.length, key, field, file: at.file, line: at.line, tCons: { lo, loInc: true }, fCons: null, restricts: false, x: null, t: nFacts++, f: null, mono: true };
+    checks.push(c);
+    if (!loOf.has(field)) loOf.set(field, []);
+    loOf.get(field).push(c);
+    return c;
+  };
+  // A field an increment by at least 1 raises can start from 0: the bound it reaches is 1 or more.
+  const raisers = new Map();
+  const raised = new Set();
+  nodes.forEach((n, id) => {
+    if (n.kind !== 'stmt' || !n.st || n.st.at == null) return;
+    const inc = increments(n.st);
+    if (!inc || inc.min < 1 || inc.sizeError) return;
+    raisers.set(id, inc);
+    for (const f of inc.fields) raised.add(f);
+  });
+  for (const a of assigns) {
+    const v = numberOf(a.value);
+    const cap = intCap(a.field);
+    if (cap == null || v == null || !Number.isInteger(v) || v < (raised.has(a.field) ? 0 : 1) || v > cap) continue;
+    if ((a.n.st.targets || []).some((t) => { const o = resolve(t); return o && o !== a.field && overlaps(o, a.field); })) continue;
+    (a.n.genStmt ||= []).push(newLo(a.field, v, a.n.st).t);
+  }
+  // An increment by at least m turns "at least k" into "at least k + m", where the sum fits the field.
+  const lifted = new Map();
+  for (const [id, inc] of raisers) {
+    const list = [];
+    for (const field of inc.fields) {
+      const pairs = [];
+      for (const c of [...(loOf.get(field) || []), ...tallies.filter((t) => t.field === field)]) {
+        const lo = c.tCons.lo + inc.min;
+        if (lo < 1) continue;
+        if (lo <= intCap(field)) pairs.push([c.t, newLo(field, lo, nodes[id].st).t]);
+      }
+      if (pairs.length) list.push({ field, max: inc.max, pairs });
+    }
+    if (list.length) lifted.set(id, list);
+  }
+  // A VARYING counter is at least what it starts at inside the loop: a constant FROM sets it at the
+  // head, and a FROM naming a field that is at least k sets it to k, where that field held it.
+  const stepped = new Map();
+  const derived = new Map();
+  for (let more = true; more;) {
+    more = false;
+    for (const { head, step, loops } of loopHeads) {
+      loops.forEach((loop, idx) => {
+        const field = loop.counter ? resolve(loop.counter) : null;
+        const cap = intCap(field);
+        const by = loop.by ? (loop.by.length === 1 ? addend(loop.by[0]) : null) : 1;
+        if (cap == null || by == null) return;
+        const at = { file: loop.counter.file, line: loop.counter.line };
+        const from = numberOf(constValue(loop.from || []));
+        if (from != null) {
+          const key = `${head}|${idx}`;
+          if (derived.has(key) || !Number.isInteger(from) || from < 1 || from > cap) return;
+          const c = newLo(field, from, at);
+          derived.set(key, c);
+          nodes[head].genStmt = [...(nodes[head].genStmt || []), c.t];
+          if (idx === 0) stepped.set(step, { field, max: by });
+          else if (!loop.until.some((t) => { const v = numberOf(constValue([t])); return v != null && v >= cap; })) nodes[step].genStmt = [...(nodes[step].genStmt || []), c.t];
+          more = true;
+          return;
+        }
+        const src = idx === 0 && loop.from && loop.from.length === 1 && loop.from[0].t === 'word' ? resolve(loop.from[0]) : null;
+        const srcCap = intCap(src);
+        if (srcCap == null || srcCap > cap) return;
+        for (const c of loOf.get(src) || []) {
+          const key = `${head}|${idx}|${c.tCons.lo}`;
+          let d = derived.get(key);
+          if (!d) {
+            d = newLo(field, c.tCons.lo, at);
+            derived.set(key, d);
+            stepped.set(step, { field, max: by });
+            more = true;
+          }
+          const pair = `${head}|${c.t}>${d.t}`;
+          if (derived.has(pair)) continue;
+          derived.set(pair, true);
+          (nodes[head].implies ||= []).push([c.t, d.t, true]);
+          more = true;
+        }
+      });
+    }
+  }
+
+  // A bound an expression gives a field through another field, X <= G + 1, is a bound only where a
+  // check has bounded G: "X <= G + 1 held" and "G <= 100 held" together give X <= 101. The first
+  // fact dies with a write to X or G, the second with a write to G, and the result with a write to X,
+  // so the pair is joined at whichever of the two checks comes last.
+  const outcomeAt = new Map();
+  for (const node of nodes) if (node.kind === 'outcome') outcomeAt.set(`${node.test}|${node.value}`, node);
+  // A backward scan for the last byte past the spaces, VARYING I FROM the field's length BY -1 UNTIL
+  // I < 1 OR F(I:1) > SPACE, leaves I from 1 to that length where F > SPACES held as it began: a
+  // field that compares above spaces has a byte above a space, under any collating sequence, and the
+  // scan meets it before 0. The witness dies with a write to F or to anything its subscript reads.
+  const keptOnStep = new Map();
+  const isSpaces = (toks) => toks.length === 1 && (WORD(toks[0], 'SPACE') || WORD(toks[0], 'SPACES') || (toks[0].t === 'lit' && !toks[0].prefix && /^ +$/.test(String(toks[0].v))));
+  const textOf = (toks) => toks.map((t) => (t.t === 'word' ? t.u : String(t.v))).join(' ');
+  // A whole alphanumeric item or table element, with the fields its subscript reads.
+  const scanned = (toks) => {
+    const base = toks[0] && toks[0].t === 'word' ? resolve(toks[0]) : null;
+    if (!base || base.index || base.level === 88 || base.size == null || categoryOf(base)?.k !== 'A' || variableLength(base)) return null;
+    let i = 1;
+    while (i + 1 < toks.length && (WORD(toks[i], 'OF') || WORD(toks[i], 'IN')) && toks[i + 1].t === 'word') i += 2;
+    const reads = [];
+    if (i < toks.length) {
+      if (toks[i].v !== '(' || toks[toks.length - 1].v !== ')') return null;
+      let depth = 0;
+      for (let j = i; j < toks.length; j++) {
+        const t = toks[j];
+        if (t.v === ':') return null;
+        if (t.v === '(' || t.v === ')') { depth += t.v === '(' ? 1 : -1; if (!depth && j < toks.length - 1) return null; continue; }
+        const f = t.t === 'word' ? resolve(t) : null;
+        if (f) reads.push(f.level === 88 && f.parent ? f.parent : f);
+      }
+    }
+    return { base, reads };
+  };
+  // What an outcome says is above spaces (`above`) or only not all spaces.
+  const notBlank = (tree, outcome, out = []) => {
+    if (tree.k === 'not') return notBlank(tree.a, !outcome, out);
+    if ((tree.k === 'and' && outcome) || (tree.k === 'or' && !outcome)) { notBlank(tree.a, outcome, out); notBlank(tree.b, outcome, out); return out; }
+    if (tree.k !== 'rel') return out;
+    const op = outcome ? tree.op : NEGATE[tree.op];
+    if (isSpaces(tree.right) && (op === '>' || op === '<>')) out.push({ toks: tree.left, above: op === '>' });
+    else if (isSpaces(tree.left) && (op === '<' || op === '<>')) out.push({ toks: tree.right, above: op === '<' });
+    return out;
+  };
+  const scans = [];
+  for (const { head, step, test, testAfter, body, loops } of loopHeads) {
+    if (testAfter || !body || loops.length !== 1 || !body.every((el) => el.k === 'stmt' && el.st.verb === 'CONTINUE')) continue;
+    const loop = loops[0];
+    const counter = loop.counter ? resolve(loop.counter) : null;
+    const cap = intCap(counter);
+    const tree = nodes[test].tree;
+    if (cap == null || !tree || tree.k !== 'or' || !loop.by || loop.by.map((t) => t.v).join('') !== '-1') continue;
+    const from = loop.from || [];
+    let start = numberOf(constValue(from));
+    if (start == null && WORD(from[0], 'LENGTH') && WORD(from[1], 'OF')) start = scanned(from.slice(2))?.base.size ?? null;
+    if (start == null || !Number.isInteger(start) || start < 1 || start > cap) continue;
+    const isCounter = (toks) => toks.length === 1 && toks[0].t === 'word' && resolve(toks[0]) === counter;
+    const done = (r) => r.k === 'rel' && isCounter(r.left) && (r.op === '<' ? numberOf(constValue(r.right)) === 1 : (r.op === '<=' || r.op === '=') && numberOf(constValue(r.right)) === 0);
+    const probe = (r) => {
+      if (r.k !== 'rel') return null;
+      const [el, op] = isSpaces(r.right) ? [r.left, r.op] : isSpaces(r.left) ? [r.right, FLIP[r.op]] : [null, null];
+      if (!el || (op !== '>' && op !== '<>') || el.length < 6) return null;
+      const tail = el.slice(-5);
+      if (tail[0].v !== '(' || !isCounter([tail[1]]) || tail[2].v !== ':' || numberOf(constValue([tail[3]])) !== 1 || tail[4].v !== ')') return null;
+      const toks = el.slice(0, -5);
+      const s = scanned(toks);
+      return s && s.base.size === start ? { toks, above: op === '>' } : null;
+    };
+    const p = done(tree.a) ? probe(tree.b) : done(tree.b) ? probe(tree.a) : null;
+    const exit = p && outcomeAt.get(`${test}|true`);
+    if (exit) scans.push({ ...p, counter, start, exit, head, step, at: loop.counter });
+  }
+  // The scan's counter never passes its start: the step runs only once I < 1 has failed, so it
+  // cannot wrap, and the body writes nothing.
+  for (const s of scans) {
+    const key = fieldKey(s.counter);
+    noteField(key, s.counter);
+    const h = { id: checks.length, key, field: s.counter, file: s.at.file, line: s.at.line, tCons: { hi: s.start, hiInc: true }, fCons: null, restricts: false, x: null, t: nFacts++, f: null };
+    checks.push(h);
+    nodes[s.head].genStmt = [...(nodes[s.head].genStmt || []), h.t];
+    keptOnStep.set(s.step, [...(keptOnStep.get(s.step) || []), h.t]);
+  }
+  if (scans.length) {
+    const witness = new Map();
+    const bitFor = (toks, above) => {
+      const k = `${above ? '>' : '<>'}|${textOf(toks)}`;
+      if (witness.has(k)) return witness.get(k);
+      const s = scanned(toks);
+      const bit = nFacts++;
+      for (const f of [s.base, ...s.reads]) {
+        const key = fieldKey(f);
+        noteField(key, f);
+        checks.push({ pseudo: true, key, field: f, x: null, t: bit, f: null });
+      }
+      witness.set(k, bit);
+      return bit;
+    };
+    const wanted = new Set(scans.map((s) => textOf(s.toks)));
+    for (const id of tests) {
+      const n = nodes[id];
+      if (!n.tree) continue;
+      for (const outcome of [true, false]) {
+        for (const nb of notBlank(n.tree, outcome)) {
+          if (!wanted.has(textOf(nb.toks)) || !scanned(nb.toks)) continue;
+          n.gen[String(outcome)].push(bitFor(nb.toks, false));
+          if (nb.above) n.gen[String(outcome)].push(bitFor(nb.toks, true));
+        }
+      }
+    }
+    for (const s of scans) {
+      const bit = witness.get(`${s.above ? '>' : '<>'}|${textOf(s.toks)}`);
+      if (bit == null) continue;
+      const key = fieldKey(s.counter);
+      noteField(key, s.counter);
+      const y = { id: checks.length, key, field: s.counter, file: s.at.file, line: s.at.line, tCons: { numeric: true, lo: 1, loInc: true, hi: s.start, hiInc: true }, fCons: null, restricts: false, x: null, t: nFacts++, f: null, bounds: { lo: 1, hi: s.start } };
+      checks.push(y);
+      (s.exit.implies ||= []).push([bit, y.t]);
+    }
+  }
+  const MAX_BOUNDS_PER_RELATION = 8;
+  for (const c of [...checks]) {
+    if (c.pseudo || c.test == null) continue;
+    for (const outcome of [true, false]) {
+      const bit = outcome ? c.rt : c.rf;
+      const dep = bit != null ? (outcome ? c.tDep : c.fDep) : null;
+      if (!dep) continue;
+      const gKey = fieldKey(dep.g);
+      const bounds = [];
+      for (const u of checks) {
+        if (u.pseudo || u.key !== gKey || u.bounds || u.assigned || u === c) continue;
+        for (const [ubit, ucons, uoutcome] of [[u.t, u.tCons, true], [u.f, u.fCons, false]]) {
+          if (ubit == null || !ucons || ucons.dep) continue;
+          const r = asRange(ucons);
+          const gv = dep.needs === 'hi' ? r.hi : r.lo;
+          if (gv == null) continue;
+          const value = dep.m * gv + dep.b;
+          if (!Number.isFinite(value) || Math.abs(value) > EXPR_LIMIT) continue;
+          bounds.push({ u, ubit, uoutcome, value, inc: dep.inc && r[`${dep.needs}Inc`] !== false });
+        }
+      }
+      if (!bounds.length || bounds.length > MAX_BOUNDS_PER_RELATION) continue;
+      noteField(gKey, dep.g);
+      checks.push({ pseudo: true, key: gKey, field: dep.g, x: null, t: bit, f: null });
+      for (const { u, ubit, uoutcome, value, inc } of bounds) {
+        const y = { id: checks.length, key: c.key, field: c.field, file: c.file, line: c.line, tCons: { [dep.side]: value, [`${dep.side}Inc`]: inc }, fCons: null, restricts: false, x: null, t: nFacts++, f: null };
+        checks.push(y);
+        const here = outcomeAt.get(`${c.test}|${outcome}`);
+        if (here) (here.implies ||= []).push([ubit, y.t]);
+        const there = u.test != null ? outcomeAt.get(`${u.test}|${uoutcome}`) : null;
+        if (there) (there.implies ||= []).push([bit, y.t]);
+      }
+    }
+  }
+
+  // ---- what an arithmetic statement leaves in an integer field ----
+  // COMPUTE, ADD, SUBTRACT, MULTIPLY, DIVIDE and a MOVE of a field or function leave the receiving
+  // field inside an interval worked out from what each operand can hold: its picture, the facts that
+  // hold at the statement, the length of an item. The interval is a fact only where the result fits
+  // the receiving field, so nothing was lost to truncation or overflow, and where no divisor can be
+  // zero. Whatever the statement's operands needed to hold is what the fact needs to hold.
+  const BINARY_USAGE = /^(COMP|COMP-4|COMP-5|BINARY)$/;
+  const rangesOf = new Map();
+  // The whole numbers an integer field can hold when read, and those a result may take to be stored whole.
+  const rangeOfField = (f) => {
+    if (!f || f.index || f.level === 88) return null;
+    if (rangesOf.has(f)) return rangesOf.get(f);
+    let out = null;
+    const cat = categoryOf(f);
+    const pic = pictureOf(f);
+    if (cat && cat.k === 'N' && /^S?9+$/.test(pic)) {
+      const D = 10n ** BigInt(cat.digits) - 1n;
+      const signed = pic[0] === 'S';
+      const digits = { lo: signed ? -D : 0n, hi: D };
+      out = { hold: digits, fit: digits };
+      if (BINARY_USAGE.test(String(f.effectiveUsage || 'DISPLAY').replace('COMPUTATIONAL', 'COMP'))) {
+        if (f.size >= 1 && f.size <= 8) {
+          const bits = BigInt(f.size * 8);
+          const store = signed ? { lo: -(2n ** (bits - 1n)), hi: 2n ** (bits - 1n) - 1n } : { lo: 0n, hi: 2n ** bits - 1n };
+          out = {
+            hold: { lo: store.lo < digits.lo ? store.lo : digits.lo, hi: store.hi > digits.hi ? store.hi : digits.hi },
+            fit: { lo: store.lo > digits.lo ? store.lo : digits.lo, hi: store.hi < digits.hi ? store.hi : digits.hi },
+          };
+        } else out = null;
+      }
+    }
+    rangesOf.set(f, out);
+    return out;
+  };
+  // The most bytes an item named by these tokens can be, as a subscripted element or as written.
+  const sizeBound = (span) => {
+    const f = span[0] && span[0].t === 'word' ? resolve(span[0]) : null;
+    if (!f || f.index || f.level === 88 || f.size == null || !Number.isInteger(f.size)) return null;
+    if (span.length === 1) return f.contributes || f.size;
+    if (!WORD(span[1], 'OF') && span[1].v === '(' && span[span.length - 1].v === ')' && !span.some((t) => t.t === 'op' && t.v === ':')) {
+      return (f.children || []).some((c) => c.level !== 88) ? Math.ceil(f.size / Math.max(1, f.occurs || 1)) : f.size;
+    }
+    return null;
+  };
+  const arithEnv = {
+    field: (tok, subscripted) => {
+      const f = tok.t === 'word' ? resolve(tok) : null;
+      return rangeOfField(f) ? { k: 'field', f, tok, plain: !subscripted && !inTable(f) } : null;
+    },
+    sizeOf: sizeBound,
+  };
+  const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+  // A check's outcome as whole-number ends, from a range or a set of numbers; null ends are open.
+  const wholeEnds = (cons) => {
+    const isNum = (v) => /^[+-]?\d+(\.\d+)?$/.test(v);
+    if (cons.set && !(cons.set.size && [...cons.set].every(isNum))) return null;
+    const r = cons.set ? asRange(cons) : cons;
+    const end = (v, up, inc) => (v == null || Math.abs(v) >= Number.MAX_SAFE_INTEGER ? null : BigInt(up ? (inc ? Math.floor(v) : Math.ceil(v) - 1) : (inc ? Math.ceil(v) : Math.floor(v) + 1)));
+    const lo = end(r.lo, false, r.loInc);
+    const hi = end(r.hi, true, r.hiInc);
+    return lo == null && hi == null ? null : { lo, hi };
+  };
+  let factsByKey = new Map();
+  const indexFacts = () => {
+    factsByKey = new Map();
+    for (const c of checks) {
+      if (c.pseudo || c.key == null || (!c.tCons && !c.fCons)) continue;
+      if (!factsByKey.has(c.key)) factsByKey.set(c.key, []);
+      factsByKey.get(c.key).push(c);
+    }
+  };
+  // The facts held where the statement being read runs, from the last analysis; none on the first pass.
+  let heldBits = null;
+  // What a field can hold, and the facts that say so: its picture, or a constant, or the tightest
+  // lower and upper end among the facts that hold here.
+  const leafCands = (leaf) => {
+    const r = rangeOfField(leaf.f);
+    const base = { needs: [], lo: r.hold.lo, hi: r.hold.hi };
+    if (!leaf.plain) return [base];
+    const cv = numberOf(constValue([leaf.tok]));
+    if (cv != null && Number.isInteger(cv)) return [{ needs: [], lo: BigInt(cv), hi: BigInt(cv) }];
+    if (!heldBits) return [base];
+    let lo = null;
+    let hi = null;
+    for (const c of factsByKey.get(fieldKey(leaf.f)) || []) {
+      for (const [bit, cons] of [[c.t, c.tCons], [c.f, c.fCons]]) {
+        if (bit == null || !cons || !hasFact(heldBits, bit)) continue;
+        const e = wholeEnds(cons);
+        if (!e) continue;
+        if (e.lo != null && e.lo > (lo ? lo.v : base.lo)) lo = { bit, v: e.lo };
+        if (e.hi != null && e.hi < (hi ? hi.v : base.hi)) hi = { bit, v: e.hi };
+      }
+    }
+    const needs = [...new Set([lo && lo.bit, hi && hi.bit].filter((x) => x != null))].sort((x, y) => x - y);
+    const from = lo ? lo.v : base.lo;
+    const to = hi ? hi.v : base.hi;
+    return needs.length && from <= to ? [base, { needs, lo: from, hi: to }] : [base];
+  };
+  // A fact "the field holds a whole number from lo to hi" (either end may be open), one per field and interval.
+  const derivedOf = new Map();
+  const arithBudget = () => nodes.length * Math.ceil((nFacts + 64) / 32) * 4 <= FACT_BUDGET_BYTES / 2;
+  const derivedFact = (field, lo, hi, at) => {
+    if (lo != null && (lo > MAX_SAFE || lo < -MAX_SAFE)) lo = null;
+    if (hi != null && (hi > MAX_SAFE || hi < -MAX_SAFE)) hi = null;
+    if (lo == null && hi == null) return null;
+    // Each end is a fact of its own, so that routes which reach it by different statements meet at the looser.
+    if (lo != null && hi != null) { derivedFact(field, lo, null, at); derivedFact(field, null, hi, at); }
+    const id = `${lo ?? ''}|${hi ?? ''}`;
+    if (!derivedOf.has(field)) derivedOf.set(field, new Map());
+    const mine = derivedOf.get(field);
+    if (mine.has(id)) return mine.get(id);
+    if (!arithBudget()) return null;
+    const key = fieldKey(field);
+    noteField(key, field);
+    const bounds = { ...(lo != null ? { lo: Number(lo) } : {}), ...(hi != null ? { hi: Number(hi) } : {}) };
+    const tCons = { numeric: true, ...(lo != null ? { lo: Number(lo), loInc: true } : {}), ...(hi != null ? { hi: Number(hi), hiInc: true } : {}) };
+    const c = { id: checks.length, key, field, file: at.file, line: at.line, tCons, fCons: null, restricts: false, x: null, t: nFacts++, f: null, bounds, derived: true };
+    checks.push(c);
+    mine.set(id, c);
+    return c;
+  };
+  const derivedSeen = new Set();
+  const rules = [];
+  // Whatever holds after `n` when the facts in `needs` hold before it; with none needed, whenever it runs.
+  const derive = (n, needs, fact, bucket = null) => {
+    const id = `${n.id}|${bucket}|${needs.join(',')}|${fact.t}`;
+    if (derivedSeen.has(id)) return false;
+    derivedSeen.add(id);
+    rules.push({ n, needs, fact, bucket });
+    return true;
+  };
+  // An interval implies every looser interval the model holds about its field, so a route that reached a
+  // tighter one and a route that reached a looser one still meet at the looser. A check the program made
+  // is not among them: the interval is what the data holds, not a test that ran.
+  const withLooser = (fact) => {
+    const out = [fact.t];
+    const own = fact.bounds;
+    for (const c of factsByKey.get(fact.key) || []) {
+      if (c === fact || !c.derived) continue;
+      for (const [bit, cons] of [[c.t, c.tCons], [c.f, c.fCons]]) {
+        if (bit == null || !cons) continue;
+        const e = wholeEnds(cons);
+        if (!e) continue;
+        if ((e.lo == null || (own.lo != null && BigInt(own.lo) >= e.lo)) && (e.hi == null || (own.hi != null && BigInt(own.hi) <= e.hi))) out.push(bit);
+      }
+    }
+    return out;
+  };
+  const expandRules = () => {
+    indexFacts();
+    for (const n of nodes) { n.derive = undefined; n.genArith = undefined; }
+    for (const r of rules) {
+      const bits = withLooser(r.fact);
+      const at = r.bucket == null ? r.n : nodes[r.n.test];
+      if (!r.needs.length) {
+        if (r.bucket == null) (at.genArith ||= []).push(...bits);
+        else ((at.genArithOn ||= { true: [], false: [] })[r.bucket]).push(...bits);
+      } else (r.n.derive ||= []).push({ needs: r.needs, to: bits });
+    }
+  };
+
+  const ARITH_VERBS = new Set(['COMPUTE', 'ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MOVE']);
+  const between = (seg, from, to) => seg.slice(from, to < 0 ? seg.length : to);
+  const idxOf = (seg, word) => seg.findIndex((t) => WORD(t, word));
+  // A statement as a tree per receiving field; null where its words are not ones the model reads.
+  const readArith = (st) => {
+    let seg = segOf(st);
+    const cut = seg.findIndex((t) => t.t === 'word' && (t.u === 'ON' || t.u === 'NOT' || t.u === 'SIZE' || t.u === `END-${st.verb}`));
+    if (cut >= 0) seg = seg.slice(0, cut);
+    if (seg.some((t) => WORD(t, 'CORRESPONDING') || WORD(t, 'CORR') || WORD(t, 'REMAINDER'))) return null;
+    const operands = (toks, count) => {
+      const p = parser(toks, arithEnv);
+      const out = [];
+      while (!p.done()) out.push(p.primary());
+      if (!out.length || (count && out.length !== count)) throw parser;
+      return out;
+    };
+    const sum = (list) => list.reduce((a, b) => ({ k: 'bin', op: '+', a, b }));
+    // Receiving names with ROUNDED; anything else, including a subscript, still writes but is not followed.
+    const receivers = (toks) => {
+      const out = [];
+      for (let i = 0; i < toks.length; i++) {
+        const t = toks[i];
+        if (WORD(t, 'ROUNDED')) { if (!out.length) throw parser; out[out.length - 1].rounded = true; if (WORD(toks[i + 1], 'MODE')) i += WORD(toks[i + 2], 'IS') ? 3 : 2; continue; }
+        if (t.t !== 'word') throw parser;
+        const f = resolve(t);
+        out.push({ tok: t, f: f && !f.index && f.level !== 88 ? f : null, rounded: false, sub: toks[i + 1] && toks[i + 1].v === '(' });
+        if (toks[i + 1] && toks[i + 1].v === '(') { const close = closeIn(toks, i + 1); if (close < 0) throw parser; i = close; }
+      }
+      if (!out.length) throw parser;
+      return out;
+    };
+    const closeIn = (toks, i) => { let d = 0; for (let j = i; j < toks.length; j++) { if (toks[j].v === '(') d++; else if (toks[j].v === ')' && --d === 0) return j; } return -1; };
+    const own = (r) => arithEnv.field(r.tok, false);
+    const per = (targets, make) => targets.map((r) => (r.sub || !r.f ? null : make(r)));
+    return attempt(() => {
+      let targets;
+      let trees;
+      switch (st.verb) {
+        case 'COMPUTE': {
+          const eq = seg.findIndex((t) => t.t === 'op' && t.v === '=');
+          if (eq < 1) return null;
+          targets = receivers(seg.slice(0, eq));
+          const p = parser(seg.slice(eq + 1), arithEnv);
+          const e = p.expr();
+          if (!p.done()) return null;
+          trees = per(targets, () => e);
+          break;
+        }
+        case 'ADD': {
+          const g = idxOf(seg, 'GIVING');
+          if (g < 0) {
+            const to = idxOf(seg, 'TO');
+            if (to < 1) return null;
+            const ops = operands(seg.slice(0, to));
+            targets = receivers(seg.slice(to + 1));
+            trees = per(targets, (r) => { const l = own(r); return l ? sum([...ops, l]) : null; });
+          } else {
+            const ops = operands(seg.slice(0, g).filter((t) => !WORD(t, 'TO')));
+            targets = receivers(seg.slice(g + 1));
+            trees = per(targets, () => sum(ops));
+          }
+          break;
+        }
+        case 'SUBTRACT': {
+          const from = idxOf(seg, 'FROM');
+          const g = idxOf(seg, 'GIVING');
+          if (from < 1) return null;
+          const subs = sum(operands(seg.slice(0, from)));
+          if (g < 0) {
+            targets = receivers(seg.slice(from + 1));
+            trees = per(targets, (r) => { const l = own(r); return l ? { k: 'bin', op: '-', a: l, b: subs } : null; });
+          } else {
+            const [minuend] = operands(between(seg, from + 1, g), 1);
+            targets = receivers(seg.slice(g + 1));
+            trees = per(targets, () => ({ k: 'bin', op: '-', a: minuend, b: subs }));
+          }
+          break;
+        }
+        case 'MULTIPLY': {
+          const by = idxOf(seg, 'BY');
+          const g = idxOf(seg, 'GIVING');
+          if (by < 1) return null;
+          const [a] = operands(seg.slice(0, by), 1);
+          if (g < 0) {
+            targets = receivers(seg.slice(by + 1));
+            trees = per(targets, (r) => { const l = own(r); return l ? { k: 'bin', op: '*', a: l, b: a } : null; });
+          } else {
+            const [b] = operands(between(seg, by + 1, g), 1);
+            targets = receivers(seg.slice(g + 1));
+            trees = per(targets, () => ({ k: 'bin', op: '*', a, b }));
+          }
+          break;
+        }
+        case 'DIVIDE': {
+          const into = idxOf(seg, 'INTO');
+          const by = idxOf(seg, 'BY');
+          const g = idxOf(seg, 'GIVING');
+          if (into > 0 && by < 0) {
+            const [d] = operands(seg.slice(0, into), 1);
+            if (g < 0) {
+              targets = receivers(seg.slice(into + 1));
+              trees = per(targets, (r) => { const l = own(r); return l ? { k: 'bin', op: '/', a: l, b: d } : null; });
+            } else {
+              const [n] = operands(between(seg, into + 1, g), 1);
+              targets = receivers(seg.slice(g + 1));
+              trees = per(targets, () => ({ k: 'bin', op: '/', a: n, b: d }));
+            }
+          } else if (by > 0 && into < 0 && g > by) {
+            const [n] = operands(seg.slice(0, by), 1);
+            const [d] = operands(between(seg, by + 1, g), 1);
+            targets = receivers(seg.slice(g + 1));
+            trees = per(targets, () => ({ k: 'bin', op: '/', a: n, b: d }));
+          } else return null;
+          break;
+        }
+        case 'MOVE': {
+          const to = idxOf(seg, 'TO');
+          if (to < 1) return null;
+          const p = parser(seg.slice(0, to), arithEnv);
+          const e = p.primary();
+          if (!p.done() || (e.k !== 'field' && e.k !== 'range' && e.k !== 'mod')) return null;
+          targets = receivers(seg.slice(to + 1));
+          trees = per(targets, () => e);
+          break;
+        }
+        default: return null;
+      }
+      // Several receivers taking turns: what one takes is no longer what the next reads.
+      if (targets.length > 1) {
+        const written = targets.map((r) => r.f).filter(Boolean);
+        if (written.some((w, i) => written.some((v, j) => i !== j && overlaps(w, v)))) return null;
+        for (const tree of trees) for (const l of tree ? leaves(tree) : []) if (written.some((w) => overlaps(w, l.f))) return null;
+      }
+      return { targets, trees };
+    });
+  };
+
+  const arith = [];
+  try {
+    for (const n of nodes) {
+      if (n.kind !== 'stmt' || !n.st || n.st.at == null || !ARITH_VERBS.has(n.st.verb)) continue;
+      const read = readArith(n.st);
+      if (read && read.trees.some(Boolean)) arith.push({ n, ...read });
+    }
+  } catch {
+    arith.length = 0;
+  }
+
+  // A condition's requirements that hold whichever way the rest of it went: the relations it makes true.
+  const relationsOf = (tree, outcome, out = []) => {
+    switch (tree.k) {
+      case 'not': return relationsOf(tree.a, !outcome, out);
+      case 'and': if (outcome) { relationsOf(tree.a, true, out); relationsOf(tree.b, true, out); } return out;
+      case 'or': if (!outcome) { relationsOf(tree.a, false, out); relationsOf(tree.b, false, out); } return out;
+      case 'rel': out.push({ rel: tree, pol: outcome }); return out;
+      default: return out;
+    }
+  };
+  const ORDERING = new Set(['<', '<=', '>', '>=']);
+  // Relations between two integer fields: the ordering tests whose sides are both plain fields.
+  const relations = new Map();
+  const collectRelations = (tree, test) => {
+    if (tree.k === 'rel') {
+      if (!ORDERING.has(tree.op) || relations.has(tree)) return;
+      const f = fieldOf(tree.left);
+      const g = fieldOf(tree.right);
+      if (!f || !g || f === g || inTable(f) || inTable(g) || !rangeOfField(f) || !rangeOfField(g)) return;
+      if (constValue(tree.left) != null || constValue(tree.right) != null) return;
+      relations.set(tree, { f, g, op: tree.op, tokF: tree.left[0], tokG: tree.right[0], test, entries: { true: new Map(), false: new Map() } });
+    } else for (const s of [tree.a, tree.b]) if (s) collectRelations(s, test);
+  };
+  try {
+    for (const id of tests) { const t = nodes[id].tree; if (t) collectRelations(t, id); }
+  } catch {
+    relations.clear();
+  }
+
+  // The fields that matter: those an index reads, and those that flow into them through the
+  // statements above and the relations between fields.
+  const relevant = new Set();
+  for (const st of prog.statements) for (const x of st.indexes || []) { const it = x.tok && x.tok.t === 'word' ? resolve(x.tok) : null; if (it && !it.index) relevant.add(it); }
+  for (const it of prog.items) {
+    if (!it.dependingOn) continue;
+    const c = resolve({ t: 'word', u: String(it.dependingOn).toUpperCase(), v: it.dependingOn });
+    if (c && !c.index) relevant.add(c);
+  }
+  for (let more = relevant.size > 0; more;) {
+    more = false;
+    const before = relevant.size;
+    for (const a of arith) if (a.targets.some((r) => r.f && relevant.has(r.f))) for (const tree of a.trees) for (const l of tree ? leaves(tree) : []) relevant.add(l.f);
+    for (const r of relations.values()) if (relevant.has(r.f) || relevant.has(r.g)) { relevant.add(r.f); relevant.add(r.g); }
+    more = relevant.size > before;
+  }
+
+  // One pass over the statements and relations, reading each against the facts `prev` holds at it. True if it added anything.
+  const arithRound = (prev) => {
+    if (!relevant.size || !(arith.length || relations.size)) return false;
+    // Each further pass runs the whole analysis again, so a program too large for that is left with what one pass gives.
+    if (prev && nodes.length * Math.ceil(nFacts / 32) > ARITH_WORK) return false;
+    let grew = false;
+    try {
+    indexFacts();
+    for (const a of arith) {
+      a.trees.forEach((tree, i) => {
+        const r = a.targets[i];
+        if (!tree || !r.f || !rangeOfField(r.f) || inTable(r.f) || !relevant.has(r.f)) return;
+        const fit = rangeOfField(r.f).fit;
+        heldBits = prev ? prev.get(a.n.id) || null : null;
+        for (const c of candidates(tree, leafCands, 64)) {
+          const s = storedRange(c.iv, r.rounded);
+          if (s.lo < fit.lo || s.hi > fit.hi || (s.lo === fit.lo && s.hi === fit.hi)) continue;
+          const fact = derivedFact(r.f, s.lo, s.hi, a.n.st);
+          if (fact && derive(a.n, c.needs, fact)) grew = true;
+        }
+      });
+    }
+    for (const rel of relations.values()) {
+      if (!relevant.has(rel.f) && !relevant.has(rel.g)) continue;
+      const at = nodes[rel.test].at || nodes[rel.test].st;
+      heldBits = prev ? prev.get(rel.test) || null : null;
+      for (const pol of [true, false]) {
+        const eff = pol ? rel.op : NEGATE[rel.op];
+        for (const [tgt, src, tok, op] of [[rel.f, rel.g, rel.tokG, eff], [rel.g, rel.f, rel.tokF, FLIP[eff]]]) {
+          const hold = rangeOfField(tgt).hold;
+          for (const c of leafCands({ f: src, tok, plain: true })) {
+            let lo = null;
+            let hi = null;
+            if (op === '<') hi = c.hi - 1n; else if (op === '<=') hi = c.hi; else if (op === '>') lo = c.lo + 1n; else lo = c.lo;
+            if (lo != null && lo <= hold.lo) lo = null;
+            if (hi != null && hi >= hold.hi) hi = null;
+            if ((lo == null && hi == null) || (hi != null && hi < hold.lo) || (lo != null && lo > hold.hi)) continue;
+            const fact = derivedFact(tgt, lo, hi, at);
+            const id = fact && `${fact.t}|${c.needs}`;
+            if (fact && !rel.entries[pol].has(id)) { rel.entries[pol].set(id, { needs: c.needs, fact }); grew = true; }
+          }
+        }
+      }
+    }
+    // A relation holds after the outcome of its test that makes it true, and the fields it bounds hold
+    // what the other side could hold.
+    for (const id of tests) {
+      const n = nodes[id];
+      if (!n.tree) continue;
+      for (const o of [true, false]) {
+        const at = outcomeAt.get(`${id}|${o}`);
+        if (!at) continue;
+        for (const { rel, pol } of relationsOf(n.tree, o)) {
+          const rec = relations.get(rel);
+          if (rec) for (const e of rec.entries[pol].values()) if (derive(at, e.needs, e.fact, String(o))) grew = true;
+        }
+      }
+    }
+    } catch {
+      // Whatever went wrong, the statements keep the facts they had.
+        grew = false;
+    }
+    heldBits = null;
+    return grew;
+  };
+  arithRound(null);
   // At least one fact, so the analysis runs, and a statement it never reaches has no facts at all.
   nFacts ||= 1;
   const extraFacts = new Map();
@@ -1090,7 +2070,14 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     }
   }
   if (!nFacts) return { nodeOf, checks: [], words: 0, facts: new Map(), nodes: nodes.length, extraFacts };
-  const words = Math.ceil(nFacts / 32);
+  let words = 0;
+  let facts = new Map();
+  let partial = false;
+  // The analysis proper, run again whenever arithmetic has added facts.
+  const analyse = () => {
+  words = Math.ceil(nFacts / 32);
+  for (const n of nodes) { n.kill = undefined; n.keeps = undefined; n.genS = undefined; n.genArithOn = undefined; }
+  expandRules();
   // Every node holds a bitset of every fact, several times over, so the cost is their product. A
   // 426,000-line generated program passed an 8 GB heap here, and running out of heap cannot be
   // caught. Past the budget the program is left unordered, which callers already handle.
@@ -1100,19 +2087,9 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   const factsOfKey = new Map();
   for (const c of checks) {
     const list = factsOfKey.get(c.key) || [];
-    for (const f of [c.x, c.t, c.f]) if (f != null) list.push(f);
+    for (const f of [c.x, c.t, c.f, c.rt, c.rf]) if (f != null) list.push(f);
     factsOfKey.set(c.key, list);
   }
-  const overlaps = (w, f) => {
-    if (w === f) return true;
-    if (w.index || f.index) return w.index && f.index && w.index === f.index;
-    if (w.level === 66 || f.level === 66) return true;
-    if (itemsInRecord(w) !== itemsInRecord(f)) return false;
-    if (w.offset == null || f.offset == null || w.size == null || f.size == null) return true;
-    const wEnd = w.offset + (w.contributes || w.size);
-    const fEnd = f.offset + (f.contributes || f.size);
-    return w.offset < fEnd && f.offset < wEnd;
-  };
   const killCache = new Map();
   const killOf = (w) => {
     if (!w) return null;
@@ -1128,44 +2105,6 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     killCache.set(w, bits);
     return bits;
   };
-  const writtenBy = (n) => {
-    const out = [];
-    const add = (tok) => { const f = tok ? resolve(tok) : null; if (f) out.push(f.level === 88 && f.parent ? f.parent : f); };
-    if (n.st) {
-      for (const t of n.st.targets || []) add(t);
-      if (n.st.verb === 'CALL' || n.st.verb === 'READ' || n.st.verb === 'RETURN') {
-        // A callee may write what it is passed by reference, and a READ fills the file's records.
-        for (const t of n.st.sources || []) {
-          const f = resolve(t);
-          if (!f) continue;
-          if (f.records) for (const r of f.records) out.push(r);
-          else if (n.st.verb === 'CALL') out.push(f);
-        }
-      }
-    }
-    if (n.e && n.e.kind === 'SQL') {
-      // A statement fills the host variables of its INTO list and reads the rest.
-      const toks = n.e.toks;
-      const into = toks.findIndex((t) => WORD(t, 'INTO'));
-      if (into >= 0) {
-        for (let i = into + 1; i < toks.length && !WORD(toks[i], 'FROM'); i++) {
-          if (toks[i].t === 'op' && toks[i].v === ':' && toks[i + 1]) add(toks[i + 1]);
-        }
-      }
-    } else if (n.e) {
-      // A command may fill what any option is given directly, except what it sends FROM. A name
-      // inside that argument's own parentheses - a subscript, a reference modification - is read.
-      let depth = 0;
-      let option = null;
-      for (let i = 0; i < n.e.toks.length; i++) {
-        const t = n.e.toks[i];
-        if (t.t === 'sep') { depth += t.v === '(' ? 1 : -1; continue; }
-        if (depth === 0) { option = t.t === 'word' ? t.u : option; continue; }
-        if (depth === 1 && t.t === 'word' && option !== 'FROM') add(t);
-      }
-    }
-    return out;
-  };
   for (const n of nodes) {
     if (n.kind !== 'stmt' && n.kind !== 'exec' && n.kind !== 'step' && n.kind !== 'call') continue;
     let bits = null;
@@ -1177,13 +2116,64 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     }
     if (bits) n.kill = bits;
   }
+  // The facts that say a field is bounded above from a value that leaves room for `max` more.
+  const roomFacts = new Map();
+  const roomFor = (field, max) => {
+    let out = roomFacts.get(field)?.get(max);
+    if (out) return out;
+    out = [];
+    const cap = intCap(field);
+    for (const c of checks) {
+      if (c.key !== field || c.mono || c.pseudo) continue;
+      for (const [bit, cons] of [[c.t, c.tCons], [c.f, c.fCons]]) {
+        const r = bit != null && cons ? asRange(cons) : null;
+        if (!r || r.hi == null) continue;
+        if ((r.hiInc ? Math.floor(r.hi) : Math.ceil(r.hi) - 1) + max <= cap) out.push(bit);
+      }
+    }
+    if (!roomFacts.has(field)) roomFacts.set(field, new Map());
+    roomFacts.get(field).set(max, out);
+    return out;
+  };
+  // What a write does not kill: the lower bounds of a field it only raises, where nothing else it
+  // writes shares the field's bytes.
+  const keepAcross = (n, list) => {
+    const wrote = writtenBy(n);
+    for (const { field, max, sizeError } of list) {
+      const mine = loOf.get(field);
+      if (!mine || wrote.some((w) => w !== field && overlaps(w, field))) continue;
+      const guards = sizeError ? null : roomFor(field, max);
+      if (guards && !guards.length) continue;
+      const bits = new Uint32Array(words);
+      for (const c of mine) bits[c.t >>> 5] |= 1 << (c.t & 31);
+      (n.keeps ||= []).push({ bits, guards });
+    }
+  };
+  nodes.forEach((n, id) => {
+    if (!n.kill) return;
+    if (n.kind === 'stmt' && n.st && n.st.at != null) {
+      const inc = increments(n.st);
+      if (inc) keepAcross(n, inc.fields.map((field) => ({ field, max: inc.max, sizeError: inc.sizeError })));
+      for (const { field, max, pairs } of lifted.get(id) || []) {
+        const guards = roomFor(field, max);
+        if (guards.length && !(n.st.targets || []).some((t) => { const o = resolve(t); return o && o !== field && overlaps(o, field); })) (n.lifts ||= []).push({ pairs, guards });
+      }
+    } else if (n.kind === 'step' && stepped.has(id)) {
+      keepAcross(n, [{ ...stepped.get(id), sizeError: false }]);
+    }
+    if (n.kind === 'step' && keptOnStep.has(id)) {
+      const bits = new Uint32Array(words);
+      for (const b of keptOnStep.get(id)) bits[b >>> 5] |= 1 << (b & 31);
+      (n.keeps ||= []).push({ bits, guards: null });
+    }
+  });
 
   // ---- must-analysis ----
   const ZERO = new Uint32Array(words);
   const ONES = new Uint32Array(words).fill(0xffffffff);
   const genBits = (list) => { const b = new Uint32Array(words); for (const x of list) b[x >>> 5] |= 1 << (x & 31); return b; };
-  for (const id of tests) { const n = nodes[id]; n.genT = genBits(n.gen.true); n.genF = genBits(n.gen.false); }
-  for (const n of nodes) if (n.genStmt) n.genS = genBits(n.genStmt);
+  for (const id of tests) { const n = nodes[id]; n.genT = genBits([...n.gen.true, ...(n.genArithOn ? n.genArithOn.true : [])]); n.genF = genBits([...n.gen.false, ...(n.genArithOn ? n.genArithOn.false : [])]); }
+  for (const n of nodes) if (n.genStmt || n.genArith) n.genS = genBits([...(n.genStmt || []), ...(n.genArith || [])]);
   const summaries = new Map();
   // Reverse postorder from every way in, so a forward analysis visits a node after what precedes it
   // and a join is revisited only when a loop brings something new.
@@ -1209,6 +2199,9 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     for (let i = 0; i < post.length; i++) order[post[i]] = post.length - 1 - i;
   }
   const scratch = new Uint32Array(words);
+  const killScratch = new Uint32Array(words);
+  // A summary is joined to whatever enters the range, so it cannot assume a guard the caller lacks.
+  let summarising = false;
   // What holds after a node, in a buffer reused by every call: the caller merges it into the next
   // node's facts before calling again. Null where the route ends here.
   const transfer = (n, input) => {
@@ -1226,17 +2219,46 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       out = scratch;
     }
     if (n.kill) {
-      if (out === input) { for (let i = 0; i < words; i++) scratch[i] = input[i] & ~n.kill[i]; out = scratch; }
-      else for (let i = 0; i < words; i++) out[i] &= ~n.kill[i];
+      let kill = n.kill;
+      if (n.keeps) {
+        kill = killScratch;
+        kill.set(n.kill);
+        for (const k of n.keeps) {
+          if (k.guards && (summarising || !k.guards.some((g) => input[g >>> 5] & (1 << (g & 31))))) continue;
+          for (let i = 0; i < words; i++) kill[i] &= ~k.bits[i];
+        }
+      }
+      if (out === input) { for (let i = 0; i < words; i++) scratch[i] = input[i] & ~kill[i]; out = scratch; }
+      else for (let i = 0; i < words; i++) out[i] &= ~kill[i];
     }
     // What the statement assigns holds after it, over whatever the write took away.
     if (n.genS) {
       if (out === input) { for (let i = 0; i < words; i++) scratch[i] = input[i] | n.genS[i]; out = scratch; }
       else for (let i = 0; i < words; i++) out[i] |= n.genS[i];
     }
+    // An increment that cannot wrap raises the lower bounds that held before it.
+    if (n.lifts) {
+      for (const { pairs, guards } of n.lifts) {
+        if (summarising || !guards.some((g) => input[g >>> 5] & (1 << (g & 31)))) continue;
+        for (const [from, to] of pairs) {
+          if (!(input[from >>> 5] & (1 << (from & 31)))) continue;
+          if (out === input) { scratch.set(input); out = scratch; }
+          out[to >>> 5] |= 1 << (to & 31);
+        }
+      }
+    }
+    // What a statement or a test leaves in a field, where the facts its operands needed held before it.
+    if (n.derive && !summarising) {
+      for (const d of n.derive) {
+        if (!d.needs.every((x) => input[x >>> 5] & (1 << (x & 31)))) continue;
+        if (out === input) { scratch.set(input); out = scratch; }
+        for (const t of d.to) out[t >>> 5] |= 1 << (t & 31);
+      }
+    }
     // A flag test's outcome turns what held before it into the bound the flag stood for.
     if (n.implies) {
-      for (const [from, to] of n.implies) {
+      for (const [from, to, soft] of n.implies) {
+        if (soft && summarising) continue;
         if (!(input[from >>> 5] & (1 << (from & 31)))) continue;
         if (out === input) { scratch.set(input); out = scratch; }
         out[to >>> 5] |= 1 << (to & 31);
@@ -1310,6 +2332,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   // a recursive PERFORM does anyway.
   const performed = [...ranges.values()].filter((r) => r.entry != null && r.end != null);
   const callers = new Map();
+  summarising = true;
   const pending = [...performed].sort((a, b) => order[b.entry] - order[a.entry]);
   const queued = new Set(pending.map((r) => r.key));
   for (let steps = 0; pending.length && steps < performed.length * 20; steps++) {
@@ -1327,7 +2350,8 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     for (const c of callers.get(r.key) || []) if (!queued.has(c.key)) { queued.add(c.key); pending.push(c); }
   }
   // Stopped at a step limit, a summary may say a range never returns when it does.
-  let partial = pending.length > 0;
+  partial = pending.length > 0;
+  summarising = false;
 
   // Contexts: the program's own entry and every extra one enter with nothing; a range enters with
   // what holds at every PERFORM of it that some context reaches. A context runs again only when what
@@ -1359,13 +2383,16 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     }
   }
   if (work.length || unknownLabel) partial = true;
-  const facts = new Map();
+  facts = new Map();
   for (const IN of results.values()) {
     for (const [id, bits] of IN) {
       const had = facts.get(id);
       if (had) meetInto(had, bits); else facts.set(id, bits.slice());
     }
   }
+  };
+  analyse();
+  for (let round = 1; round < 12 && arithRound(facts); round++) { analyse(); }
 
   // What a run can reach, from the graph alone and with the contexts the facts use: code entered from
   // an entry runs on past the end of a paragraph, and a performed range stops at its end. A PERFORM
@@ -1423,6 +2450,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       const guards = reads.get(x.tok);
       let said = null;
       let ran = null;
+      const chains = guards || [];
       for (const g of guards || []) {
         let cons = new Map();
         const r = new Map();
@@ -1434,14 +2462,14 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       const mine = [];
       for (const key of new Set([...said.keys(), ...ran.keys()])) {
         const c = { id: checks.length, key, field: ran.get(key) || (typeof key === 'string' ? { index: key.slice(3) } : key), file: (n.at || n.st).file, line: (n.at || n.st).line,
-          tCons: said.get(key) || null, fCons: null, restricts: ran.has(key), f: null };
+          tCons: plainCons(said.get(key)), fCons: null, restricts: ran.has(key), f: null };
         c.x = c.restricts ? placeFacts++ : null;
         c.t = c.tCons ? placeFacts++ : null;
         checks.push(c);
         mine.push(c);
       }
       posOf.set(x.tok, nodes.length + places.length);
-      places.push({ test: id, checks: mine });
+      places.push({ test: id, checks: mine, chains });
     }
   }
   const reachedAt = new Uint8Array(nodes.length + places.length);
@@ -1453,6 +2481,19 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     const bits = new Uint32Array(Math.max(words, Math.ceil(placeFacts / 32)));
     bits.set(before);
     for (const c of p.checks) for (const x of [c.x, c.t]) if (x != null) bits[x >>> 5] |= 1 << (x & 31);
+    // What a relation before the name says of its fields, if every reading of the name is behind one.
+    let related = null;
+    for (const chain of p.chains) {
+      const got = new Set();
+      for (const [sub, outcome] of chain) {
+        for (const { rel, pol } of relationsOf(sub, outcome)) {
+          const rec = relations.get(rel);
+          if (rec) for (const e of rec.entries[pol].values()) if (e.needs.every((x) => before[x >>> 5] & (1 << (x & 31)))) for (const x of withLooser(e.fact)) got.add(x);
+        }
+      }
+      related = related ? new Set([...related].filter((x) => got.has(x))) : got;
+    }
+    for (const x of related || []) bits[x >>> 5] |= 1 << (x & 31);
     facts.set(nodes.length + i, bits);
   });
 
@@ -1460,7 +2501,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   // the caller has let the parse tree go. A statement no context reaches has no facts, and credits
   // nothing. One `reached` does not mark does not run, unless `partial` says the analysis stopped
   // short or met a paragraph the parse did not find.
-  return { nodeOf, posOf, checks: checks.filter((c) => !c.pseudo), words, nodes: nodes.length, facts, reached: reachedAt, extraFacts, partial };
+  return { loopBody, nodeOf, posOf, checks: checks.filter((c) => !c.pseudo), words, nodes: nodes.length, facts, reached: reachedAt, extraFacts, partial };
 }
 
 // For each token a condition reads, what each reading of it waits on: the operands to its left at
@@ -1489,27 +2530,64 @@ export const hasFact = (bits, x) => x != null && bits != null && (bits[x >>> 5]
 // named is the one that decided it: one whose outcome alone makes the value safe, if there is one.
 // A bound the program's data sets rather than a check it made counts only where it keeps the index
 // between 1 and the sink's `limit`.
-export function creditOf(checks, bits, sinkKind, limit = null) {
+// `offset` is the constant the sink adds to the index it names, T(I - 1): the outcomes are judged
+// shifted by it, and a shifted top is held to the limit.
+export function creditOf(checks, bits, sinkKind, limit = null, offset = 0, nonNeg = false) {
   let tested = null;
   let cons = null;
   let consBy = null;
   let alone = null;
+  // An index a check tested is credited only where one outcome of it holds: where both reach the
+  // use, the route on which the check failed reaches it too. An outcome that says something only
+  // through arithmetic on other fields is not one that decided the index.
+  const decided = (c) => !INDEX_SINKS.has(sinkKind) || (hasFact(bits, c.t) && !c.tCons.viaExpr) || (hasFact(bits, c.f) && !c.fCons.viaExpr);
   for (const c of checks) {
-    if (c.bounds && !(limit != null && c.bounds.lo >= 1 && c.bounds.hi <= limit)) continue;
-    if (hasFact(bits, c.x) && !tested) tested = c;
+    if (c.bounds && !(limit != null && (c.bounds.lo == null ? c.bounds.hi != null : c.bounds.lo + offset >= 1) && (c.bounds.hi == null || c.bounds.hi + offset <= limit))) continue;
+    if (hasFact(bits, c.x) && !tested && decided(c)) tested = c;
     for (const [bit, said] of [[c.t, c.tCons], [c.f, c.fCons]]) {
       if (!hasFact(bits, bit)) continue;
       cons = meet(cons, said);
-      consBy ||= c;
+      // A lower bound the program's data sets is shared by every place that sets it, so a test names the guard.
+      if (!consBy || (consBy.mono && !c.mono)) consBy = c;
       if (!alone && stops(said, sinkKind)) alone = c;
     }
   }
   // A check whose outcome puts the index past either end is the use it should have prevented.
-  if (limit != null && outside(cons, limit)) return { level: 0, check: null };
-  if (cons && stops(cons, sinkKind)) return { level: 2, check: alone || consBy };
+  const shifted = shift(cons, offset);
+  // An unsigned index moved up by a constant starts at that constant, whatever the checks said of its bottom.
+  if (shifted && offset > 0 && nonNeg && shifted.lo == null && !shifted.set) { shifted.lo = offset; shifted.loInc = true; }
+  if (limit != null && outside(shifted, limit)) return { level: 0, check: null };
+  // A bound above the table's or the field's size lets the index past its end, however the check was written.
+  const pastEnd = !!shifted && limit != null && (sinkKind === 'subscript' || sinkKind === 'reference-modification') && overTop(shifted, limit);
+  if (shifted && stops(shifted, sinkKind) && !pastEnd) return { level: 2, check: alone || consBy, cons: shifted };
   return tested ? { level: 1, check: tested } : { level: 0, check: null };
 }
 
-const outside = (cons, limit) => !!cons && (
-  (cons.lo != null && (cons.lo > limit || (cons.lo === limit && !cons.loInc)))
-  || (cons.hi != null && (cons.hi < 1 || (cons.hi === 1 && !cons.hiInc))));
+// Whether a constraint keeps an integer at or below `limit`, and at 1 or more where `fromOne`.
+export function within(said, limit, fromOne = true) {
+  if (!said) return false;
+  const cons = asRange(said);
+  return (!fromOne || atLeastOne(cons)) && cons.hi != null && (cons.hiInc ? cons.hi <= limit : cons.hi <= limit + 1);
+}
+
+
+// A constraint moved by a constant: the values it allows, each plus `by`.
+function shift(said, by) {
+  if (!said) return said;
+  const out = { ...said };
+  if (out.set) out.set = new Set([...out.set].map((v) => (/^[+-]?\d+(\.\d+)?$/.test(v) ? String(Number(v) + by) : v)));
+  if (out.lo != null) out.lo += by;
+  if (out.hi != null) out.hi += by;
+  return out;
+}
+const overTop = (said, limit) => {
+  const cons = asRange(said);
+  return cons.hi != null && (cons.hi > limit + 1 || (cons.hi === limit + 1 && cons.hiInc));
+};
+
+const outside = (said, limit) => {
+  if (!said) return false;
+  const cons = asRange(said);
+  return (cons.lo != null && (cons.lo > limit || (cons.lo === limit && !cons.loInc)))
+    || (cons.hi != null && (cons.hi < 1 || (cons.hi === 1 && !cons.hiInc)));
+};