LuaDecompBoolean.inc

function TDecompiler.TryEmitOrAnd(BranchBlk, TrueBlk, FalseBlk: Integer): Boolean;
var
  BranchNode: PSSANode;
  I, J, S: Integer;
  JmpBlk, ValBlk, MergeIdx: Integer;
  CondExpr, ValExpr, CombinedExpr: AnsiString;
  IsOr: Boolean;
  PhiNode: PSSANode;
  PhiIdx: Integer;
  HasOnlyJmp, HasValDef: Boolean;
  ValDefNode, EffectiveValDef: PSSANode;
  N: PSSANode;
  { Chain continuation variables }
  FinalMerge, NextMerge, Safety: Integer;
  FinalPhiNode, NextPhiNode, DefaultNode: PSSANode;
  LHS, Segment: AnsiString;
  HasSideEffect, IsChainIntermediate: Boolean;
  UsesTestedReg: Boolean;
  ValN: PSSANode;
begin
  Result := False;

  if FOpts.Debug then
    WriteLn(StdErr, 'TryEmitOrAnd: checking BB', BranchBlk,
            ' TrueBlk=BB', TrueBlk, ' FalseBlk=BB', FalseBlk);

  { Find the BRANCH node in the branch block }
  BranchNode := nil;
  for I := 0 to High(FSF^.Blocks[BranchBlk].Nodes) do
    if FSF^.Blocks[BranchBlk].Nodes[I]^.Kind = SSA_BRANCH then begin
      BranchNode := FSF^.Blocks[BranchBlk].Nodes[I]; Break;
    end;
  if BranchNode = nil then begin
    if FOpts.Debug then
      WriteLn(StdErr, 'TryEmitOrAnd: failed - no BRANCH node in BB', BranchBlk);
    Exit;
  end;

  { Accept TEST/TESTSET or comparison operations (EQ/LT/LE) for or/and patterns }

  { Validate both successors exist and are forward }
  if (TrueBlk < 0) or (FalseBlk < 0) then begin
    if FOpts.Debug then
      WriteLn(StdErr, 'TryEmitOrAnd: failed - invalid successor indices');
    Exit;
  end;
  if (TrueBlk >= Length(FSF^.Blocks)) or (FalseBlk >= Length(FSF^.Blocks)) then begin
    if FOpts.Debug then
      WriteLn(StdErr, 'TryEmitOrAnd: failed - successor out of range');
    Exit;
  end;

  { Determine which successor is the single-JMP block (pass-through) and
    which is the value-definition block (fallback).
    For "or" (Invert=true/C=1): TrueBlk is the jump-to-merge (pass condition through),
    FalseBlk has the fallback value.
    For "and" (Invert=false/C=0): FalseBlk is the jump-to-merge,
    TrueBlk has the fallback value. }

  { Check if TrueBlk is a single-JMP block }
  HasOnlyJmp := True;
  for I := 0 to High(FSF^.Blocks[TrueBlk].Nodes) do
    if not (FSF^.Blocks[TrueBlk].Nodes[I]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
      HasOnlyJmp := False; Break;
    end;

  if HasOnlyJmp then begin
    JmpBlk := TrueBlk;
    ValBlk := FalseBlk;
  end else begin
    { Check if FalseBlk is a single-JMP block }
    HasOnlyJmp := True;
    for I := 0 to High(FSF^.Blocks[FalseBlk].Nodes) do
      if not (FSF^.Blocks[FalseBlk].Nodes[I]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
        HasOnlyJmp := False; Break;
      end;
    if not HasOnlyJmp then begin
      if FOpts.Debug then
        WriteLn(StdErr, 'TryEmitOrAnd: failed - neither successor is JMP-only');
      Exit;  { Neither is a JMP-only block; not or/and }
    end;
    JmpBlk := FalseBlk;
    ValBlk := TrueBlk;
  end;

  { Reject or/and when the JMP block leads to the current loop exit.
    In that case, this is an "if cond then break end" pattern, not a
    value expression.  Let TryEmitBreakIf handle it instead. }
  if IsBreakTarget(JmpBlk) then begin
    if FOpts.Debug then
      WriteLn(StdErr, 'TryEmitOrAnd: rejected - JmpBlk BB', JmpBlk,
              ' is break target');
    Exit;
  end;

  { The value block must have at least one value-defining node.
    Multiple real nodes are OK (e.g., GETTABLE chain before BRANCH in chained or/and).
    The LAST real node defines the value for the or/and expression.
    However, side-effect statements (SETTABLE, SETGLOBAL, SETUPVAL, CALL with
    no return value) indicate this is an if/then pattern, not an or/and expression.
    A non-TESTSET BRANCH in ValBlk with body statements before it (CALL, GETTABLE, etc.)
    indicates this is an if-then body with a nested condition, not a value arm of or/and. }
  HasValDef := False;
  HasSideEffect := False;  { track if ValBlk has body statements }
  ValDefNode := nil;
  for I := 0 to High(FSF^.Blocks[ValBlk].Nodes) do begin
    N := FSF^.Blocks[ValBlk].Nodes[I];
    if N^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP] then Continue;
    if N^.Kind = SSA_BRANCH then begin
      { TESTSET branches (RelOp=ropTestSet) define a value - treat as value def.
        Other branches (TEST/EQ/LT/LE) indicate nested control flow.
        If there are body statements before this branch (CALL, GETTABLE, etc.),
        this is an if-then body, not a value arm of an or/and expression.
        Example: "if type(x) == 'string' then local name = x; x = tbl[name];
                  if type(x) ~= 'function' then error(...) end end"
        The inner block has MOVE+GETTABLE+CALL+BRANCH - it's a body, not a value. }
      if N^.RelOp = ropTestSet then begin
        HasValDef := True;
        ValDefNode := N;
      end else begin
        { Non-TESTSET BRANCH in ValBlk: could be a chain continuation
          (e.g., "sum == 2 and self[y][x]" where self[y][x] is TEST'd),
          or a nested if-condition (e.g., "if a then if b then ... end end").
          Reject if ValBlk has 2+ successors where BOTH lead to blocks
          that themselves have bodies (CALL, SETTABLE, etc.), indicating
          this is an if-body rather than a value chain.
          Accept if the TEST is on a register that feeds a PHI at the merge. }
        { Check if the merge block's PHI has a matching register.
          In a true or/and chain, the merge PHI combines values from multiple
          short-circuit paths. ValBlk may or may not contribute directly - in
          multi-element chains, ValBlk starts a sub-chain whose descendants
          contribute to the merge PHI.
          Accept if the merge has a PHI on the same register AND either:
          (a) ValBlk is directly a PhiBlock, or
          (b) the PHI has 3+ operands (multi-element chain). }
        UsesTestedReg := False;
        if Length(FSF^.Blocks[JmpBlk].Succs) >= 1 then begin
          S := FSF^.Blocks[JmpBlk].Succs[0]; { potential merge block }
          { Follow single-successor chain through LOADBOOL intermediates
            to find the real merge block (same logic as main merge detection) }
          for PhiIdx := 0 to 3 do begin
            if (S < 0) or (S >= Length(FSF^.Blocks)) then Break;
            if Length(FSF^.Blocks[S].Succs) <> 1 then Break;
            HasOnlyJmp := True;
            for J := 0 to High(FSF^.Blocks[S].Nodes) do begin
              ValN := FSF^.Blocks[S].Nodes[J];
              if not (ValN^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP, SSA_LOADBOOL]) then begin
                HasOnlyJmp := False; Break;
              end;
            end;
            if HasOnlyJmp then
              S := FSF^.Blocks[S].Succs[0]
            else
              Break;
          end;
          if (S >= 0) and (S < Length(FSF^.Blocks)) then begin
            for J := 0 to High(FSF^.Blocks[S].Nodes) do begin
              ValN := FSF^.Blocks[S].Nodes[J];
              if (ValN^.Kind = SSA_PHI) and
                 (ValN^.Dest.Reg = N^.OpA.Reg) then begin
                { Accept if ValBlk is directly a PhiBlock }
                for PhiIdx := 0 to High(ValN^.PhiBlocks) do begin
                  if ValN^.PhiBlocks[PhiIdx] = ValBlk then begin
                    UsesTestedReg := True;
                    Break;
                  end;
                end;
                { Also accept if PHI has 3+ operands (multi-element chain) }
                if (not UsesTestedReg) and (Length(ValN^.PhiBlocks) >= 3) then
                  UsesTestedReg := True;
                Break;
              end;
            end;
          end;
        end;
        if not UsesTestedReg then begin
          if FOpts.Debug then
            WriteLn(StdErr, 'TryEmitOrAnd: rejected ValBlk BB', ValBlk,
                    ' - non-TESTSET BRANCH, no PHI at merge for tested reg R',
                    N^.OpA.Reg);
          Exit;
        end;
        { Accept: the TEST feeds a PHI at the merge --> this is a chained
          or/and value expression.  However, the TEST BRANCH itself does NOT
          produce a value - it only tests R(A).  The actual value for the
          or/and arm was produced by a preceding node in this block (e.g.
          GETTABLE for "self[y][x]").  So we only set HasValDef if ValDefNode
          was already assigned by a preceding real node (line 4151-4152).
          We do NOT overwrite ValDefNode with the BRANCH. }
        if ValDefNode <> nil then
          HasValDef := True;
      end;
      Continue;
    end;
    if N^.Kind in [SSA_SETTABLE, SSA_SETGLOBAL, SSA_SETUPVAL, SSA_SETLIST] then Exit;
    { CALL with no return (ImmC=1) or as statement (ImmC=0) is a side-effect }
    if (N^.Kind = SSA_CALL) and (N^.ImmC <= 1) then Exit;
    { CALL with return value: mark as side-effect for BRANCH rejection
      (a CALL in a ValBlk followed by a BRANCH indicates an if-body, not or/and) }
    if (N^.Kind = SSA_CALL) and (N^.ImmC > 1) then
      HasSideEffect := True;
    HasValDef := True;
    ValDefNode := N;  { take the last real node as the value }
  end;

  { Both blocks must converge to the same merge block.
    For simple patterns: JmpBlk and ValBlk share one successor.
    For chained patterns: JmpBlk leads to a merge block, and ValBlk's
    sub-chain eventually reaches the same merge block.  We follow the
    chain from JmpBlk through single-successor blocks (e.g., LOADBOOL
    intermediates) and check if ValBlk also reaches it. }
  if Length(FSF^.Blocks[JmpBlk].Succs) < 1 then Exit;
  MergeIdx := FSF^.Blocks[JmpBlk].Succs[0];
  { Follow single-successor chain from MergeIdx to find the real merge
    (handles LOADBOOL intermediate blocks: JmpBlk-->LOADBOOL-->merge).
    IMPORTANT: Only follow through blocks that are truly empty intermediates
    (LOADBOOL/JMP/PHI/NOP only, no value-defining content like LOADK or
    GETTABLE).  If a block has a PHI + value definition (e.g., LOADK for
    the "or default" pattern), it IS the merge - don't skip it. }
  for Safety := 0 to 3 do begin
    if (MergeIdx < 0) or (MergeIdx >= Length(FSF^.Blocks)) then Break;
    if Length(FSF^.Blocks[MergeIdx].Succs) = 1 then begin
      { Check if this block has value-defining content (not just LOADBOOL/JMP/PHI/NOP) }
      HasOnlyJmp := True;
      for I := 0 to High(FSF^.Blocks[MergeIdx].Nodes) do begin
        N := FSF^.Blocks[MergeIdx].Nodes[I];
        if not (N^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP, SSA_LOADBOOL]) then begin
          HasOnlyJmp := False; Break;
        end;
      end;
      if HasOnlyJmp then
        MergeIdx := FSF^.Blocks[MergeIdx].Succs[0]
      else
        Break;  { Block has real content - this is the merge point }
    end else
      Break;
  end;

  { Check if ValBlk directly converges, or if it has a sub-chain }
  if (Length(FSF^.Blocks[ValBlk].Succs) >= 1) and
     (FSF^.Blocks[ValBlk].Succs[0] = MergeIdx) then begin
    { Direct convergence - simple or/and }
    if not HasValDef then Exit;
  end else begin
    { ValBlk might have a sub-chain (e.g., TEST-->sub-blocks-->MergeIdx).
      Check if the chain eventually reaches MergeIdx.
      We allow this only if ValDefNode exists (there's a value). }
    if not HasValDef then Exit;
    { Verify the sub-chain converges: follow successors of ValBlk's sub-blocks
      up to 8 hops to find MergeIdx. Check both successor paths. }
    HasOnlyJmp := False;  { reuse as "found merge" flag }
    S := ValBlk;
    for I := 0 to 7 do begin
      if (S < 0) or (S >= Length(FSF^.Blocks)) then Break;
      if Length(FSF^.Blocks[S].Succs) = 1 then begin
        S := FSF^.Blocks[S].Succs[0];
        if S = MergeIdx then begin HasOnlyJmp := True; Break; end;
      end else if Length(FSF^.Blocks[S].Succs) >= 2 then begin
        { Check BOTH successors for MergeIdx }
        if FSF^.Blocks[S].Succs[0] = MergeIdx then begin HasOnlyJmp := True; Break; end;
        if FSF^.Blocks[S].Succs[1] = MergeIdx then begin HasOnlyJmp := True; Break; end;
        { Follow first successor to continue the chain }
        S := FSF^.Blocks[S].Succs[0];
        if S = MergeIdx then begin HasOnlyJmp := True; Break; end;
      end else
        Break;
    end;
    if not HasOnlyJmp then Exit;
  end;

  { Find the PHI node at the merge block that combines the two values.
    Prefer a PHI whose Dest.Reg matches the branch's value register:
    - For TESTSET: prefer Dest.Reg (A = result register), then OpA.Reg (B = test register)
    - For TEST: prefer OpA.Reg (test register), then Dest.Reg
    - For EQ/LT/LE: prefer OpA.Reg or OpB.Reg
    Fall back to first PHI if no register-matching one is found. }
  PhiNode := nil;
  HasOnlyJmp := False; { reuse as "found LOADBOOL PHI" flag }
  for I := 0 to High(FSF^.Blocks[MergeIdx].Nodes) do begin
    N := FSF^.Blocks[MergeIdx].Nodes[I];
    if (N^.Kind = SSA_PHI) and (Length(N^.PhiBlocks) >= 2) then begin
      case BranchNode^.RelOp of
        ropTestSet:
          if N^.Dest.Reg = BranchNode^.Dest.Reg then begin
            PhiNode := N; Break;
          end;
        ropTest:
          if N^.Dest.Reg = BranchNode^.OpA.Reg then begin
            PhiNode := N; Break;
          end;
        ropEQ, ropLT, ropLE: begin
          { For comparison branches, prefer the PHI that has LOADBOOL
            operands (the boolean result register), not just any PHI
            matching the comparison operand registers. }
          if PhiNode = nil then
            PhiNode := N; { tentative: first PHI as fallback }
          { Check if this PHI has LOADBOOL source blocks }
          if not HasOnlyJmp then
            for J := 0 to High(N^.PhiBlocks) do begin
              S := N^.PhiBlocks[J];
              if (S >= 0) and (S < Length(FSF^.Blocks)) then
                for PhiIdx := 0 to High(FSF^.Blocks[S].Nodes) do
                  if (FSF^.Blocks[S].Nodes[PhiIdx]^.Kind = SSA_LOADBOOL) and
                     (FSF^.Blocks[S].Nodes[PhiIdx]^.Dest.Reg = N^.Dest.Reg) then begin
                    PhiNode := N;
                    HasOnlyJmp := True; { found best match }
                    Break;
                  end;
              if HasOnlyJmp then Break;
            end;
        end;
      else
        begin PhiNode := N; Break; end;
      end;
      if PhiNode = nil then
        PhiNode := N; { fallback: first PHI }
    end;
  end;

  { A value-expression collapse must have a PHI result to carry the merged
    short-circuit value.  If no PHI exists at the detected merge, this is
    structured control flow (often if/elseif/else inside a loop), not an
    or/and expression.  Continuing with PhiNode=nil only marks blocks emitted
    and silently drops body statements. }
  if PhiNode = nil then begin
    if FOpts.Debug then
      WriteLn(StdErr, 'TryEmitOrAnd: rejected - no PHI result at MergeIdx BB',
              MergeIdx);
    Exit;
  end;

  { Reject if-then-assign patterns: if the ValBlk writes to a register that
    has a PHI at the merge block with the same register number, this is a
    conditional variable update (e.g., "if cond then count=count+1 end"),
    not a genuine or/and value expression.  In real or/and, the condition
    value flows through the JmpBlk, but in if-then-assign the JmpBlk just
    passes through the old value of the variable being modified.

    EXCEPTION: For TESTSET branches, the compiler allocates a temp register
    (R(A) of TESTSET) specifically for the or/and result.  The ValBlk writes
    to the SAME register, and the PHI merges both paths - this IS the or/and
    pattern, so don't reject it.

    NOTE: In Lua 5.4+, the compiler may add a MOVE after a CONCAT/BINOP/UNOP
    to copy the result to the target register.  When ValDefNode is a MOVE,
    look through it to find the underlying value-defining instruction. }
  EffectiveValDef := ValDefNode;
  if (EffectiveValDef <> nil) and (EffectiveValDef^.Kind = SSA_MOVE) then begin
    { Find the node that defines the source register of this MOVE }
    for I := High(FSF^.Blocks[ValBlk].Nodes) downto 0 do begin
      N := FSF^.Blocks[ValBlk].Nodes[I];
      if (N <> EffectiveValDef) and (N^.Dest.Reg = EffectiveValDef^.OpA.Reg) and
         (N^.Kind in [SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then begin
        EffectiveValDef := N;
        Break;
      end;
    end;
  end;
  if (EffectiveValDef <> nil) and
     (EffectiveValDef^.Kind in [SSA_BINOP, SSA_UNOP, SSA_CONCAT]) and
     ((BranchNode^.RelOp <> ropTestSet) or
      (ValDefNode^.Dest.Reg <> BranchNode^.Dest.Reg)) then begin
    { Exception: if the merge PHI has a LOADBOOL operand, this is a boolean
      expression (e.g., "a < b and not c"), not a conditional assignment.
      The LOADBOOL indicates that the false path produces a boolean value,
      which is a hallmark of or/and value expressions. }
    HasOnlyJmp := False; { reuse: LOADBOOL found flag }
    if (MergeIdx >= 0) and (MergeIdx < Length(FSF^.Blocks)) then begin
      for I := 0 to High(FSF^.Blocks[MergeIdx].Nodes) do begin
        N := FSF^.Blocks[MergeIdx].Nodes[I];
        if N^.Kind = SSA_PHI then begin
          for J := 0 to High(N^.PhiBlocks) do begin
            S := N^.PhiBlocks[J];
            if (S >= 0) and (S < Length(FSF^.Blocks)) then begin
              for PhiIdx := 0 to High(FSF^.Blocks[S].Nodes) do
                if FSF^.Blocks[S].Nodes[PhiIdx]^.Kind = SSA_LOADBOOL then begin
                  HasOnlyJmp := True; Break;
                end;
              if HasOnlyJmp then Break;
            end;
          end;
          if HasOnlyJmp then Break;
        end;
      end;
    end;
    if not HasOnlyJmp then begin
      for I := 0 to High(FSF^.Blocks[MergeIdx].Nodes) do begin
        N := FSF^.Blocks[MergeIdx].Nodes[I];
        if (N^.Kind = SSA_PHI) and (N^.Dest.Reg = ValDefNode^.Dest.Reg) then begin
          { The ValBlk modifies a register that is merged at the merge block.
            This is a conditional assignment, not an or/and expression. }
          Exit;
        end;
      end;
    end;
  end;

  { Reject if MergeIdx is a loop latch/tail (has a backward successor).
    Loop-carried PHIs at such blocks are NOT or/and merge points - they
    track variable evolution across loop iterations.  Processing them as
    or/and would silently swallow the conditional assignment in the body. }
  if (MergeIdx >= 0) and (MergeIdx < Length(FSF^.Blocks)) then
    for I := 0 to High(FSF^.Blocks[MergeIdx].Succs) do
      if FSF^.Blocks[MergeIdx].Succs[I] < MergeIdx then begin
        if FOpts.Debug then
          WriteLn(StdErr, 'TryEmitOrAnd: rejected - MergeIdx BB', MergeIdx,
                  ' is loop latch (has backward succ BB',
                  FSF^.Blocks[MergeIdx].Succs[I], ')');
        Exit;
      end;

  { === Multi-operand PHI: 3+ operands for chained or/and expressions ===
    First try negated compound pattern (not (a and b)), then chained handler. }
  if (PhiNode <> nil) and (Length(PhiNode^.PhiBlocks) > 2) then begin
    CombinedExpr := TryBuildNegatedCompoundExpr(PhiNode);
    if CombinedExpr = '' then
      CombinedExpr := TryBuildChainedPhiExpr(PhiNode);
    if CombinedExpr = '' then begin
      { 3+ operand PHI was rejected as or/and chain (e.g., if/then/else merge).
        Do NOT fall through to 2-operand handling - it would incorrectly consume
        blocks that belong to structured if/then/else control flow. }
      if FOpts.Debug then
        WriteLn(StdErr, 'TryEmitOrAnd: 3+ operand PHI rejected by chained handler, aborting');
      Exit;
    end;
    begin
      { Check if the outer branch's contribution is already included in the
        chained PHI expression.  If JmpBlk (or its chain destination) is a
        direct PhiBlock source, then TryBuildChainedPhiExpr already captured
        it.  If JmpBlk leads to a PhiBlock through a shared intermediate
        (e.g., LOADBOOL merge with another path), we need to prepend the
        outer condition ourselves.
        Example: "print(x == 0 or a.first and a.record.field == value)"
        BB0 branches on EQ x 0 --> BB1(JMP-->BB7).  BB7 is a PhiBlock but
        also receives BB5 (from inner comparison), so the outer "x==0" is
        not captured by the chained handler. }
      HasOnlyJmp := False;  { reuse: "outer already included" flag }
      S := JmpBlk;
      for Safety := 0 to 4 do begin
        for I := 0 to High(PhiNode^.PhiBlocks) do
          if PhiNode^.PhiBlocks[I] = S then begin
            { Check that this PhiBlock is exclusively from the outer branch.
              If the block has multiple predecessors, the outer condition
              merges with other paths and isn't individually represented. }
            if Length(FSF^.Blocks[S].Preds) <= 1 then
              HasOnlyJmp := True;
            Break;
          end;
        if HasOnlyJmp then Break;
        { Follow single-successor chain }
        if (S >= 0) and (S < Length(FSF^.Blocks)) and
           (Length(FSF^.Blocks[S].Succs) = 1) then
          S := FSF^.Blocks[S].Succs[0]
        else
          Break;
      end;
      if (not HasOnlyJmp) and (BranchNode <> nil) then begin
        { Outer condition not included - prepend it.
          Determine the raw condition and or/and operator.
          For EQ/LT/LE: use non-inverted comparison.  The operator depends
          on whether JmpBlk = Succs[0] (JMP target) or Succs[1] (skip target)
          and the Invert flag (A field of the instruction):
            JmpBlk = Succs[0]: IsOr = Invert
            JmpBlk = Succs[1]: IsOr = not Invert
          For TEST/TESTSET: IsOr = Invert (C=1 --> or, C=0 --> and). }
        case BranchNode^.RelOp of
          ropEQ, ropLT, ropLE: begin
            CondExpr := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                     BranchNode^.RelOp, False, BranchNode^.PC);
            if (Length(FSF^.Blocks[BranchBlk].Succs) >= 2) and
               (FSF^.Blocks[BranchBlk].Succs[0] = JmpBlk) then
              IsOr := BranchNode^.Invert
            else
              IsOr := not BranchNode^.Invert;
            if IsOr then
              CombinedExpr := CondExpr + ' or ' + StripOuterParens(CombinedExpr)
            else
              CombinedExpr := CondExpr + ' and ' + StripOuterParens(CombinedExpr);
            if FOpts.Debug then
              WriteLn(StdErr, 'TryEmitOrAnd: prepended outer comparison: ', CondExpr,
                      ' op=', BoolToStr(IsOr, 'or', 'and'));
          end;
          ropTest, ropTestSet: begin
            CondExpr := ExprOf(BranchNode^.OpA, BranchNode^.PC);
            IsOr := BranchNode^.Invert;
            if IsOr then
              CombinedExpr := CondExpr + ' or ' + StripOuterParens(CombinedExpr)
            else
              CombinedExpr := CondExpr + ' and ' + StripOuterParens(CombinedExpr);
            if FOpts.Debug then
              WriteLn(StdErr, 'TryEmitOrAnd: prepended outer TEST condition: ', CondExpr,
                      ' op=', BoolToStr(IsOr, 'or', 'and'));
          end;
        end;
      end;
      { Cache the result }
      PhiIdx := NodeIdx(PhiNode^.Dest.Reg, PhiNode^.Dest.Version);
      if (PhiIdx >= 0) and (PhiIdx < Length(FExprStr)) then
        FExprStr[PhiIdx] := CombinedExpr;
      { Mark all intermediate blocks as emitted (but NOT MergeIdx itself,
        since it may contain important nodes like RETURN, CALL, etc.) }
      for I := BranchBlk + 1 to MergeIdx - 1 do
        if (I >= 0) and (I < Length(FSF^.Blocks)) then
          FEmitted[I] := True;
      { Emit non-branch statements from the branch block (e.g.,
        "local value = 'initial'" and "print(value)" before the or/and) }
      FEmitted[BranchBlk] := True;
      for I := 0 to High(FSF^.Blocks[BranchBlk].Nodes) do begin
        N := FSF^.Blocks[BranchBlk].Nodes[I];
        if N^.Kind <> SSA_BRANCH then
          EmitNode(N, BranchBlk);
      end;
      { Emit assignment if the PHI targets a user local or global }
      LHS := '';
      IsChainIntermediate := False;  { reuse as "is global" flag }
      { Check for SETGLOBAL at the merge block }
      for I := 0 to High(FSF^.Blocks[MergeIdx].Nodes) do begin
        N := FSF^.Blocks[MergeIdx].Nodes[I];
        if (N^.Kind = SSA_SETGLOBAL) and (N^.OpA.Reg = PhiNode^.Dest.Reg) then begin
          if (N^.ConstIdx >= 0) and (N^.ConstIdx < Length(FProto^.K)) and
             (FProto^.K[N^.ConstIdx].Kind = lckString) then
            LHS := FProto^.K[N^.ConstIdx].SValue
          else
            LHS := ConstStr(N^.ConstIdx);
          IsChainIntermediate := True;  { is global }
          Break;
        end;
      end;
      if LHS = '' then begin
        if IsUserLocal(PhiNode^.Dest.Reg, PhiNode^.PC) or
           IsUserLocal(PhiNode^.Dest.Reg, PhiNode^.PC + 1) or
           ShouldEmitAsLocal(PhiNode^.Dest.Reg, PhiNode^.PC) then begin
          LHS := LocalNameForEmit(PhiNode^.Dest.Reg, PhiNode^.PC);
        end;
      end;
      if LHS <> '' then begin
        if (not IsChainIntermediate) and NeedsLocalDecl(PhiNode^.Dest.Reg, PhiNode^.PC) then
          EmitLine('local ' + LHS + ' = ' + StripOuterParens(CombinedExpr))
        else
          EmitLine(LHS + ' = ' + StripOuterParens(CombinedExpr));
        PhiIdx := NodeIdx(PhiNode^.Dest.Reg, PhiNode^.Dest.Version);
        if (PhiIdx >= 0) and (PhiIdx < Length(FExprStr)) then
          FExprStr[PhiIdx] := LHS;
      end;
      Result := True;
      Exit;
    end;
  end;

  { Determine or vs and and build condition expression }
  case BranchNode^.RelOp of
    ropTest, ropTestSet: begin
      { C=1 (Invert=true):  truthy values pass through --> "or"
        C=0 (Invert=false): falsy values pass through  --> "and" }
      IsOr := BranchNode^.Invert;
      CondExpr := ExprOf(BranchNode^.OpA, BranchNode^.PC);

      { Reject conditional assignment patterns: "if f() then m = j end"
        In a genuine or/and, the tested register (or TESTSET dest register)
        matches the PHI register.  In a conditional assignment, the TEST register
        (the call result) differs from the PHI register (old variable value).
        For TESTSET: the branch Dest register should match the PHI register.
        For TEST: the branch OpA register should match the PHI register.
        Only apply this for TEST/TESTSET (not comparison). }
      if (PhiNode <> nil) then begin
        if BranchNode^.RelOp = ropTestSet then begin
          { TESTSET writes result to Dest register - check Dest vs PHI }
          if BranchNode^.Dest.Reg <> PhiNode^.Dest.Reg then begin
            if FOpts.Debug then
              WriteLn(StdErr, 'TryEmitOrAnd: rejected - TESTSET dest R',
                      BranchNode^.Dest.Reg, ' <> PHI reg R', PhiNode^.Dest.Reg);
            Exit;
          end;
        end else begin
          { TEST: tested register should match PHI register.
            However, in derived-value chains like "opts and opts.width or 80",
            the TEST is on R0 (opts) and the PHI is on R1 (width).
            The ValBlk uses R0 via GETTABLE to produce R1.
            Also, in "status and yes or no", TEST is on R9 (status) and
            PHI is on R11 - the ValBlk has a BRANCH (sub-chain).
            So: if registers differ, allow if ValBlk reads from the tested
            register OR has a TESTSET BRANCH (sub-chain).  Otherwise reject.
            A plain TEST BRANCH in ValBlk indicates an if-then body with a
            nested condition, NOT a value-producing or/and sub-chain. Only
            TESTSET branches produce values that flow to the merge PHI. }
          if BranchNode^.OpA.Reg <> PhiNode^.Dest.Reg then begin
            UsesTestedReg := False;
            for I := 0 to High(FSF^.Blocks[ValBlk].Nodes) do begin
              ValN := FSF^.Blocks[ValBlk].Nodes[I];
              if ValN^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP] then Continue;
              { Allow if ValBlk has a TESTSET BRANCH (sub-chain --> or/and chain).
                A plain TEST BRANCH is just control flow inside an if-body. }
              if (ValN^.Kind = SSA_BRANCH) and (ValN^.RelOp = ropTestSet) then begin
                UsesTestedReg := True;
                Break;
              end;
              { Check if any operand reads from the tested register }
              if (ValN^.OpA.Reg = BranchNode^.OpA.Reg) or
                 (ValN^.OpB.Reg = BranchNode^.OpA.Reg) then begin
                UsesTestedReg := True;
                Break;
              end;
            end;
            if not UsesTestedReg then begin
              if FOpts.Debug then
                WriteLn(StdErr, 'TryEmitOrAnd: rejected - TEST reg R',
                        BranchNode^.OpA.Reg, ' <> PHI reg R', PhiNode^.Dest.Reg,
                        ' and ValBlk does not use tested reg or have sub-chain');
              Exit;
            end;
          end;
        end;
      end;
    end;
    ropEQ, ropLT, ropLE: begin
      { For comparison branches, reject simple conditional assignments.
        A comparison-based or/and has either:
        (a) A sub-chain in ValBlk (another BRANCH for chain continuation), or
        (b) LOADBOOL somewhere (boolean result of comparison).
        Without either, this is "if cond then x = val end" - the or/and
        collapse is semantically wrong because when the condition is false,
        it assigns false instead of keeping the old value. }
      if (PhiNode <> nil) then begin
        HasOnlyJmp := False;  { reuse: "has sub-chain or LOADBOOL" flag }
        { Check if ValBlk has a BRANCH (sub-chain continuation) }
        for I := 0 to High(FSF^.Blocks[ValBlk].Nodes) do
          if FSF^.Blocks[ValBlk].Nodes[I]^.Kind = SSA_BRANCH then begin
            HasOnlyJmp := True; Break;
          end;
        { If no sub-chain, check for LOADBOOL in ValBlk }
        if not HasOnlyJmp then
          for I := 0 to High(FSF^.Blocks[ValBlk].Nodes) do
            if (FSF^.Blocks[ValBlk].Nodes[I]^.Kind = SSA_LOADBOOL) and
               (FSF^.Blocks[ValBlk].Nodes[I]^.Dest.Reg = PhiNode^.Dest.Reg) then begin
              HasOnlyJmp := True; Break;
            end;
        { If no sub-chain and no LOADBOOL in ValBlk, check merge PHI source blocks }
        if not HasOnlyJmp then
          for I := 0 to High(PhiNode^.PhiBlocks) do begin
            S := PhiNode^.PhiBlocks[I];
            if (S >= 0) and (S < Length(FSF^.Blocks)) then
              for J := 0 to High(FSF^.Blocks[S].Nodes) do
                if (FSF^.Blocks[S].Nodes[J]^.Kind = SSA_LOADBOOL) and
                   (FSF^.Blocks[S].Nodes[J]^.Dest.Reg = PhiNode^.Dest.Reg) then begin
                  HasOnlyJmp := True; Break;
                end;
            if HasOnlyJmp then Break;
          end;
        if not HasOnlyJmp then begin
          if FOpts.Debug then
            WriteLn(StdErr, 'TryEmitOrAnd: rejected comparison branch - conditional assignment on R',
                    PhiNode^.Dest.Reg);
          Exit;
        end;
      end;
      { Comparison branch:
        Succs[0] = JMP block (condition false path)
        Succs[1] = skip target (condition true path)
        JmpBlk = Succs[0] --> false passes through --> "and"
        JmpBlk = Succs[1] --> true passes through  --> "or" }
      if (Length(FSF^.Blocks[BranchBlk].Succs) >= 2) and
         (FSF^.Blocks[BranchBlk].Succs[0] = JmpBlk) then
        IsOr := False
      else
        IsOr := True;
      CondExpr := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                BranchNode^.RelOp, BranchNode^.Invert,
                                BranchNode^.PC);
    end;
  else
    Exit;
  end;

  { Build value expression }
  ValExpr := NodeExpr(ValDefNode);

  if FOpts.Debug then
    WriteLn(StdErr, 'TryEmitOrAnd: CondExpr="', CondExpr,
            '" ValExpr="', ValExpr,
            '" ValDefNode.Kind=', Ord(ValDefNode^.Kind),
            ' ValDefNode.PC=', ValDefNode^.PC);

  { Wrap in parentheses since or/and has lower precedence than .. and other ops.
    This ensures correct grouping when the result is embedded in a larger expression. }
  if IsOr then
    CombinedExpr := '(' + CondExpr + ' or ' + ValExpr + ')'
  else
    CombinedExpr := '(' + CondExpr + ' and ' + ValExpr + ')';

  { Cache the result in FExprStr for the PHI node at the merge block }
  if PhiNode <> nil then begin
    PhiIdx := NodeIdx(PhiNode^.Dest.Reg, PhiNode^.Dest.Version);
    if (PhiIdx >= 0) and (PhiIdx < Length(FExprStr)) then
      FExprStr[PhiIdx] := CombinedExpr;
  end;

  { ---- Chain continuation: extend through multi-level or/and chains ----
    Check if MergeIdx continues into another merge block with a PHI on
    the same register. This handles patterns like:
      (x > 5 and "big") or "small"
    where the first level builds (x > 5 and "big"), and the merge block
    (MergeIdx) defines the "or" default "small", feeding into an outer PHI.

    Strict requirements to prevent false extensions:
    - FinalMerge must have exactly 1 successor (not a branch block)
    - NextMerge's PHI must have exactly 2 operands (not a multi-way chain)
    - One operand must come from a JMP-only block, the other from FinalMerge
    - No back-edges (all PHI sources must be forward)
    - FinalMerge must contain only PHI + a single value definition (no side-effects) }
  FinalMerge := MergeIdx;
  FinalPhiNode := PhiNode;
  Safety := 0;
  while (FinalPhiNode <> nil) and (Safety < 10) do begin
    Inc(Safety);
    { Check if FinalMerge has exactly 1 successor }
    if Length(FSF^.Blocks[FinalMerge].Succs) <> 1 then Break;
    NextMerge := FSF^.Blocks[FinalMerge].Succs[0];
    if (NextMerge <= FinalMerge) or (NextMerge >= Length(FSF^.Blocks)) then Break;

    { Check if NextMerge has a PHI on the same register with 2+ operands }
    NextPhiNode := nil;
    for I := 0 to High(FSF^.Blocks[NextMerge].Nodes) do begin
      N := FSF^.Blocks[NextMerge].Nodes[I];
      if (N^.Kind = SSA_PHI) and (N^.Dest.Reg = FinalPhiNode^.Dest.Reg) and
         (Length(N^.Operands) >= 2) and
         (Length(N^.PhiBlocks) = Length(N^.Operands)) then begin
        NextPhiNode := N; Break;
      end;
    end;
    if NextPhiNode = nil then Break;

    { Verify no back-edges: all PHI sources must be before NextMerge }
    HasSideEffect := False;
    for I := 0 to High(NextPhiNode^.PhiBlocks) do
      if NextPhiNode^.PhiBlocks[I] >= NextMerge then begin
        HasSideEffect := True; Break;
      end;
    if HasSideEffect then Break;

    { Verify that FinalMerge is one of the PHI's source blocks }
    HasSideEffect := True;  { reuse as "valid chain" flag (inverted) }
    for I := 0 to High(NextPhiNode^.PhiBlocks) do begin
      if NextPhiNode^.PhiBlocks[I] = FinalMerge then begin
        HasSideEffect := False;
        Break;
      end;
    end;
    if HasSideEffect then Break;

    { Find the default value defined at FinalMerge (non-PHI, non-JUMP content).
      If any side-effect statement is found, this is not a chain - stop extending. }
    DefaultNode := nil;
    HasSideEffect := False;
    for I := 0 to High(FSF^.Blocks[FinalMerge].Nodes) do begin
      N := FSF^.Blocks[FinalMerge].Nodes[I];
      if N^.Kind in [SSA_PHI, SSA_JUMP, SSA_NOP, SSA_BRANCH] then Continue;
      if N^.Kind in [SSA_SETTABLE, SSA_SETGLOBAL, SSA_SETUPVAL] then begin
        HasSideEffect := True; Break;
      end;
      if (N^.Kind = SSA_CALL) and (N^.ImmC <= 1) then begin
        HasSideEffect := True; Break;
      end;
      { Only accept as chain default if it writes to the SAME register as the chain.
        E.g., a CONCAT writing R1 should not be treated as a default for an R11 chain. }
      if N^.Dest.Reg = FinalPhiNode^.Dest.Reg then
        DefaultNode := N
      else begin
        HasSideEffect := True; Break;  { Different register --> not a chain, stop }
      end;
    end;
    if HasSideEffect or (DefaultNode = nil) then Break;

    { For 3+ operand PHIs at NextMerge, build the FULL chain by incorporating
      all operands from JMP-only source blocks (which have cached or/and
      expressions from earlier TryEmitOrAnd passes).
      The current CombinedExpr represents one arm; other arms come from
      JMP-only blocks that resolved to cached intermediate PHI expressions. }
    if Length(NextPhiNode^.Operands) > 2 then begin
      { Collect all chain arms: iterate over PHI operands.
        Operands from JMP-only blocks represent cached or/and sub-expressions.
        The operand from FinalMerge represents the default value. }
      ValExpr := '';
      for I := 0 to High(NextPhiNode^.PhiBlocks) do begin
        S := NextPhiNode^.PhiBlocks[I];
        if S = FinalMerge then begin
          { This is the default value from FinalMerge }
          Segment := NodeExpr(DefaultNode);
        end else begin
          { Check if this source block is JMP-only with a cached expression }
          HasOnlyJmp := True;
          for PhiIdx := 0 to High(FSF^.Blocks[S].Nodes) do
            if not (FSF^.Blocks[S].Nodes[PhiIdx]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
              HasOnlyJmp := False; Break;
            end;
          if HasOnlyJmp then begin
            { Trace back: find branch ancestor and any cached intermediate PHI }
            Segment := '';
            { Search for cached PHI expression between this block and NextMerge }
            for PhiIdx := S + 1 to NextMerge - 1 do begin
              for J := 0 to High(FSF^.Blocks[PhiIdx].Nodes) do begin
                N := FSF^.Blocks[PhiIdx].Nodes[J];
                if (N^.Kind = SSA_PHI) and
                   (N^.Dest.Reg = NextPhiNode^.Operands[I].Reg) then begin
                  MergeIdx := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
                  if (MergeIdx >= 0) and (MergeIdx < Length(FExprStr)) and (FExprStr[MergeIdx] <> '') then
                    Segment := FExprStr[MergeIdx];
                  Break;
                end;
              end;
              if Segment <> '' then Break;
            end;
            if Segment = '' then
              Segment := ExprOf(NextPhiNode^.Operands[I], NextPhiNode^.PC);
          end else
            Segment := ExprOf(NextPhiNode^.Operands[I], NextPhiNode^.PC);
        end;
        if ValExpr <> '' then
          ValExpr := '(' + ValExpr + ' or ' + Segment + ')'
        else
          ValExpr := Segment;
      end;
      CombinedExpr := ValExpr;
    end else begin
      { Simple 2-operand extension: (CombinedExpr or default)
        Wrap in parentheses so the result is safe inside higher-precedence
        operators like CONCAT (..), arithmetic, etc. }
      ValExpr := NodeExpr(DefaultNode);
      CombinedExpr := '(' + StripOuterParens(CombinedExpr) + ' or ' + ValExpr + ')';
    end;

    if FOpts.Debug then
      WriteLn(StdErr, 'TryEmitOrAnd: chain extension BB', FinalMerge,
              ' --> BB', NextMerge, ' default=', CombinedExpr);

    { Cache at NextMerge's PHI }
    PhiIdx := NodeIdx(NextPhiNode^.Dest.Reg, NextPhiNode^.Dest.Version);
    if (PhiIdx >= 0) and (PhiIdx < Length(FExprStr)) then
      FExprStr[PhiIdx] := CombinedExpr;

    { Mark FinalMerge as emitted (its content is part of the chain) }
    FEmitted[FinalMerge] := True;

    FinalMerge := NextMerge;
    FinalPhiNode := NextPhiNode;
  end;

  { Emit non-branch statements from the branch block }
  FEmitted[BranchBlk] := True;
  for I := 0 to High(FSF^.Blocks[BranchBlk].Nodes) do begin
    N := FSF^.Blocks[BranchBlk].Nodes[I];
    if N^.Kind <> SSA_BRANCH then
      EmitNode(N, BranchBlk);
  end;

  { If the final PHI result is a user-local variable or a parameter being
    reassigned, emit the assignment.  Otherwise the expression is only
    cached for inline use (e.g., SETTABLE).

    EXCEPTION: If the FinalMerge block is a branch block (has 2+ successors),
    this or/and result is likely an intermediate step in a multi-level chain
    like ((sum==2) and self[y][x]) or ((sum==3) and 1) or 0.
    In that case, do NOT emit as a statement - just keep the cached
    expression so the downstream TryEmitOrAnd can build the full chain.

    However, only suppress if the branch at FinalMerge actually tests the
    SAME register as the PHI (i.e., it IS a chain continuation).  If the
    branch tests a DIFFERENT register, this is a standalone or/and that
    happens to be followed by an unrelated if-condition (e.g.,
    valuesTable = (valuesTable or keysTable) followed by if getmetatable(...)). }
  if FinalPhiNode <> nil then begin
    { Skip emission if the merge block contains a FORPREP - the PHI is a
      for-loop control register (start/limit/step).  The expression will be
      inlined by EmitForNumericLoop; emitting a standalone assignment here
      would produce a spurious "tN = expr" before the for statement. }
    for I := 0 to High(FSF^.Blocks[FinalMerge].Nodes) do
      if FSF^.Blocks[FinalMerge].Nodes[I]^.Kind = SSA_FORPREP then begin
        { Just mark blocks as emitted and exit - expression is cached in FExprStr }
        FEmitted[BranchBlk] := True;
        FEmitted[JmpBlk] := True;
        FEmitted[ValBlk] := True;
        for J := ValBlk + 1 to FinalMerge - 1 do
          if (J >= 0) and (J < Length(FSF^.Blocks)) then
            FEmitted[J] := True;
        { Emit non-branch statements from the branch block }
        for J := 0 to High(FSF^.Blocks[BranchBlk].Nodes) do begin
          N := FSF^.Blocks[BranchBlk].Nodes[J];
          if N^.Kind <> SSA_BRANCH then
            EmitNode(N, BranchBlk);
        end;
        Result := True;
        Exit;
      end;

    { Skip emission if this is an intermediate chain result (not user-local
      and merge block continues branching on the SAME register) }
    IsChainIntermediate := False;
    { Check if FinalMerge has a SETGLOBAL consuming the PHI result.
      If so, this is NOT intermediate - the value is consumed by the assignment. }
    HasSideEffect := False;  { reuse as "has consuming SETGLOBAL" flag }
    for I := 0 to High(FSF^.Blocks[FinalMerge].Nodes) do begin
      N := FSF^.Blocks[FinalMerge].Nodes[I];
      if (N^.Kind = SSA_SETGLOBAL) and (N^.OpA.Reg = FinalPhiNode^.Dest.Reg) then begin
        HasSideEffect := True; Break;
      end;
    end;
    if (not HasSideEffect) and
       (Length(FSF^.Blocks[FinalMerge].Succs) >= 2) and
       (not IsUserLocal(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC)) and
       (not IsUserLocal(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC + 1)) and
       (not ShouldEmitAsLocal(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC)) then begin
      { Check if any reachable block within a short range has a PHI on the
        same register - indicating this is an intermediate in a chain that
        a subsequent TryEmitOrAnd call will extend.
        E.g., evolve: BB10 has PHI R12_5, BB14 has PHI R12_7, BB15 has PHI R12_9
        --> this is a chain.  copyTables: merge has PHI R2, but no downstream
        PHI on R2 --> this is a standalone or/and that must be emitted. }
      for I := FinalMerge + 1 to FinalMerge + 20 do begin
        if I >= Length(FSF^.Blocks) then Break;
        for J := 0 to High(FSF^.Blocks[I].Nodes) do begin
          N := FSF^.Blocks[I].Nodes[J];
          if (N^.Kind = SSA_PHI) and (N^.Dest.Reg = FinalPhiNode^.Dest.Reg) then begin
            IsChainIntermediate := True;
            Break;
          end;
        end;
        if IsChainIntermediate then Break;
      end;
    end;
    if IsChainIntermediate then begin
      { Keep the cached CombinedExpr in FExprStr - don't emit assignment }
    end
    else if HasSideEffect then begin
      { HasSideEffect = True means SETGLOBAL consumes the PHI result.
        Emit the global assignment. }
      LHS := '';
      for I := 0 to High(FSF^.Blocks[FinalMerge].Nodes) do begin
        N := FSF^.Blocks[FinalMerge].Nodes[I];
        if (N^.Kind = SSA_SETGLOBAL) and (N^.OpA.Reg = FinalPhiNode^.Dest.Reg) then begin
          if (N^.ConstIdx >= 0) and (N^.ConstIdx < Length(FProto^.K)) and
             (FProto^.K[N^.ConstIdx].Kind = lckString) then
            LHS := FProto^.K[N^.ConstIdx].SValue;
          Break;
        end;
      end;
      if LHS <> '' then begin
        EmitLine(LHS + ' = ' + StripOuterParens(CombinedExpr));
        PhiIdx := NodeIdx(FinalPhiNode^.Dest.Reg, FinalPhiNode^.Dest.Version);
        if (PhiIdx >= 0) and (PhiIdx < Length(FExprStr)) then
          FExprStr[PhiIdx] := LHS;
      end;
    end
    else if IsUserLocal(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC) or
       IsUserLocal(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC + 1) or
       ShouldEmitAsLocal(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC) or
       ShouldEmitTemp(FinalPhiNode^.Dest.Reg, FinalPhiNode^.Dest.Version,
                      FinalPhiNode^.PC) then begin
      if IsUserLocal(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC) or
         IsUserLocal(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC + 1) or
         ShouldEmitAsLocal(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC) then
        LHS := LocalNameForEmit(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC)
      else
        LHS := TempName(FinalPhiNode^.Dest.Reg);
      if LHS <> '' then begin
        { Check for parallel assignment: if FinalMerge block also has a MOVE
          consuming a previously cached or/and expression (from a temp register),
          combine into a multi-assign like "p, a = p or d * 0.3, a or 0".
          Pattern: TESTSET R_temp←R_target1 ... PHI R_temp ... TEST R_target2 ...
                   PHI R_target2 + MOVE R_target1←R_temp at FinalMerge. }
        Segment := '';  { reuse: parallel LHS }
        ValExpr := '';  { reuse: parallel RHS }
        for I := 0 to High(FSF^.Blocks[FinalMerge].Nodes) do begin
          N := FSF^.Blocks[FinalMerge].Nodes[I];
          if (N^.Kind = SSA_MOVE) and (N <> FinalPhiNode) then begin
            J := NodeIdx(N^.OpA.Reg, N^.OpA.Version);
            if (J >= 0) and (J < Length(FExprStr)) and (FExprStr[J] <> '') and
               ((Pos(' or ', FExprStr[J]) > 0) or (Pos(' and ', FExprStr[J]) > 0)) then begin
              { MOVE source has a cached or/and expression - check if MOVE dest
                is a user local or parameter }
              if IsUserLocal(N^.Dest.Reg, N^.PC) or
                 IsUserLocal(N^.Dest.Reg, N^.PC + 1) then begin
                Segment := LocalNameForEmit(N^.Dest.Reg, N^.PC);
                ValExpr := FExprStr[J];
                { Mark the MOVE as inlined to prevent double emission }
                S := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
                if (S >= 0) and (S < Length(FInlined)) then
                  FInlined[S] := True;
                Break;
              end;
            end;
          end;
        end;
        if (Segment <> '') and (ValExpr <> '') then begin
          { Emit parallel assignment: target1, target2 = expr1, expr2 }
          EmitLine(Segment + ', ' + LHS + ' = ' +
                   StripOuterParens(ValExpr) + ', ' +
                   StripOuterParens(CombinedExpr));
        end else begin
          if NeedsLocalDecl(FinalPhiNode^.Dest.Reg, FinalPhiNode^.PC) then
            EmitLine('local ' + LHS + ' = ' + StripOuterParens(CombinedExpr))
          else
            EmitLine(LHS + ' = ' + StripOuterParens(CombinedExpr));
        end;
        { After emitting the assignment, clear the cached expression so
          subsequent references to this variable use the local name instead
          of re-expanding the full or/and expression. }
        PhiIdx := NodeIdx(FinalPhiNode^.Dest.Reg, FinalPhiNode^.Dest.Version);
        if (PhiIdx >= 0) and (PhiIdx < Length(FExprStr)) then
          FExprStr[PhiIdx] := LHS;
      end;
    end;
  end;

  { Mark JmpBlk, ValBlk, and any intermediate blocks in the sub-chain as emitted }
  FEmitted[JmpBlk] := True;
  FEmitted[ValBlk] := True;
  { Mark blocks between ValBlk+1 and FinalMerge-1 as emitted (sub-chain blocks) }
  for I := ValBlk + 1 to FinalMerge - 1 do begin
    if (I >= 0) and (I < Length(FSF^.Blocks)) then
      FEmitted[I] := True;
  end;

  if FOpts.Debug then
    WriteLn(StdErr, 'TryEmitOrAnd: success - emitted or/and for BB', BranchBlk,
            ' JmpBlk=BB', JmpBlk, ' ValBlk=BB', ValBlk, ' MergeIdx=BB', MergeIdx,
            ' FinalMerge=BB', FinalMerge);

  Result := True;
end;

{ ======================================================================
  TryCacheBranchValueSelect - detect short-circuit condition chains whose
  result is consumed by a SETTABLE at the merge block.

  Lua emits expressions such as:
    tbl.x = cond and value or fallback

  as branch-only/value-only blocks ending in a PHI used by SETTABLE.  If we
  treat those branches structurally, the emitter prints empty if/else paths
  and then loses the real selected value.  This recognizer caches the selected
  expression on the final PHI and leaves the merge block itself un-emitted so
  normal SETTABLE/CALL emission continues from there.
  ====================================================================== }
function TDecompiler.TryCacheBranchValueSelect(BranchBlk, TrueBlk,
  FalseBlk: Integer): Boolean;
var
  BranchNode, PhiNode, SetNode: PSSANode;
  MergeIdx, I, J, PhiIdx: Integer;
  SelectedIdx, DefaultIdx: Integer;
  CondExpr, SelectedVal, DefaultVal, CombinedExpr: AnsiString;
  Visited: array of Boolean;

  function FindBranchNode(Blk: Integer): PSSANode;
  var
    K: Integer;
  begin
    Result := nil;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) then Exit;
    for K := 0 to High(FSF^.Blocks[Blk].Nodes) do
      if FSF^.Blocks[Blk].Nodes[K]^.Kind = SSA_BRANCH then begin
        Result := FSF^.Blocks[Blk].Nodes[K];
        Exit;
      end;
  end;

  function IsPureValueBlock(Blk: Integer): Boolean;
  var
    K: Integer;
    N: PSSANode;
  begin
    Result := False;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) then Exit;
    for K := 0 to High(FSF^.Blocks[Blk].Nodes) do begin
      N := FSF^.Blocks[Blk].Nodes[K];
      case N^.Kind of
        SSA_PHI, SSA_NOP, SSA_JUMP, SSA_BRANCH,
        SSA_MOVE, SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
        SSA_GETUPVAL, SSA_GETGLOBAL, SSA_GETTABLE,
        SSA_BINOP, SSA_UNOP, SSA_CONCAT:
          ;
      else
        Exit;
      end;
    end;
    Result := True;
  end;

  function NegateCond(const S: AnsiString): AnsiString;
  begin
    if S = '' then
      Result := ''
    else if S = 'true' then
      Result := 'false'
    else if S = 'false' then
      Result := 'true'
    else
      Result := InvertAtom(StripOuterParens(S));
  end;

  function CondForSucc(BNode: PSSANode; SuccIdx: Integer): AnsiString;
  var
    SkipCond, TestExpr: AnsiString;
  begin
    Result := '';
    if BNode = nil then Exit;
    case BNode^.RelOp of
      ropEQ, ropLT, ropLE:
        SkipCond := BuildCompare(BNode^.OpA, BNode^.OpB,
                                  BNode^.RelOp, BNode^.Invert,
                                  BNode^.PC);
      ropTest, ropTestSet: begin
        TestExpr := ExprOf(BNode^.OpA, BNode^.PC);
        if BNode^.Invert then
          SkipCond := NegateCond(TestExpr)
        else
          SkipCond := TestExpr;
      end;
    else
      Exit;
    end;

    { In the CFG, Succs[1] is the comparison/test skip target; Succs[0] is
      fall-through to the JMP instruction. }
    if SuccIdx = 1 then
      Result := SkipCond
    else
      Result := NegateCond(SkipCond);
  end;

  function NeedsParens(const S: AnsiString): Boolean;
  begin
    Result := (Pos(' or ', S) > 0) or (Pos(' and ', S) > 0);
  end;

  function ParenIfNeeded(const S: AnsiString): AnsiString;
  begin
    Result := StripOuterParens(S);
    if NeedsParens(Result) then
      Result := '(' + Result + ')';
  end;

  function AndCond(const A, B: AnsiString): AnsiString;
  var
    LA, LB: AnsiString;
  begin
    LA := StripOuterParens(A);
    LB := StripOuterParens(B);
    if (LA = '') or (LB = '') then begin Result := ''; Exit; end;
    if LA = 'true' then begin Result := LB; Exit; end;
    if LB = 'true' then begin Result := LA; Exit; end;
    if (LA = 'false') or (LB = 'false') then begin Result := 'false'; Exit; end;
    Result := ParenIfNeeded(LA) + ' and ' + ParenIfNeeded(LB);
  end;

  function OrCond(const A, B: AnsiString): AnsiString;
  var
    LA, LB: AnsiString;
  begin
    LA := StripOuterParens(A);
    LB := StripOuterParens(B);
    if LA = '' then begin Result := LB; Exit; end;
    if LB = '' then begin Result := LA; Exit; end;
    if (LA = 'true') or (LB = 'true') then begin Result := 'true'; Exit; end;
    if LA = 'false' then begin Result := LB; Exit; end;
    if LB = 'false' then begin Result := LA; Exit; end;
    Result := ParenIfNeeded(LA) + ' or ' + ParenIfNeeded(LB);
  end;

  function SimplifyAbsorption(const S: AnsiString): AnsiString;
  var
    P, Q: Integer;
    A, Inside, NegA, B: AnsiString;
  begin
    Result := S;
    P := Pos(' or (', S);
    if (P <= 1) or (Length(S) < 2) or (S[Length(S)] <> ')') then Exit;
    A := Copy(S, 1, P - 1);
    Inside := Copy(S, P + 5, Length(S) - (P + 5));
    Q := Pos(' and ', Inside);
    if Q <= 1 then Exit;
    NegA := Copy(Inside, 1, Q - 1);
    B := Copy(Inside, Q + 5, Length(Inside) - (Q + 4));
    if NegA = NegateCond(A) then
      Result := A + ' or ' + B;
  end;

  function IsValueTruthBranch(BNode: PSSANode;
    const SelectedRef: TSSARef): Boolean;
  begin
    Result := (BNode <> nil) and
              (BNode^.RelOp in [ropTest, ropTestSet]) and
              RefEqual(BNode^.OpA, SelectedRef);
  end;

  function PathCondTo(Blk, TargetBlk, MergeBlk, Depth: Integer;
    const SelectedRef: TSSARef): AnsiString;
  var
    BN: PSSANode;
    SI, Succ: Integer;
    EdgeCond, SubCond, Term: AnsiString;
  begin
    Result := '';
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) then Exit;
    if Depth > 48 then Exit;
    if Blk = TargetBlk then begin Result := 'true'; Exit; end;
    if Blk = MergeBlk then Exit;
    if Visited[Blk] then Exit;
    if (Blk <> BranchBlk) and (not IsPureValueBlock(Blk)) then Exit;

    Visited[Blk] := True;
    try
      BN := FindBranchNode(Blk);
      if (BN <> nil) and (Length(FSF^.Blocks[Blk].Succs) >= 2) then begin
        for SI := 0 to 1 do begin
          Succ := FSF^.Blocks[Blk].Succs[SI];
          SubCond := PathCondTo(Succ, TargetBlk, MergeBlk, Depth + 1,
                                SelectedRef);
          if SubCond = '' then Continue;
          if IsValueTruthBranch(BN, SelectedRef) then
            EdgeCond := 'true'
          else
            EdgeCond := CondForSucc(BN, SI);
          Term := AndCond(EdgeCond, SubCond);
          Result := OrCond(Result, Term);
        end;
      end
      else if Length(FSF^.Blocks[Blk].Succs) = 1 then
        Result := PathCondTo(FSF^.Blocks[Blk].Succs[0], TargetBlk,
                             MergeBlk, Depth + 1, SelectedRef);
    finally
      Visited[Blk] := False;
    end;
    Result := SimplifyAbsorption(Result);
  end;

begin
  Result := False;
  if (BranchBlk < 0) or (BranchBlk >= Length(FSF^.Blocks)) then Exit;
  if (TrueBlk < 0) or (FalseBlk < 0) then Exit;

  BranchNode := FindBranchNode(BranchBlk);
  if BranchNode = nil then Exit;

  MergeIdx := FindMerge(BranchBlk, TrueBlk, FalseBlk);
  if (MergeIdx <= BranchBlk) or (MergeIdx >= Length(FSF^.Blocks)) then Exit;

  { Keep this recognizer conservative: every consumed arm must be pure value
    plumbing.  Side-effecting bodies still belong to EmitIfRegion. }
  for I := BranchBlk + 1 to MergeIdx - 1 do
    if not IsPureValueBlock(I) then
      Exit;

  PhiNode := nil;
  SetNode := nil;
  for I := 0 to High(FSF^.Blocks[MergeIdx].Nodes) do begin
    if FSF^.Blocks[MergeIdx].Nodes[I]^.Kind <> SSA_SETTABLE then Continue;
    SetNode := FSF^.Blocks[MergeIdx].Nodes[I];
    for J := 0 to High(FSF^.Blocks[MergeIdx].Nodes) do
      if (FSF^.Blocks[MergeIdx].Nodes[J]^.Kind = SSA_PHI) and
         RefEqual(FSF^.Blocks[MergeIdx].Nodes[J]^.Dest, SetNode^.OpC) then begin
        PhiNode := FSF^.Blocks[MergeIdx].Nodes[J];
        Break;
      end;
    if PhiNode <> nil then Break;
  end;
  if (PhiNode = nil) or (SetNode = nil) then Exit;
  if (Length(PhiNode^.Operands) <> 2) or (Length(PhiNode^.PhiBlocks) <> 2) then
    Exit;

  SelectedIdx := 0;
  DefaultIdx := 1;
  SetLength(Visited, Length(FSF^.Blocks));
  CondExpr := PathCondTo(BranchBlk, PhiNode^.PhiBlocks[SelectedIdx],
                         MergeIdx, 0, PhiNode^.Operands[SelectedIdx]);
  if CondExpr = '' then begin
    SelectedIdx := 1;
    DefaultIdx := 0;
    CondExpr := PathCondTo(BranchBlk, PhiNode^.PhiBlocks[SelectedIdx],
                           MergeIdx, 0, PhiNode^.Operands[SelectedIdx]);
  end;
  CondExpr := SimplifyAbsorption(CondExpr);
  if (CondExpr = '') or (CondExpr = 'true') or (CondExpr = 'false') then Exit;

  SelectedVal := ExprOf(PhiNode^.Operands[SelectedIdx], PhiNode^.PC);
  DefaultVal := ExprOf(PhiNode^.Operands[DefaultIdx], PhiNode^.PC);
  if (SelectedVal = '') or (DefaultVal = '') or (SelectedVal = DefaultVal) then
    Exit;

  CombinedExpr := '(' + ParenIfNeeded(CondExpr) + ' and ' +
                  ParenIfNeeded(SelectedVal) + ' or ' +
                  ParenIfNeeded(DefaultVal) + ')';
  PhiIdx := NodeIdx(PhiNode^.Dest.Reg, PhiNode^.Dest.Version);
  if (PhiIdx < 0) or (PhiIdx >= Length(FExprStr)) then Exit;
  FExprStr[PhiIdx] := CombinedExpr;

  { Emit prefix statements in the branch block, then consume only the value
    selection arms.  Leave MergeIdx available for its SETTABLE and any later
    statements such as CALL/table.insert. }
  FEmitted[BranchBlk] := True;
  for I := 0 to High(FSF^.Blocks[BranchBlk].Nodes) do
    if FSF^.Blocks[BranchBlk].Nodes[I]^.Kind <> SSA_BRANCH then
      EmitNode(FSF^.Blocks[BranchBlk].Nodes[I], BranchBlk);
  for I := BranchBlk + 1 to MergeIdx - 1 do
    FEmitted[I] := True;

  if FOpts.Debug then
    WriteLn(StdErr, 'TryCacheBranchValueSelect: BB', BranchBlk,
            ' cached PHI R', PhiNode^.Dest.Reg, '_', PhiNode^.Dest.Version,
            ' = ', CombinedExpr, ' Merge=BB', MergeIdx);
  Result := True;
end;

{ ======================================================================
  TryBuildComparisonExpr - detect LOADBOOL comparison patterns at PHI level
  ====================================================================== }

function TDecompiler.TryBuildComparisonExpr(PhiNode: PSSANode): AnsiString;
{ Detect the pattern:
    BB_branch: BRANCH (comparison) --> BB_jmp, BB_false
    BB_jmp: JMP --> BB_true
    BB_false: LOADBOOL R = false (skip) --> BB_merge
    BB_true: LOADBOOL R = true --> BB_merge
    BB_merge: PHI R := phi(false, true)
  Emit the comparison expression directly. }
var
  Blk0, Blk1: Integer;
  Node0, Node1: PSSANode;
  BoolVal0, BoolVal1: Integer;  { 0 or 1 }
  TrueBlk, FalseBlk: Integer;
  BranchBlk: Integer;
  BranchNode: PSSANode;
  I, J: Integer;
  InvertCmp: Boolean;
begin
  Result := '';
  if Length(PhiNode^.Operands) <> 2 then Exit;
  if Length(PhiNode^.PhiBlocks) <> 2 then Exit;

  Blk0 := PhiNode^.PhiBlocks[0];
  Blk1 := PhiNode^.PhiBlocks[1];

  { Find the defining LOADBOOL nodes for each operand }
  Node0 := nil;
  Node1 := nil;
  for I := 0 to High(FSF^.AllNodes) do begin
    if RefEqual(FSF^.AllNodes[I]^.Dest, PhiNode^.Operands[0]) then
      Node0 := FSF^.AllNodes[I];
    if RefEqual(FSF^.AllNodes[I]^.Dest, PhiNode^.Operands[1]) then
      Node1 := FSF^.AllNodes[I];
  end;

  { Both operands must be LOADBOOL }
  if (Node0 = nil) or (Node0^.Kind <> SSA_LOADBOOL) then Exit;
  if (Node1 = nil) or (Node1^.Kind <> SSA_LOADBOOL) then Exit;

  BoolVal0 := Node0^.ImmA;  { 0=false, nonzero=true }
  BoolVal1 := Node1^.ImmA;

  { One must be true (1) and the other false (0) }
  if not ((BoolVal0 = 0) and (BoolVal1 <> 0)) and
     not ((BoolVal0 <> 0) and (BoolVal1 = 0)) then Exit;

  { Identify which block contributes true and which contributes false }
  if BoolVal1 <> 0 then begin
    TrueBlk := Blk1;
    FalseBlk := Blk0;
  end else begin
    TrueBlk := Blk0;
    FalseBlk := Blk1;
  end;

  { Find the branch block: the common predecessor that has a BRANCH comparison.
    For the LOADBOOL pattern, the false block is reached from the branch directly,
    and the true block is reached via a JMP from the branch's other successor.
    The branch block is the predecessor of the false block's predecessor,
    or more reliably, look for a BRANCH in the predecessors' predecessors. }

  { The false block (LOADBOOL false, skip) is a direct successor of the branch block.
    The true block (LOADBOOL true) is reached via the branch's JMP path.
    So: branch_block is a predecessor of FalseBlk that contains a BRANCH node.
    When FalseBlk has multiple predecessors (e.g., compound conditions where
    both "type≠number" and "duration≤0" lead to LOADBOOL false), we must
    search all predecessors to find the one with a BRANCH. }
  BranchBlk := -1;
  BranchNode := nil;
  for I := 0 to High(FSF^.Blocks[FalseBlk].Preds) do begin
    BranchBlk := FSF^.Blocks[FalseBlk].Preds[I];
    if (BranchBlk >= 0) and (BranchBlk < Length(FSF^.Blocks)) then begin
      for J := High(FSF^.Blocks[BranchBlk].Nodes) downto 0 do begin
        if FSF^.Blocks[BranchBlk].Nodes[J]^.Kind = SSA_BRANCH then begin
          BranchNode := FSF^.Blocks[BranchBlk].Nodes[J]; Break;
        end;
      end;
      if BranchNode <> nil then Break;  { found a predecessor with BRANCH }
    end;
  end;
  if (BranchBlk < 0) or (BranchNode = nil) then Exit;
  if not (BranchNode^.RelOp in [ropEQ, ropLT, ropLE]) then Exit;

  { The BRANCH encodes a comparison (LT/LE/EQ).
    The branch's "true" successor (fall-through = skip the JMP) goes to FalseBlk.
    The branch's "false" successor (the JMP path) eventually reaches TrueBlk.
    So the comparison result is INVERTED relative to the original comparison:
    When comparison is true --> skip JMP --> go to FalseBlk --> LOADBOOL false
    When comparison is false --> do JMP --> go to TrueBlk --> LOADBOOL true

    Wait, let's re-examine: LT 1 x y with A=1 means:
      if (x < y) != 1 --> skip next (JMP)
    So if x<y is TRUE: (true != 1) is false --> do NOT skip --> execute JMP --> reach TrueBlk
    If x<y is FALSE: (false != 1) is true --> skip JMP --> reach FalseBlk

    Actually: the Invert field on the BRANCH node captures this.
    BRANCH with Invert=False: "if condition then goto true_succ else goto false_succ"
    The BRANCH node's Invert=True means the test is already inverted.

    For the LOADBOOL pattern:
    - Comparison TRUE --> JMP path --> TrueBlk (LOADBOOL true) --> correct
    - Comparison FALSE --> skip JMP --> FalseBlk (LOADBOOL false) --> correct

    So the LOADBOOL true matches when the comparison is true.
    The branch's successor order: succs[0] = JMP block, succs[1] = skip block.
    If the JMP block eventually leads to TrueBlk, the comparison naturally
    produces the correct boolean. No extra inversion needed. }

  { Build the comparison expression from the BRANCH node.
    In the LOADBOOL pattern, the Invert flag is opposite to the return
    semantics: Invert=True means "skip JMP if NOT condition" which leads
    to FalseBlk. The JMP path (condition TRUE) leads to TrueBlk.
    So we negate the Invert flag to get the correct comparison expression. }
  InvertCmp := not BranchNode^.Invert;
  Result := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                          BranchNode^.RelOp, InvertCmp,
                          BranchNode^.PC);
end;

{ ======================================================================
  TryBuildOrAndExpr - detect or/and patterns at PHI expression level
  ====================================================================== }

function TDecompiler.TryBuildOrAndExpr(PhiNode: PSSANode): AnsiString;
var
  Blk0, Blk1: Integer;
  IsJmp0, IsJmp1: Boolean;
  I, J: Integer;
  JmpBlk, ValBlk: Integer;
  BranchNode: PSSANode;
  BranchBlk: Integer;
  CondExpr, ValExpr: AnsiString;
  IsOr: Boolean;
  PhiBlkIdx: Integer;
  N: PSSANode;
  CondOperand, ValOperand: TSSARef;
  CachedIdx: Integer;
  FoundCached: Boolean;
begin
  Result := '';
  if (Length(PhiNode^.Operands) <> 2) or (Length(PhiNode^.PhiBlocks) <> 2) then
    Exit;

  Blk0 := PhiNode^.PhiBlocks[0];
  Blk1 := PhiNode^.PhiBlocks[1];

  if (Blk0 < 0) or (Blk0 >= Length(FSF^.Blocks)) or
     (Blk1 < 0) or (Blk1 >= Length(FSF^.Blocks)) then Exit;

  { Check which predecessor is a JMP-only block }
  IsJmp0 := True;
  for I := 0 to High(FSF^.Blocks[Blk0].Nodes) do
    if not (FSF^.Blocks[Blk0].Nodes[I]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
      IsJmp0 := False; Break;
    end;

  IsJmp1 := True;
  for I := 0 to High(FSF^.Blocks[Blk1].Nodes) do
    if not (FSF^.Blocks[Blk1].Nodes[I]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
      IsJmp1 := False; Break;
    end;

  { Exactly one should be JMP-only for or/and pattern }
  if IsJmp0 = IsJmp1 then Exit;

  if IsJmp0 then begin
    JmpBlk := Blk0;
    ValBlk := Blk1;
    CondOperand := PhiNode^.Operands[0]; { passed through JMP }
    ValOperand := PhiNode^.Operands[1];  { defined in value block }
  end else begin
    JmpBlk := Blk1;
    ValBlk := Blk0;
    CondOperand := PhiNode^.Operands[1];
    ValOperand := PhiNode^.Operands[0];
  end;

  { Find the common branch ancestor: a block that has both JmpBlk and ValBlk
    as successors (directly or via a single intermediate) }
  BranchBlk := -1;
  BranchNode := nil;
  for I := 0 to High(FSF^.Blocks) do begin
    if Length(FSF^.Blocks[I].Succs) >= 2 then begin
      if ((FSF^.Blocks[I].Succs[0] = JmpBlk) and (FSF^.Blocks[I].Succs[1] = ValBlk)) or
         ((FSF^.Blocks[I].Succs[0] = ValBlk) and (FSF^.Blocks[I].Succs[1] = JmpBlk)) then begin
        BranchBlk := I;
        Break;
      end;
    end;
  end;

  if BranchBlk < 0 then Exit;

  { Find the BRANCH node in the ancestor }
  for I := 0 to High(FSF^.Blocks[BranchBlk].Nodes) do
    if FSF^.Blocks[BranchBlk].Nodes[I]^.Kind = SSA_BRANCH then begin
      BranchNode := FSF^.Blocks[BranchBlk].Nodes[I]; Break;
    end;
  if BranchNode = nil then Exit;

  { Find which block the PHI lives in }
  PhiBlkIdx := -1;
  for I := 0 to High(FSF^.Blocks) do
    for J := 0 to High(FSF^.Blocks[I].Nodes) do
      if FSF^.Blocks[I].Nodes[J] = PhiNode then begin
        PhiBlkIdx := I; Break;
      end;

  { Determine or vs and based on branch type and which successor is the JMP block }
  case BranchNode^.RelOp of
    ropTest, ropTestSet: begin
      { TEST C=1 (Invert=true): truthy values pass through --> "or"
        TEST C=0 (Invert=false): falsy values pass through --> "and"
        The JMP block passes the condition through. }
      IsOr := BranchNode^.Invert;
      CondExpr := ExprOf(BranchNode^.OpA, BranchNode^.PC);

      { Reject conditional assignment patterns.
        In a genuine or/and expression (y = cond and val), the JMP-side
        operand carries the CONDITION value, so its register matches the
        branch's test register.  In a conditional assignment
        (if f() then m = j end), the JMP-side operand carries the OLD
        variable value, which is on a DIFFERENT register than the branch.
        Reject the pattern if the JMP operand register differs from the
        branch test register.

        EXCEPTION 1: For TESTSET, the destination register (R(A)) differs
        from the test register (R(B) in OpA).  The PHI CondOperand will have
        the TESTSET destination register, so check against Dest.Reg instead.

        EXCEPTION 2: If the ValBlk contains a BRANCH node (sub-chain),
        this is part of a multi-level or/and chain like "status and yes or no".
        In that case, the TEST register differs from the PHI register because
        the compiler uses TEST (not TESTSET) when the condition value itself
        isn't needed in the result register.  Allow the pattern. }
      if (CondOperand.Reg <> BranchNode^.OpA.Reg) and
         ((BranchNode^.RelOp <> ropTestSet) or
          (CondOperand.Reg <> BranchNode^.Dest.Reg)) then begin
        { Check if ValBlk has a BRANCH --> sub-chain, which means or/and chain }
        FoundCached := False;  { reuse as "has branch in ValBlk" flag }
        for I := 0 to High(FSF^.Blocks[ValBlk].Nodes) do
          if FSF^.Blocks[ValBlk].Nodes[I]^.Kind = SSA_BRANCH then begin
            FoundCached := True; Break;
          end;
        if not FoundCached then Exit; { No branch --> conditional assignment }
      end;
    end;
    ropEQ, ropLT, ropLE: begin
      { For comparison branches:
        Succs[0] = JMP block (fall-through = condition FALSE path)
        Succs[1] = skip target (condition TRUE path)
        "and" pattern: condition false --> pass through --> JmpBlk = Succs[0]
        "or"  pattern: condition true  --> pass through --> JmpBlk = Succs[1] }
      if FSF^.Blocks[BranchBlk].Succs[0] = JmpBlk then
        IsOr := False  { "and" pattern }
      else
        IsOr := True;  { "or" pattern }
      CondExpr := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                BranchNode^.RelOp, BranchNode^.Invert,
                                BranchNode^.PC);
    end;
  else
    Exit;
  end;

  { Check if there's a cached chain expression from an intermediate PHI
    between BranchBlk and PhiBlkIdx. This handles cases like:
    (self[y][x] > 0 and ALIVE) or DEAD - where the inner "and ALIVE" was
    already resolved by TryEmitOrAnd and cached at an intermediate PHI.
    Take the FIRST match (closest to BranchBlk). }
  if PhiBlkIdx >= 0 then begin
    FoundCached := False;
    for I := BranchBlk + 1 to PhiBlkIdx - 1 do begin
      if FoundCached then Break;
      for J := 0 to High(FSF^.Blocks[I].Nodes) do begin
        N := FSF^.Blocks[I].Nodes[J];
        if (N^.Kind = SSA_PHI) and (N^.Dest.Reg = CondOperand.Reg) then begin
          CachedIdx := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
          if (CachedIdx >= 0) and (CachedIdx < Length(FExprStr)) and (FExprStr[CachedIdx] <> '') then begin
            CondExpr := FExprStr[CachedIdx];
            FoundCached := True;
            Break;
          end;
        end;
      end;
    end;
  end;

  { Build value expression from the operand in the value block }
  ValExpr := ExprOf(ValOperand, PhiNode^.PC);

  { Safety check: if condition and value resolve to the same user-local name,
    this is just a normal if/else re-assignment, not a real or/and expression.
    e.g., "y" reassigned in if-body --> PHI merges old y and new y --> not "y or y" }
  if CondExpr = ValExpr then Exit;

  { Wrap in parentheses since or/and has lower precedence than .. and other operators.
    The caller (ExprOf) may embed this result inside a CONCAT, BINOP, etc.
    CALL argument consumers strip outer parens via StripOuterParens. }
  if IsOr then
    Result := '(' + CondExpr + ' or ' + ValExpr + ')'
  else
    Result := '(' + CondExpr + ' and ' + ValExpr + ')';
end;

{ ======================================================================
  TryBuildNegatedCompoundExpr - detect "not (a and b)" / "not (a or b)"
  ======================================================================

  Pattern: PHI operands mix LOADBOOL constants + one UNOP[not] value.
  Dead blocks (from LOADBOOL pairs with no predecessors) are filtered out.

  For "not (a and b and c)":
    TEST a C=0: a falsy --> JMP --> LOADBOOL true
    TEST b C=0: b falsy --> JMP --> LOADBOOL true
    NOT c --> value block
    PHI(true, true, not_c) plus dead LOADBOOL false blocks

  For "not (a or b or c)":
    TEST a C=1: a truthy --> JMP --> LOADBOOL false
    TEST b C=1: b truthy --> JMP --> LOADBOOL false
    NOT c --> value block
    PHI(false, false, not_c) plus dead LOADBOOL true blocks }

function TDecompiler.TryBuildNegatedCompoundExpr(PhiNode: PSSANode): AnsiString;
var
  NOperands, I, J, K, PhiBlkIdx: Integer;
  SrcBlk, PredBlk, BranchBlk: Integer;
  { Live operand tracking }
  LiveIdx: array of Integer;  { indices into PhiNode^.Operands }
  NLive: Integer;
  { Per-live-operand classification }
  DefNode: PSSANode;
  IsLB: array of Boolean;     { is LOADBOOL }
  LBVal: array of Boolean;    { LOADBOOL value (true/false) }
  IsNot: array of Boolean;    { is UNOP[not] }
  NLoadBool, NNotOp: Integer;
  NotOpIdx: Integer;          { index in LiveIdx of the UNOP[not] operand }
  ExpectedVal: Boolean;
  { Branch tracing }
  BranchNode, N: PSSANode;
  TracedBlk, M: Integer;
  IsJmpBlock: Boolean;
  { Expression building }
  InnerParts: array of AnsiString;
  NInner: Integer;
  NotArgExpr, InnerExpr: AnsiString;
  TestC: Integer;
begin
  Result := '';
  NOperands := Length(PhiNode^.Operands);
  if NOperands < 2 then Exit;
  if Length(PhiNode^.PhiBlocks) <> NOperands then Exit;

  Inc(FExprDepth);
  if FExprDepth > 50 then begin
    Dec(FExprDepth);
    Exit;
  end;
  try

  { Find PHI block }
  PhiBlkIdx := -1;
  for I := 0 to High(FSF^.Blocks) do
    for J := 0 to High(FSF^.Blocks[I].Nodes) do
      if FSF^.Blocks[I].Nodes[J] = PhiNode then begin
        PhiBlkIdx := I; Break;
      end;
  if PhiBlkIdx < 0 then Exit;

  { Skip loop-header PHIs }
  for I := 0 to NOperands - 1 do
    if PhiNode^.PhiBlocks[I] >= PhiBlkIdx then Exit;

  { Filter dead operands: non-entry blocks with no predecessors }
  NLive := 0;
  SetLength(LiveIdx, NOperands);
  for I := 0 to NOperands - 1 do begin
    SrcBlk := PhiNode^.PhiBlocks[I];
    if (SrcBlk > 0) and (SrcBlk < Length(FSF^.Blocks)) and
       (Length(FSF^.Blocks[SrcBlk].Preds) = 0) then
      Continue;
    LiveIdx[NLive] := I;
    Inc(NLive);
  end;
  SetLength(LiveIdx, NLive);
  if NLive < 2 then Exit;

  { Classify each live operand by its defining node }
  SetLength(IsLB, NLive);
  SetLength(LBVal, NLive);
  SetLength(IsNot, NLive);
  NLoadBool := 0;
  NNotOp := 0;
  NotOpIdx := -1;

  for I := 0 to NLive - 1 do begin
    IsLB[I] := False;
    IsNot[I] := False;
    DefNode := nil;
    for J := 0 to High(FSF^.AllNodes) do
      if RefEqual(FSF^.AllNodes[J]^.Dest, PhiNode^.Operands[LiveIdx[I]]) then begin
        DefNode := FSF^.AllNodes[J];
        Break;
      end;
    if DefNode = nil then Exit;
    if DefNode^.Kind = SSA_LOADBOOL then begin
      IsLB[I] := True;
      LBVal[I] := (DefNode^.ImmA <> 0);
      Inc(NLoadBool);
    end
    else if (DefNode^.Kind = SSA_UNOP) and (DefNode^.UnOp = uopNot) then begin
      IsNot[I] := True;
      Inc(NNotOp);
      NotOpIdx := I;
    end
    else
      Exit; { unexpected operand type --> not this pattern }
  end;

  { Require: exactly 1 UNOP[not] and at least 1 LOADBOOL }
  if (NNotOp <> 1) or (NLoadBool < 1) then Exit;

  { All LOADBOOLs must have the same value }
  ExpectedVal := LBVal[0]; { first live operand must be LOADBOOL since there's only 1 not }
  if IsNot[0] then begin
    { First live operand is the not - find the first LOADBOOL }
    for I := 1 to NLive - 1 do
      if IsLB[I] then begin ExpectedVal := LBVal[I]; Break; end;
  end;
  for I := 0 to NLive - 1 do
    if IsLB[I] and (LBVal[I] <> ExpectedVal) then Exit;

  { ExpectedVal=true --> negated-and: not (a and b and ...)
    ExpectedVal=false --> negated-or: not (a or b or ...) }

  { For each LOADBOOL operand, trace back to find the controlling TEST branch.
    The LOADBOOL block is reached via JMP trampolines from a TEST branch.
    Extract the tested expression as an inner conjunct/disjunct. }
  SetLength(InnerParts, NLive);
  NInner := 0;

  for I := 0 to NLive - 1 do begin
    if not IsLB[I] then Continue;
    SrcBlk := PhiNode^.PhiBlocks[LiveIdx[I]];
    { Trace back through predecessors to find the TEST branch.
      The LOADBOOL block may be reached via JMP-only trampolines. }
    TracedBlk := SrcBlk;
    BranchNode := nil;
    BranchBlk := -1;
    for K := 0 to 5 do begin { max 5 hops to prevent infinite loop }
      if (TracedBlk < 0) or (TracedBlk >= Length(FSF^.Blocks)) then Break;
      if Length(FSF^.Blocks[TracedBlk].Preds) = 0 then Break;
      { Try each predecessor }
      for J := 0 to High(FSF^.Blocks[TracedBlk].Preds) do begin
        PredBlk := FSF^.Blocks[TracedBlk].Preds[J];
        if (PredBlk < 0) or (PredBlk >= Length(FSF^.Blocks)) then Continue;
        { Check if predecessor has a BRANCH node }
        for M := 0 to High(FSF^.Blocks[PredBlk].Nodes) do begin
          N := FSF^.Blocks[PredBlk].Nodes[M];
          if (N^.Kind = SSA_BRANCH) and (N^.RelOp in [ropTest, ropTestSet]) then begin
            BranchNode := N;
            BranchBlk := PredBlk;
            Break;
          end;
        end;
        if BranchNode <> nil then Break;
        { If predecessor is JMP-only, continue tracing through it }
        IsJmpBlock := True;
        for M := 0 to High(FSF^.Blocks[PredBlk].Nodes) do
          if not (FSF^.Blocks[PredBlk].Nodes[M]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
            IsJmpBlock := False; Break;
          end;
        if IsJmpBlock then begin
          TracedBlk := PredBlk;
          Break; { restart outer loop with new TracedBlk }
        end;
      end;
      if BranchNode <> nil then Break;
    end;

    if BranchNode = nil then Exit;

    { Verify: the TEST's C value matches the expected pattern.
      For negated-and (LOADBOOL=true): TEST C=0 (Invert=false) --> falsy short-circuits
      For negated-or (LOADBOOL=false): TEST C=1 (Invert=true) --> truthy short-circuits }
    if ExpectedVal then begin
      { negated-and: expect Invert=false (C=0) }
      if BranchNode^.Invert then Exit;
    end else begin
      { negated-or: expect Invert=true (C=1) }
      if not BranchNode^.Invert then Exit;
    end;

    InnerParts[NInner] := ExprOf(BranchNode^.OpA, BranchNode^.PC);
    Inc(NInner);
  end;

  { Add the UNOP[not] operand's inner argument as the last conjunct/disjunct }
  DefNode := nil;
  for J := 0 to High(FSF^.AllNodes) do
    if RefEqual(FSF^.AllNodes[J]^.Dest, PhiNode^.Operands[LiveIdx[NotOpIdx]]) then begin
      DefNode := FSF^.AllNodes[J];
      Break;
    end;
  if (DefNode = nil) or (DefNode^.Kind <> SSA_UNOP) or (DefNode^.UnOp <> uopNot) then Exit;
  NotArgExpr := ExprOf(DefNode^.OpA, DefNode^.PC);
  InnerParts[NInner] := NotArgExpr;
  Inc(NInner);

  if NInner < 2 then Exit;

  { Build: not (a and/or b and/or ... and/or z) }
  if ExpectedVal then
    InnerExpr := 'and'
  else
    InnerExpr := 'or';

  Result := InnerParts[0];
  for I := 1 to NInner - 1 do
    Result := Result + ' ' + InnerExpr + ' ' + InnerParts[I];
  Result := 'not (' + Result + ')';

  finally
    Dec(FExprDepth);
  end;
end;

{ ======================================================================
  TryBuildChainedPhiExpr - handle 3+ operand PHIs for chained or/and
  ====================================================================== }

function TDecompiler.TryBuildChainedPhiExpr(PhiNode: PSSANode): AnsiString;
{ Handle PHIs with 2+ operands that form chained or/and expressions.

  For a chain like "a and b and c and d":
    PHI(a from BB_jmp0, b from BB_jmp1, c from BB_jmp2, d from BB_val)
    Each JMP block is a short-circuit exit for TEST with Invert=false (and).

  For "a or b or c or d":
    Each JMP block is a short-circuit exit for TEST with Invert=true (or).

  For mixed "a and b or c":
    Operators can vary per segment.

  Algorithm:
    1. For each operand in order, find whether it's JMP-only (short-circuit) or value (default).
    2. For JMP-only: find the branch ancestor, determine "or" vs "and", record the operator.
    3. Build expression: segment1 op1 segment2 op2 ... opN-1 segmentN
  }
var
  NOperands: Integer;
  OpIdx, I, J, S: Integer;
  SrcBlk: Integer;
  BranchBlk: Integer;
  BranchNode: PSSANode;
  JmpBlk: Integer;
  IsJmpOnly: Boolean;
  CondExpr, ValExpr: AnsiString;
  IsOr, TmpFlag: Boolean;
  N: PSSANode;
  PhiBlkIdx: Integer;
  { Arrays to hold per-operand info }
  SegExprs: array of AnsiString;   { expression for each operand }
  SegOps: array of Boolean;        { True = "or" to NEXT segment, False = "and" to NEXT }
  HasJmpBlock: Boolean;
begin
  Result := '';
  NOperands := Length(PhiNode^.Operands);
  if NOperands < 2 then Exit;
  if Length(PhiNode^.PhiBlocks) <> NOperands then Exit;

  { Depth guard: prevent infinite recursion via NodeExpr --> TryBuildChainedPhiExpr cycles }
  Inc(FExprDepth);
  if FExprDepth > 50 then begin
    Dec(FExprDepth);
    Exit;
  end;
  try

  { Find which block the PHI lives in }
  PhiBlkIdx := -1;
  for I := 0 to High(FSF^.Blocks) do
    for J := 0 to High(FSF^.Blocks[I].Nodes) do
      if FSF^.Blocks[I].Nodes[J] = PhiNode then begin
        PhiBlkIdx := I; Break;
      end;
  if PhiBlkIdx < 0 then Exit;

  { Skip loop-header PHIs (back-edge detected: any source block >= PhiBlkIdx) }
  for OpIdx := 0 to NOperands - 1 do
    if PhiNode^.PhiBlocks[OpIdx] >= PhiBlkIdx then Exit;

  { Require at least one JMP-only or LOADBOOL source block (otherwise it's not an or/and pattern).
    LOADBOOL blocks produce boolean values from comparison chains (EQ/LT/LE). }
  HasJmpBlock := False;
  for OpIdx := 0 to NOperands - 1 do begin
    SrcBlk := PhiNode^.PhiBlocks[OpIdx];
    if (SrcBlk >= 0) and (SrcBlk < Length(FSF^.Blocks)) then begin
      TmpFlag := True;
      for I := 0 to High(FSF^.Blocks[SrcBlk].Nodes) do
        if not (FSF^.Blocks[SrcBlk].Nodes[I]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP, SSA_LOADBOOL]) then begin
          TmpFlag := False; Break;
        end;
      if TmpFlag then begin HasJmpBlock := True; Break; end;
    end;
  end;
  if not HasJmpBlock then Exit;

  SetLength(SegExprs, NOperands);
  SetLength(SegOps, NOperands);  { SegOps[i] = operator AFTER segment i }

  for OpIdx := 0 to NOperands - 1 do begin
    SrcBlk := PhiNode^.PhiBlocks[OpIdx];
    if (SrcBlk < 0) or (SrcBlk >= Length(FSF^.Blocks)) then begin
      if FOpts.Debug then WriteLn(StdErr, 'ChainedPhi: OpIdx=', OpIdx, ' SrcBlk=', SrcBlk, ' out of range');
      Exit;
    end;

    { Check if SrcBlk is a JMP-only block (pass-through) }
    IsJmpOnly := True;
    for I := 0 to High(FSF^.Blocks[SrcBlk].Nodes) do
      if not (FSF^.Blocks[SrcBlk].Nodes[I]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
        IsJmpOnly := False; Break;
      end;

    if IsJmpOnly then begin
      { Find the branch ancestor block that has SrcBlk as a successor }
      BranchBlk := -1;
      BranchNode := nil;
      for I := 0 to High(FSF^.Blocks) do begin
        if Length(FSF^.Blocks[I].Succs) >= 2 then begin
          if (FSF^.Blocks[I].Succs[0] = SrcBlk) or
             (FSF^.Blocks[I].Succs[1] = SrcBlk) then begin
            for J := 0 to High(FSF^.Blocks[I].Nodes) do
              if FSF^.Blocks[I].Nodes[J]^.Kind = SSA_BRANCH then begin
                BranchNode := FSF^.Blocks[I].Nodes[J]; Break;
              end;
            if BranchNode <> nil then begin
              BranchBlk := I; Break;
            end;
          end;
        end;
      end;

      if (BranchBlk < 0) or (BranchNode = nil) then begin
        if FOpts.Debug then WriteLn(StdErr, 'ChainedPhi: OpIdx=', OpIdx, ' SrcBlk=BB', SrcBlk, ' no branch ancestor found');
        Exit;
      end;

      { Validate: branch must test the same register as the PHI destination.
        If it tests a completely different register, this is an if/then/else
        merge, NOT an or/and value chain.  E.g. parseEasing: BB3 branches on
        R1 (type check), but PHI at BB8 is on R0 --> reject.
        EXCEPTION: For TESTSET, the destination register (Dest.Reg = A) differs
        from the test register (OpA.Reg = B).  The PHI CondOperand will have
        the TESTSET destination register, so check against Dest.Reg too.
        Also allow if the ValBlk has a sub-chain (BRANCH node). }
      case BranchNode^.RelOp of
        ropTest, ropTestSet: begin
          if (BranchNode^.OpA.Reg <> PhiNode^.Dest.Reg) and
             ((BranchNode^.RelOp <> ropTestSet) or
              (BranchNode^.Dest.Reg <> PhiNode^.Dest.Reg)) then begin
            { Check if this is part of a sub-chain (ValBlk has BRANCH) }
            TmpFlag := False;
            for I := OpIdx + 1 to NOperands - 1 do begin
              SrcBlk := PhiNode^.PhiBlocks[I];
              if (SrcBlk >= 0) and (SrcBlk < Length(FSF^.Blocks)) then begin
                for J := 0 to High(FSF^.Blocks[SrcBlk].Nodes) do
                  if FSF^.Blocks[SrcBlk].Nodes[J]^.Kind = SSA_BRANCH then begin
                    TmpFlag := True; Break;
                  end;
              end;
              if TmpFlag then Break;
            end;
            if not TmpFlag then Exit;
          end;
        end;
        ropEQ, ropLT, ropLE:
          if (BranchNode^.OpA.Reg <> PhiNode^.Dest.Reg) and
             (BranchNode^.OpB.Reg <> PhiNode^.Dest.Reg) then Exit;
      end;

      { Build condition expression }
      case BranchNode^.RelOp of
        ropTest, ropTestSet: begin
          CondExpr := ExprOf(BranchNode^.OpA, BranchNode^.PC);

          { Check for cached chain expression from an intermediate PHI }
          TmpFlag := False;
          for I := BranchBlk + 1 to PhiBlkIdx - 1 do begin
            if TmpFlag then Break;
            for J := 0 to High(FSF^.Blocks[I].Nodes) do begin
              N := FSF^.Blocks[I].Nodes[J];
              if (N^.Kind = SSA_PHI) and (N^.Dest.Reg = PhiNode^.Operands[OpIdx].Reg) then begin
                JmpBlk := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
                if (JmpBlk >= 0) and (JmpBlk < Length(FExprStr)) and (FExprStr[JmpBlk] <> '') then begin
                  CondExpr := FExprStr[JmpBlk];
                  TmpFlag := True;
                  Break;
                end;
              end;
            end;
          end;

          { Determine or vs and:
            TEST Invert=true (C=1): truthy values short-circuit --> "or" to next
            TEST Invert=false (C=0): falsy values short-circuit --> "and" to next }
          IsOr := BranchNode^.Invert;
          SegExprs[OpIdx] := CondExpr;
          SegOps[OpIdx] := IsOr;
        end;
        ropEQ, ropLT, ropLE: begin
          CondExpr := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                    BranchNode^.RelOp, BranchNode^.Invert,
                                    BranchNode^.PC);
          { For comparison branches:
            Succs[0] = fall-through (condition FALSE path = JMP block)
            Succs[1] = skip target (condition TRUE path)
            If JmpBlk is Succs[0] --> false short-circuits --> "or" (invert logic):
              actually: false exits --> means "or" pattern
            If JmpBlk is Succs[1] --> true short-circuits --> "and" pattern }
          if (Length(FSF^.Blocks[BranchBlk].Succs) >= 2) and
             (FSF^.Blocks[BranchBlk].Succs[0] = SrcBlk) then
            IsOr := True   { false path short-circuits = "or" }
          else
            IsOr := False; { true path short-circuits = "and" }
          SegExprs[OpIdx] := CondExpr;
          SegOps[OpIdx] := IsOr;
        end;
      else
        Exit;
      end;
    end else begin
      { Non-JMP block = value/default block. }
      { Reject if it has side-effect statements. }
      if FOpts.Debug then
        WriteLn(StdErr, 'ChainedPhi: OpIdx=', OpIdx, ' SrcBlk=BB', SrcBlk, ' (value block)');
      for I := 0 to High(FSF^.Blocks[SrcBlk].Nodes) do begin
        N := FSF^.Blocks[SrcBlk].Nodes[I];
        if N^.Kind in [SSA_SETTABLE, SSA_SETGLOBAL, SSA_SETUPVAL, SSA_CALL,
                       SSA_CLOSURE] then begin
          if FOpts.Debug then WriteLn(StdErr, 'ChainedPhi: OpIdx=', OpIdx, ' rejected - side-effect in value block');
          Exit;
        end;
      end;
      { Use the operand's definition PC (not the PHI's PC) for ExprOf,
        so that user-local name lookup doesn't incorrectly resolve to the
        local variable name.  E.g. LOADK R0 "default" at PC 8, but LocVar
        "value" starts at PC 9 - ExprOf(R0, 9) would return "value". }
      ValExpr := '';
      for I := 0 to High(FSF^.AllNodes) do begin
        if RefEqual(FSF^.AllNodes[I]^.Dest, PhiNode^.Operands[OpIdx]) then begin
          { Skip PHI-defined operands to avoid infinite recursion between
            NodeExpr and TryBuildChainedPhiExpr (self-ref or PHI cycles) }
          if FSF^.AllNodes[I]^.Kind = SSA_PHI then Continue;
          ValExpr := NodeExpr(FSF^.AllNodes[I]);
          Break;
        end;
      end;
      if ValExpr = '' then
        ValExpr := ExprOf(PhiNode^.Operands[OpIdx], PhiNode^.PC);
      SegExprs[OpIdx] := ValExpr;
      SegOps[OpIdx] := False; { doesn't matter for last segment }
    end;
  end;

  { Post-process: collapse LOADBOOL comparison pairs.
    When two consecutive segments are "false" and "true" (or "true" and "false"),
    trace back to find the comparison BRANCH that generated them and replace
    both with the comparison expression. }
  OpIdx := 0;
  while OpIdx + 1 < NOperands do begin
    if ((SegExprs[OpIdx] = 'false') and (SegExprs[OpIdx + 1] = 'true')) or
       ((SegExprs[OpIdx] = 'true') and (SegExprs[OpIdx + 1] = 'false')) then begin
      { Find comparison BRANCH that feeds these two LOADBOOL value blocks.
        One of them may be dead code (C=1 skip makes the next unreachable).
        Search backwards from the LOADBOOL blocks to find the CLOSEST
        comparison branch - a more distant branch is likely an outer-level
        condition that happens to reach the LOADBOOL via a trampoline chain. }
      SrcBlk := PhiNode^.PhiBlocks[OpIdx];
      J := PhiNode^.PhiBlocks[OpIdx + 1];
      BranchNode := nil;
      BranchBlk := -1;
      { Determine upper bound for search }
      if SrcBlk > J then S := SrcBlk else S := J;
      for I := S - 1 downto 0 do begin
        if Length(FSF^.Blocks[I].Succs) < 2 then Continue;
        { Find last BRANCH node }
        N := nil;
        for S := High(FSF^.Blocks[I].Nodes) downto 0 do
          if FSF^.Blocks[I].Nodes[S]^.Kind = SSA_BRANCH then begin
            N := FSF^.Blocks[I].Nodes[S]; Break;
          end;
        if (N = nil) or not (N^.RelOp in [ropEQ, ropLT, ropLE]) then Continue;
        { Check direct successors }
        if ((FSF^.Blocks[I].Succs[0] = SrcBlk) or (FSF^.Blocks[I].Succs[0] = J) or
            (FSF^.Blocks[I].Succs[1] = SrcBlk) or (FSF^.Blocks[I].Succs[1] = J)) then begin
          BranchNode := N; BranchBlk := I; Break;
        end;
        { Check via JMP trampoline on Succs[0] }
        S := FSF^.Blocks[I].Succs[0];
        if (S >= 0) and (S < Length(FSF^.Blocks)) and (Length(FSF^.Blocks[S].Succs) = 1) then begin
          if (FSF^.Blocks[S].Succs[0] = SrcBlk) or (FSF^.Blocks[S].Succs[0] = J) then begin
            BranchNode := N; BranchBlk := I; Break;
          end;
        end;
        { Check via JMP trampoline on Succs[1] }
        S := FSF^.Blocks[I].Succs[1];
        if (S >= 0) and (S < Length(FSF^.Blocks)) and (Length(FSF^.Blocks[S].Succs) = 1) then begin
          if (FSF^.Blocks[S].Succs[0] = SrcBlk) or (FSF^.Blocks[S].Succs[0] = J) then begin
            BranchNode := N; BranchBlk := I; Break;
          end;
        end;
      end;
      if BranchNode <> nil then begin
        { Determine comparison inversion and or/and operator.
          Lua comparison: "if (B op C) ~= A then skip next"
          Succs[0] = fallthrough (skip condition NOT met)
          Succs[1] = skip target (skip condition IS met)
          Skip condition = BuildCompare(Invert).

          Check which LOADBOOL block Succs[0] (fallthrough) reaches:
          Case 1: Succs[0] --> false LOADBOOL
            Not-skip --> false. Expression = skip cond = BuildCompare(Invert).
            Operator = "and" (false on failure = and short-circuit).
          Case 2: Succs[0] --> true LOADBOOL
            Not-skip --> true. Expression = NOT(skip cond) = BuildCompare(not Invert).
            Operator = "or" (true on success = or short-circuit). }

        { Find which LOADBOOL block has "false" }
        if SegExprs[OpIdx] = 'false' then
          S := SrcBlk { S = false LOADBOOL block }
        else
          S := J;     { S = false LOADBOOL block }

        { Check if Succs[0] or its JMP trampoline reaches the false LOADBOOL block }
        TmpFlag := False; { True = Succs[0] reaches the false block }
        if (Length(FSF^.Blocks[BranchBlk].Succs) >= 2) then begin
          if FSF^.Blocks[BranchBlk].Succs[0] = S then
            TmpFlag := True
          else begin
            { Check via JMP trampoline from Succs[0] }
            I := FSF^.Blocks[BranchBlk].Succs[0];
            if (I >= 0) and (I < Length(FSF^.Blocks)) and
               (Length(FSF^.Blocks[I].Succs) = 1) and
               (FSF^.Blocks[I].Succs[0] = S) then
              TmpFlag := True;
          end;
        end;

        if FOpts.Debug then
          WriteLn(StdErr, 'LOADBOOL collapse: BranchBlk=BB', BranchBlk,
                  ' RelOp=', Ord(BranchNode^.RelOp),
                  ' Invert=', BranchNode^.Invert,
                  ' FalseBlk=BB', S,
                  ' FallthroughToFalse=', TmpFlag,
                  ' SegExprs[', OpIdx, ']=', SegExprs[OpIdx],
                  ' SegExprs[', OpIdx+1, ']=', SegExprs[OpIdx+1]);

        if TmpFlag then begin
          { Succs[0] (fallthrough = NOT-skip) reaches false LOADBOOL.
            Fallthrough means skip condition NOT met --> result is false.
            Skip condition = BuildCompare(Invert).
            The boolean expression is: skip condition --> true, not --> false.
            Expression = skip condition = BuildCompare(Invert).
            Operator = "and" (false on failure = and short-circuit). }
          ValExpr := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                   BranchNode^.RelOp, BranchNode^.Invert,
                                   BranchNode^.PC);
          SegOps[OpIdx] := False; { "and" }
        end else begin
          { Succs[0] (fallthrough = NOT-skip) reaches true LOADBOOL.
            Fallthrough means skip condition NOT met --> result is true.
            Expression = NOT(skip condition) = BuildCompare(not Invert).
            Operator = "or" (true on success = or short-circuit). }
          ValExpr := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                   BranchNode^.RelOp, not BranchNode^.Invert,
                                   BranchNode^.PC);
          SegOps[OpIdx] := True; { "or" }
        end;
        SegExprs[OpIdx] := ValExpr;
        { Remove the next segment by shifting everything down }
        for I := OpIdx + 1 to NOperands - 2 do begin
          SegExprs[I] := SegExprs[I + 1];
          SegOps[I] := SegOps[I + 1];
        end;
        Dec(NOperands);
        { After collapse, check if the collapsed comparison should be reordered
          before the preceding value block. This happens when:
          - The current position OpIdx > 0
          - The previous segment (OpIdx-1) is a value block whose source block
            is a successor of the comparison's branch block (i.e., the comparison
            is evaluated before the value block in the control flow).
          Example: PHI(b from BB1, e from BB4, false from BB5, true from BB6)
          After collapse: [b, e, c==d]. BranchBlk for c==d is BB2, which
          is the predecessor of BB4(e). So c==d should come before e. }
        while (OpIdx > 0) and (BranchBlk >= 0) and
              (BranchBlk < PhiNode^.PhiBlocks[OpIdx - 1]) do begin
          { Swap: move the collapsed comparison before the previous segment }
          if FOpts.Debug then
            WriteLn(StdErr, '  Swapping: SegExprs[', OpIdx-1, ']=', SegExprs[OpIdx-1],
                    ' <-> SegExprs[', OpIdx, ']=', SegExprs[OpIdx]);
          ValExpr := SegExprs[OpIdx];
          SegExprs[OpIdx] := SegExprs[OpIdx - 1];
          SegExprs[OpIdx - 1] := ValExpr;
          { Swap operators too }
          TmpFlag := SegOps[OpIdx];
          SegOps[OpIdx] := SegOps[OpIdx - 1];
          SegOps[OpIdx - 1] := TmpFlag;
          Dec(OpIdx);
        end;
        if FOpts.Debug then
          WriteLn(StdErr, 'ChainedPhi: collapsed LOADBOOL pair at ', OpIdx, ': ', SegExprs[OpIdx]);
      end else
        Inc(OpIdx);
    end else
      Inc(OpIdx);
  end;

  { Build the chained expression.
    For uniform chains (all "and" or all "or"), emit:  a and b and c and d
    For mixed chains, use parentheses to clarify precedence. }
  if NOperands < 2 then Exit;

  Result := SegExprs[0];
  for I := 1 to NOperands - 1 do begin
    if SegOps[I - 1] then
      Result := Result + ' or ' + SegExprs[I]
    else
      Result := Result + ' and ' + SegExprs[I];
  end;

  { Wrap in parens for safe embedding in larger expressions }
  Result := '(' + Result + ')';

  finally
    Dec(FExprDepth);
  end;
end;