LuaDecompCF.inc

function TDecompiler.IsLoopHeader(BIdx: Integer): Boolean;
var
  I, P: Integer;
begin
  Result := False;
  for I := 0 to High(FSF^.Blocks[BIdx].Preds) do begin
    P := FSF^.Blocks[BIdx].Preds[I];
    { A back-edge exists if a predecessor has a higher or equal index AND
      that predecessor hasn't already been consumed by another structural
      construct (e.g. a for-loop's FORLOOP block). }
    if (P >= BIdx) and not FEmitted[P] then begin
      Result := True; Exit;
    end;
  end;
end;

function TDecompiler.FindLoopExit(HeaderIdx: Integer): Integer;
var
  I, S: Integer;
begin
  { The exit block is the successor of the loop header that is NOT dominated
    by the header (or is a later block). Simple heuristic: take the successor
    with the highest index that is > HeaderIdx. }
  Result := -1;
  for I := 0 to High(FSF^.Blocks[HeaderIdx].Succs) do begin
    S := FSF^.Blocks[HeaderIdx].Succs[I];
    if S > HeaderIdx then
      if (Result = -1) or (S > Result) then
        Result := S;
  end;
end;

{ IsRepeatUntilLoop - returns True if the loop at HeaderIdx is repeat-until
  rather than while.

  A while loop has its condition branch at the header, with one successor
  being the loop exit. A repeat-until loop has its condition at the TAIL
  (the block before the back-edge JMP), and the header's branch (if any)
  is an inner if-statement - both of its successors stay inside the loop. }
function TDecompiler.IsRepeatUntilLoop(HeaderIdx: Integer): Boolean;
var
  I, J, P, S, MaxBackEdge: Integer;
  HasBranch, IsJmpOnly: Boolean;
begin
  Result := False;
  { Find the maximum back-edge source for this loop header.
    Prefer reachable back-edges (blocks with predecessors) to avoid inflating
    the loop span with dead code.  Fall back to unreachable back-edges if
    they are the only ones (e.g., dead loop body after unconditional break). }
  MaxBackEdge := -1;
  for I := 0 to High(FSF^.Blocks[HeaderIdx].Preds) do begin
    P := FSF^.Blocks[HeaderIdx].Preds[I];
    if (P >= HeaderIdx) and not FEmitted[P] and
       ((P = 0) or (Length(FSF^.Blocks[P].Preds) > 0)) then
      if P > MaxBackEdge then MaxBackEdge := P;
  end;
  if MaxBackEdge < 0 then begin
    { No reachable back-edge; try unreachable ones (dead code back-edges) }
    for I := 0 to High(FSF^.Blocks[HeaderIdx].Preds) do begin
      P := FSF^.Blocks[HeaderIdx].Preds[I];
      if (P >= HeaderIdx) and not FEmitted[P] then
        if P > MaxBackEdge then MaxBackEdge := P;
    end;
  end;
  if MaxBackEdge < 0 then Exit; { No back-edge = not a loop }

  { Check if header has a BRANCH }
  HasBranch := False;
  for I := 0 to High(FSF^.Blocks[HeaderIdx].Nodes) do
    if FSF^.Blocks[HeaderIdx].Nodes[I]^.Kind = SSA_BRANCH then begin
      HasBranch := True; Break;
    end;

  if not HasBranch then begin
    { No branch in header --> definitely repeat-until (condition at tail) }
    Result := True;
    Exit;
  end;

  { Header has a branch. Check if either successor exits
    the loop. The loop body spans [HeaderIdx..MaxBackEdge]. A successor
    "exits" if it goes outside this range:
    (a) its index is > MaxBackEdge (forward exit), OR
    (b) its index is < HeaderIdx (backward exit to outer scope), OR
    (c) it's a JMP-only trampoline whose target satisfies (a) or (b).
    If any successor exits the loop, it's a while loop.
    If both successors stay inside the loop body, it's repeat-until. }
  for I := 0 to High(FSF^.Blocks[HeaderIdx].Succs) do begin
    S := FSF^.Blocks[HeaderIdx].Succs[I];
    if (S > MaxBackEdge) or (S < HeaderIdx) then
      Exit; { One successor exits the loop --> while }
    { Follow JMP-only trampolines to check if they ultimately exit }
    if (S >= 0) and (S < Length(FSF^.Blocks)) and (S <> HeaderIdx) then begin
      IsJmpOnly := True;
      for J := 0 to High(FSF^.Blocks[S].Nodes) do
        if not (FSF^.Blocks[S].Nodes[J]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
          IsJmpOnly := False; Break;
        end;
      if IsJmpOnly and (Length(FSF^.Blocks[S].Succs) = 1) then begin
        P := FSF^.Blocks[S].Succs[0];
        if (P > MaxBackEdge) or (P < HeaderIdx) then
          Exit; { JMP-only trampoline exits the loop --> while }
      end;
    end;
  end;

  { Both successors are inside the loop --> repeat-until }
  Result := True;
end;

{ FindRepeatUntilExit - find the exit block for a repeat-until loop.
  The exit is NOT a successor of the header. Instead, find the tail block
  (the block that branches back to the header or to the JMP-only back-edge),
  and the exit is the OTHER successor of that tail block. }
function TDecompiler.FindRepeatUntilExit(HeaderIdx: Integer): Integer;
var
  I, P, S, MaxBackEdge, TailBlk: Integer;
begin
  Result := -1;
  { Find the maximum back-edge source.
    Prefer reachable back-edges; fall back to unreachable if needed. }
  MaxBackEdge := -1;
  for I := 0 to High(FSF^.Blocks[HeaderIdx].Preds) do begin
    P := FSF^.Blocks[HeaderIdx].Preds[I];
    if (P >= HeaderIdx) and not FEmitted[P] and
       ((P = 0) or (Length(FSF^.Blocks[P].Preds) > 0)) then
      if P > MaxBackEdge then MaxBackEdge := P;
  end;
  if MaxBackEdge < 0 then begin
    for I := 0 to High(FSF^.Blocks[HeaderIdx].Preds) do begin
      P := FSF^.Blocks[HeaderIdx].Preds[I];
      if (P >= HeaderIdx) and not FEmitted[P] then
        if P > MaxBackEdge then MaxBackEdge := P;
    end;
  end;
  if MaxBackEdge < 0 then Exit;

  { The MaxBackEdge is typically a JMP-only block. Find the block that
    branches TO MaxBackEdge (the real tail with the condition). }
  TailBlk := -1;
  for I := 0 to High(FSF^.Blocks[MaxBackEdge].Preds) do begin
    P := FSF^.Blocks[MaxBackEdge].Preds[I];
    if (P >= HeaderIdx) and (P < MaxBackEdge) then begin
      { This is the tail block that branches to the back-edge }
      TailBlk := P;
      Break;
    end;
  end;

  if TailBlk < 0 then begin
    { MaxBackEdge itself might be the tail block (direct back-edge) }
    TailBlk := MaxBackEdge;
  end;

  { Find the exit: the successor of TailBlk that goes beyond MaxBackEdge }
  for I := 0 to High(FSF^.Blocks[TailBlk].Succs) do begin
    S := FSF^.Blocks[TailBlk].Succs[I];
    if (S <> MaxBackEdge) and (S <> HeaderIdx) then begin
      if (Result = -1) or (S > Result) then
        Result := S;
    end;
  end;
end;

{ Find the merge block (post-dominator) for an if branch }
function TDecompiler.FindMerge(BranchBlk, TrueBlk, FalseBlk: Integer): Integer;
{ Find the merge block (immediate post-dominator) for an if-branch.
  Uses BFS reachability with distance tracking from both branches.
  Merge candidates must:
    1. Be reachable from both branches
    2. Not be strictly inside one branch's dominator subtree
    3. Postdominate the branch block (every path from BranchBlk to a
       function exit passes through the candidate)
  Selection: closest candidate by max(TrueDist, FalseDist). }

  function IsJmpOnlyBlock(Blk: Integer): Boolean;
  var J: Integer;
  begin
    Result := True;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) then begin Result := False; Exit; end;
    for J := 0 to High(FSF^.Blocks[Blk].Nodes) do
      if not (FSF^.Blocks[Blk].Nodes[J]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
        Result := False; Exit;
      end;
  end;

  function IsDomBy(Blk, Dom: Integer): Boolean;
  { Check if Blk is strictly dominated by Dom (walk idom chain). }
  var B, Safety: Integer;
  begin
    Result := False;
    if Blk = Dom then Exit; { Not strict domination }
    B := Blk;
    Safety := 0;
    while (B >= 0) and (B < Length(FSF^.Blocks)) and (Safety < 200) do begin
      if B = Dom then begin Result := True; Exit; end;
      if FSF^.Blocks[B].IDom = B then Exit; { root }
      B := FSF^.Blocks[B].IDom;
      Inc(Safety);
    end;
  end;

  function IsSemanticExit(Blk: Integer): Boolean;
  { True if block contains SSA_RETURN or SSA_TAILCALL.
    More robust than checking Succs=0 alone. }
  var EI: Integer;
  begin
    Result := False;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) then Exit;
    for EI := 0 to High(FSF^.Blocks[Blk].Nodes) do
      if FSF^.Blocks[Blk].Nodes[EI]^.Kind in [SSA_RETURN, SSA_TAILCALL] then begin
        Result := True; Exit;
      end;
  end;

  function PostDominates(M, B: Integer): Boolean;
  { True if every path from B to a function exit passes through M.
    Phase 1: BFS from B with M excluded. If any semantic exit
    (SSA_RETURN/SSA_TAILCALL) is reachable -> M does NOT postdominate B.
    Phase 2: verify M itself can reach a semantic exit. If not, reject
    (conservatively handles no-exit/infinite-loop subgraphs). }
  var
    PDVisited: array of Boolean;
    PDQueue: array of Integer;
    QH, QT, Cur, Si, PDSucc: Integer;
    FoundExit: Boolean;
    NumBlks: Integer;
  begin
    Result := False;
    NumBlks := Length(FSF^.Blocks);
    if M = B then Exit;  { can't postdominate itself for merge purposes }
    if (M < 0) or (M >= NumBlks) then Exit;
    if (B < 0) or (B >= NumBlks) then Exit;

    SetLength(PDVisited, NumBlks);
    SetLength(PDQueue, NumBlks);

    { Phase 1: BFS from B excluding M - full CFG traversal }
    for Cur := 0 to NumBlks - 1 do PDVisited[Cur] := False;
    PDVisited[M] := True;  { exclude M from traversal }
    QH := 0; QT := 0;
    PDQueue[QT] := B; Inc(QT); PDVisited[B] := True;
    while QH < QT do begin
      Cur := PDQueue[QH]; Inc(QH);
      { Semantic exit check - block has RETURN/TAILCALL }
      if IsSemanticExit(Cur) then Exit;  { exit reachable without M -> False }
      for Si := 0 to High(FSF^.Blocks[Cur].Succs) do begin
        PDSucc := FSF^.Blocks[Cur].Succs[Si];
        if (PDSucc >= 0) and (PDSucc < NumBlks) and (not PDVisited[PDSucc]) then begin
          PDVisited[PDSucc] := True;
          PDQueue[QT] := PDSucc; Inc(QT);
        end;
      end;
    end;

    { Phase 1 passed: no exit reachable from B without M.
      Phase 2: verify M can reach a semantic exit. }
    if IsSemanticExit(M) then begin Result := True; Exit; end;

    for Cur := 0 to NumBlks - 1 do PDVisited[Cur] := False;
    QH := 0; QT := 0;
    PDQueue[QT] := M; Inc(QT); PDVisited[M] := True;
    FoundExit := False;
    while QH < QT do begin
      Cur := PDQueue[QH]; Inc(QH);
      if IsSemanticExit(Cur) then begin FoundExit := True; Break; end;
      for Si := 0 to High(FSF^.Blocks[Cur].Succs) do begin
        PDSucc := FSF^.Blocks[Cur].Succs[Si];
        if (PDSucc >= 0) and (PDSucc < NumBlks) and (not PDVisited[PDSucc]) then begin
          PDVisited[PDSucc] := True;
          PDQueue[QT] := PDSucc; Inc(QT);
        end;
      end;
    end;
    Result := FoundExit;
  end;

var
  NBlks, I, S: Integer;
  TrueEnd, FalseEnd: Integer;
  TrueDist, FalseDist: array of Integer;
  Queue: array of Integer;
  QHead, QTail: Integer;
  Blk, Succ: Integer;
  Cur: Integer;
  TrueOnly, FalseOnly: Boolean;
  BestMerge, BestScore, Score: Integer;
begin
  Result := -1;
  NBlks := Length(FSF^.Blocks);
  if NBlks = 0 then begin Result := Max(TrueBlk, FalseBlk) + 1; Exit; end;

  { Follow JMP-only blocks to find real endpoints }
  TrueEnd := TrueBlk;
  if IsJmpOnlyBlock(TrueBlk) and (Length(FSF^.Blocks[TrueBlk].Succs) = 1) then
    TrueEnd := FSF^.Blocks[TrueBlk].Succs[0];

  FalseEnd := FalseBlk;
  if IsJmpOnlyBlock(FalseBlk) and (Length(FSF^.Blocks[FalseBlk].Succs) = 1) then
    FalseEnd := FSF^.Blocks[FalseBlk].Succs[0];

  { Quick check: both resolve to same block }
  if (TrueEnd = FalseEnd) and (TrueEnd > BranchBlk) then begin
    Result := TrueEnd; Exit;
  end;

  { BFS from True branch - forward-only traversal (Succ > BranchBlk)
    to prevent back-edges from creating cross-loop-boundary merges.
    PostDominates uses full CFG separately for correctness.
    Distances track BFS hops; reachability = Dist >= 0. }
  SetLength(TrueDist, NBlks);
  SetLength(FalseDist, NBlks);
  for I := 0 to NBlks - 1 do begin TrueDist[I] := -1; FalseDist[I] := -1; end;

  SetLength(Queue, NBlks);

  QHead := 0; QTail := 0;
  if (TrueEnd >= 0) and (TrueEnd < NBlks) then begin
    TrueDist[TrueEnd] := 0;
    Queue[QTail] := TrueEnd; Inc(QTail);
  end;
  while QHead < QTail do begin
    Blk := Queue[QHead]; Inc(QHead);
    for S := 0 to High(FSF^.Blocks[Blk].Succs) do begin
      Succ := FSF^.Blocks[Blk].Succs[S];
      if (Succ > BranchBlk) and (Succ < NBlks) and (TrueDist[Succ] < 0) then begin
        TrueDist[Succ] := TrueDist[Blk] + 1;
        Queue[QTail] := Succ; Inc(QTail);
      end;
    end;
  end;

  { BFS from False branch - forward-only traversal }
  QHead := 0; QTail := 0;
  if (FalseEnd >= 0) and (FalseEnd < NBlks) then begin
    FalseDist[FalseEnd] := 0;
    Queue[QTail] := FalseEnd; Inc(QTail);
  end;
  while QHead < QTail do begin
    Blk := Queue[QHead]; Inc(QHead);
    for S := 0 to High(FSF^.Blocks[Blk].Succs) do begin
      Succ := FSF^.Blocks[Blk].Succs[S];
      if (Succ > BranchBlk) and (Succ < NBlks) and (FalseDist[Succ] < 0) then begin
        FalseDist[Succ] := FalseDist[Blk] + 1;
        Queue[QTail] := Succ; Inc(QTail);
      end;
    end;
  end;

  { Find merge candidate: reachable from both branches, not inside one
    branch's dominator subtree, postdominates the branch block.
    Select closest by max(TrueDist, FalseDist).
    Only forward candidates (I > BranchBlk) - backward merges are loops. }
  BestMerge := -1;
  BestScore := MaxInt;
  for I := 0 to NBlks - 1 do begin
    if (I <= BranchBlk) then Continue;  { only forward merge candidates }
    if (TrueDist[I] < 0) or (FalseDist[I] < 0) then Continue;  { not common }
    { Dominance filter: skip blocks inside one branch's subtree }
    TrueOnly := IsDomBy(I, TrueEnd) and (not IsDomBy(I, FalseEnd));
    FalseOnly := IsDomBy(I, FalseEnd) and (not IsDomBy(I, TrueEnd));
    if TrueOnly or FalseOnly then Continue;
    { Postdomination filter }
    if not PostDominates(I, BranchBlk) then Continue;
    { BFS-distance score: closest common block }
    Score := TrueDist[I];
    if FalseDist[I] > Score then Score := FalseDist[I];
    if Score < BestScore then begin
      BestScore := Score;
      BestMerge := I;
    end;
  end;
  if BestMerge >= 0 then begin
    Result := BestMerge; Exit;
  end;

  { Both branches return - genuine if/else with no merge point.
    Keep both as parallel branches (emit else). }
  if (TrueEnd >= 0) and (TrueEnd < NBlks) and
     (Length(FSF^.Blocks[TrueEnd].Succs) = 0) and
     (FalseEnd >= 0) and (FalseEnd < NBlks) and
     (Length(FSF^.Blocks[FalseEnd].Succs) = 0) then begin
    Result := Max(TrueEnd, FalseEnd) + 1; Exit;
  end;

  { One branch returns, the other continues.
    When one branch ends with RETURN (no successors), the merge is simply
    the start of the other branch - there is no else, just continuation
    after "end". }
  if (TrueEnd >= 0) and (TrueEnd < NBlks) and
     (Length(FSF^.Blocks[TrueEnd].Succs) = 0) then begin
    Result := FalseEnd; Exit;
  end;
  if (FalseEnd >= 0) and (FalseEnd < NBlks) and
     (Length(FSF^.Blocks[FalseEnd].Succs) = 0) then begin
    Result := TrueEnd; Exit;
  end;

  { Enhanced all-paths-terminate check for complex branches.
    When a branch body contains a nested if where ALL paths return,
    TrueEnd/FalseEnd still have successors (the nested BRANCH), so the
    simple Length(Succs)=0 check above misses them.  We detect this by
    verifying the BFS reach set is "closed": every reachable block's
    forward successors are also reachable, meaning no path escapes
    the branch body.  This handles switch_pattern-style elseif chains
    where one branch has a nested if with all-returning paths. }
  for I := 0 to 1 do begin { 0=check true, 1=check false }
    Cur := 0; { reuse: acts as "has any reachable block" flag }
    TrueOnly := True; { reuse: acts as "all paths terminate" flag }
    for S := BranchBlk + 1 to NBlks - 1 do begin
      if I = 0 then begin
        if TrueDist[S] < 0 then Continue;
      end else begin
        if FalseDist[S] < 0 then Continue;
      end;
      Cur := 1; { found at least one reachable block }
      for Blk := 0 to High(FSF^.Blocks[S].Succs) do begin
        Succ := FSF^.Blocks[S].Succs[Blk];
        if Succ <= BranchBlk then begin
          { Back-edge to loop header - this path continues, doesn't terminate }
          TrueOnly := False; Break;
        end;
        if (Succ > BranchBlk) and (Succ < NBlks) then begin
          if I = 0 then begin
            if TrueDist[Succ] < 0 then begin TrueOnly := False; Break; end;
          end else begin
            if FalseDist[Succ] < 0 then begin TrueOnly := False; Break; end;
          end;
        end;
      end;
      if not TrueOnly then Break;
    end;
    if (Cur = 1) and TrueOnly then begin
      { This branch all-returns - merge is the other branch's start }
      if I = 0 then begin Result := FalseEnd; Exit; end
      else begin Result := TrueEnd; Exit; end;
    end;
  end;

  { Fallback }
  if Result = -1 then
    Result := Max(TrueBlk, FalseBlk) + 1;
end;

{ ======================================================================
  Numeric / generic for detection
  ====================================================================== }

function TDecompiler.EmitForNumericLoop(BIdx: Integer): Integer;
var
  Blk  : PBasicBlock;
  N    : PSSANode;
  PrepNode, LoopNode: PSSANode;
  StartNode, LimitNode, StepNode: PSSANode;
  IterReg, LimitReg, StepReg, VarReg: Integer;
  StartExpr, LimitExpr, StepExpr, VarName: AnsiString;
  ExitBlk: Integer;
  I: Integer;
  LoopBlkIdx: Integer;
  BodyStart: Integer;
  BodyPC: Integer;
  S: Integer;
  ForOpenIdx: Integer;
begin
  Result := -1;

  if FOpts.Debug then
    WriteLn(StdErr, 'EmitForNumericLoop: FORPREP block=BB', BIdx);

  Blk := @FSF^.Blocks[BIdx];

  { Find FORPREP node in this block }
  PrepNode := nil;
  for I := 0 to High(Blk^.Nodes) do
    if Blk^.Nodes[I]^.Kind = SSA_FORPREP then begin
      PrepNode := Blk^.Nodes[I]; Break;
    end;
  if PrepNode = nil then Exit;

  IterReg  := PrepNode^.ImmA;
  LimitReg := IterReg + 1;
  StepReg  := IterReg + 2;
  { Lua 5.1-5.4: 3 internal vars (init/limit/step), user var at R(A+3)
    Lua 5.5:     2 internal vars (count/step), user var at R(A+2) }
  if FSF^.LuaVersion >= $55 then
    VarReg := IterReg + 2
  else
    VarReg := IterReg + 3;

  { Determine the FORLOOP block (jump target of FORPREP) }
  LoopBlkIdx := -1;
  for I := 0 to High(Blk^.Succs) do begin
    LoopBlkIdx := Blk^.Succs[I]; Break;
  end;
  if LoopBlkIdx < 0 then Exit;

  { Find FORLOOP node }
  LoopNode := nil;
  for I := 0 to High(FSF^.Blocks[LoopBlkIdx].Nodes) do
    if FSF^.Blocks[LoopBlkIdx].Nodes[I]^.Kind = SSA_FORLOOP then begin
      LoopNode := FSF^.Blocks[LoopBlkIdx].Nodes[I]; Break;
    end;
  if LoopNode = nil then Exit;

  ExitBlk := FindLoopExit(LoopBlkIdx);

  if FOpts.Debug then
    WriteLn(StdErr, 'EmitForNumericLoop: FORPREP=BB', BIdx,
            ' FORLOOP=BB', LoopBlkIdx, ' ExitBlk=BB', ExitBlk);

  { Find the SSA nodes that define the init/limit/step registers in this block.
    Also search predecessor blocks if not found, since the compiler may place
    the start/limit/step definitions in blocks that feed into the FORPREP block.
    NOTE: do NOT search predecessors for registers that have PHI nodes in BIdx,
    because the PHI expression (e.g. "count or 1") should be used instead of
    the individual predecessor definitions. }
  StartNode := FindDefNode(BIdx, IterReg);
  LimitNode := FindDefNode(BIdx, LimitReg);
  StepNode  := FindDefNode(BIdx, StepReg);
  { Check for PHI nodes first: they take priority over predecessor search.
    When a for-control register is defined by a PHI (e.g. "count or 1"),
    mark the PHI's source blocks as emitted so TryEmitOrAnd doesn't
    produce a spurious standalone assignment like "t4 = count or 1". }
  for I := 0 to High(Blk^.Nodes) do begin
    N := Blk^.Nodes[I];
    if N^.Kind <> SSA_PHI then Continue;
    if (StartNode = nil) and (N^.Dest.Reg = IterReg) then begin
      StartNode := N;
      for S := 0 to High(N^.PhiBlocks) do
        if (N^.PhiBlocks[S] >= 0) and (N^.PhiBlocks[S] < Length(FSF^.Blocks)) then
          FEmitted[N^.PhiBlocks[S]] := True;
    end;
    if (LimitNode = nil) and (N^.Dest.Reg = LimitReg) then begin
      LimitNode := N;
      for S := 0 to High(N^.PhiBlocks) do
        if (N^.PhiBlocks[S] >= 0) and (N^.PhiBlocks[S] < Length(FSF^.Blocks)) then
          FEmitted[N^.PhiBlocks[S]] := True;
    end;
    if (StepNode = nil) and (N^.Dest.Reg = StepReg) then begin
      StepNode := N;
      for S := 0 to High(N^.PhiBlocks) do
        if (N^.PhiBlocks[S] >= 0) and (N^.PhiBlocks[S] < Length(FSF^.Blocks)) then
          FEmitted[N^.PhiBlocks[S]] := True;
    end;
  end;
  { Search earlier blocks for registers still not found.
    Walk backward from BIdx to find the defining instruction. }
  if (StartNode = nil) or (LimitNode = nil) or (StepNode = nil) then begin
    for S := BIdx - 1 downto 0 do begin
      if StartNode = nil then StartNode := FindDefNode(S, IterReg);
      if LimitNode = nil then LimitNode := FindDefNode(S, LimitReg);
      if StepNode = nil then  StepNode := FindDefNode(S, StepReg);
      if (StartNode <> nil) and (LimitNode <> nil) and (StepNode <> nil) then
        Break;
    end;
  end;

  { Emit any non-for-setup statements in the prep block before the for line.
    Nodes that define init/limit/step or are structural (FORPREP/PHI/NOP) are skipped.
    Other nodes (e.g. intermediate computations) must be emitted first. }
  I := 0;
  while I <= High(Blk^.Nodes) do begin
    N := Blk^.Nodes[I];
    if N^.Kind in [SSA_FORPREP, SSA_PHI, SSA_NOP, SSA_JUMP, SSA_SETLIST] then begin
      Inc(I); Continue;
    end;
    { Skip nodes that define the for-control registers }
    if (N = StartNode) or (N = LimitNode) or (N = StepNode) then begin
      Inc(I); Continue;
    end;
    { Try table constructor pattern (NEWTABLE + values + SETLIST) }
    if (N^.Kind = SSA_NEWTABLE) and TryEmitTableConstructor(BIdx, I, S) then begin
      Inc(I, S); Continue;
    end;
    { Skip nodes whose result feeds into a for-control def (intermediates).
      We detect this by checking if the node's dest reg is used only by
      the for-control defining nodes.  For safety, skip any node whose
      dest.Reg is one of the for-control regs (shouldn't happen) or
      whose dest is consumed entirely by for-setup. }
    EmitNode(N, BIdx);
    Inc(I);
  end;

  { Build loop bound expressions from the defining nodes.
    Strip outer parens since for-header already provides clear context. }
  if StartNode <> nil then
    StartExpr := StripOuterParens(NodeExpr(StartNode))
  else
    StartExpr := LocalName(IterReg, Blk^.StartPC);
  if LimitNode <> nil then
    LimitExpr := StripOuterParens(NodeExpr(LimitNode))
  else
    LimitExpr := LocalName(LimitReg, Blk^.StartPC);
  if StepNode <> nil then
    StepExpr := StripOuterParens(NodeExpr(StepNode))
  else
    StepExpr := LocalName(StepReg, Blk^.StartPC);

  { Get loop variable name from inside the body (where LocVar "i" is in scope) }
  BodyStart := BIdx + 1;
  if (BodyStart < Length(FSF^.Blocks)) and
     (BodyStart <= LoopBlkIdx) then
    BodyPC := FSF^.Blocks[BodyStart].StartPC
  else
    BodyPC := Blk^.StartPC;
  VarName := LocalName(VarReg, BodyPC);
  { If still a generated name, try the debug LocVar directly }
  if (Length(VarName) > 0) and (VarName[1] = 't') then begin
    for I := 0 to High(FProto^.LocVars) do
      if (FProto^.LocVars[I].StartPC = PrepNode^.PC + 1) and
         (FProto^.LocVars[I].Name <> '') and
         (FProto^.LocVars[I].Name[1] <> '(') then begin
        VarName := FProto^.LocVars[I].Name;
        Break;
      end;
  end;

  ForOpenIdx := FOutput.Count;
  if (PrepNode <> nil) then FAnnotatePC := PrepNode^.PC;
  if StepExpr = '1' then
    EmitLine('for ' + VarName + ' = ' + StartExpr + ', ' + LimitExpr + ' do')
  else
    EmitLine('for ' + VarName + ' = ' + StartExpr + ', ' + LimitExpr + ', ' + StepExpr + ' do');
  FAnnotatePC := -1;
  Indent;

  { Emit body: blocks between FORPREP-block and FORLOOP block (exclusive) }
  FEmitted[BIdx]       := True;
  FEmitted[LoopBlkIdx] := True;
  PushLoopExit(ExitBlk);
  if BodyStart < LoopBlkIdx then
    EmitRegion(BodyStart, LoopBlkIdx)
  else if BodyStart = LoopBlkIdx then begin
    { Body is between FORLOOP successors: emit the body block }
    for I := 0 to High(FSF^.Blocks[LoopBlkIdx].Succs) do begin
      S := FSF^.Blocks[LoopBlkIdx].Succs[I];
      if (S <> ExitBlk) and (S < LoopBlkIdx) then begin
        EmitRegion(S, LoopBlkIdx);
        Break;
      end;
    end;
  end;
  PopLoopExit;

  Dedent;
  EmitLine('end');
  { Try single-line collapse: "for i = start, limit do body end" }
  if PrepNode <> nil then
    TryCollapseSingleLineBlock(ForOpenIdx, PrepNode^.PC,
      LoopNode^.PC);

  FEmitted[BIdx]       := True;
  FEmitted[LoopBlkIdx] := True;
  Result := ExitBlk;
end;

function TDecompiler.EmitForGenericLoop(BIdx: Integer): Integer;
var
  Blk  : PBasicBlock;
  I, J : Integer;
  TForNode, CallNode, N: PSSANode;
  BaseReg: Integer;
  VarNames, IterExpr, FuncExpr, Args: AnsiString;
  ExitBlk: Integer;
  R: Integer;
  BodyStart: Integer;
  VarBase: Integer;
  PredBlk: Integer;
  ArgI: Integer;
  CallIdx: Integer;
  ForOpenIdx: Integer;
begin
  Result := -1;

  if FOpts.Debug then
    WriteLn(StdErr, 'EmitForGenericLoop: TFORLOOP block=BB', BIdx);

  Blk := @FSF^.Blocks[BIdx];

  TForNode := nil;
  for I := 0 to High(Blk^.Nodes) do
    if Blk^.Nodes[I]^.Kind = SSA_TFORLOOP then begin
      TForNode := Blk^.Nodes[I]; Break;
    end;
  if TForNode = nil then Exit;

  BaseReg  := TForNode^.ImmA;

  { Try to find the CALL that initializes the for-loop registers.
    The CALL writes to BaseReg (the generator function) and is in a
    predecessor block. We use its expression as the iterator.
    If no direct CALL to BaseReg, look for a MOVE to BaseReg whose source
    comes from a CALL or user local (e.g., "for a,b in gen do"). }
  IterExpr := '';
  CallNode := nil;
  for I := 0 to High(Blk^.Preds) do begin
    PredBlk := Blk^.Preds[I];
    for J := High(FSF^.Blocks[PredBlk].Nodes) downto 0 do begin
      N := FSF^.Blocks[PredBlk].Nodes[J];
      if (N^.Kind = SSA_CALL) and (N^.ImmA = BaseReg) then begin
        CallNode := N;
        CallIdx := J;
        Break;
      end;
    end;
    if CallNode <> nil then Break;
  end;
  { If no CALL directly to BaseReg, look for MOVE to BaseReg and trace source }
  if CallNode = nil then begin
    for I := 0 to High(Blk^.Preds) do begin
      PredBlk := Blk^.Preds[I];
      for J := High(FSF^.Blocks[PredBlk].Nodes) downto 0 do begin
        N := FSF^.Blocks[PredBlk].Nodes[J];
        if (N^.Kind = SSA_MOVE) and (N^.Dest.Reg = BaseReg) then begin
          { Found MOVE to BaseReg - use the source expression as IterExpr }
          IterExpr := ExprOf(N^.OpA, N^.PC);
          { Inline the MOVE so it's not emitted as a standalone statement }
          R := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
          if (R >= 0) and (R < Length(FInlined)) then
            FInlined[R] := True;
          Break;
        end;
      end;
      if IterExpr <> '' then Break;
    end;
  end;

  { If no CALL and no MOVE found, look for direct setup of BaseReg..BaseReg+2.
    This handles "for k,v in next, tbl do" where registers are set individually. }
  if (CallNode = nil) and (IterExpr = '') then begin
    for I := 0 to High(Blk^.Preds) do begin
      PredBlk := Blk^.Preds[I];
      { Find node writing to BaseReg (the iterator function) }
      for J := High(FSF^.Blocks[PredBlk].Nodes) downto 0 do begin
        N := FSF^.Blocks[PredBlk].Nodes[J];
        if (N^.Dest.Reg = BaseReg) and
           (N^.Kind in [SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL, SSA_LOADK,
                        SSA_CLOSURE, SSA_MOVE]) then begin
          IterExpr := ExprOf(N^.Dest, N^.PC);
          { Mark it inlined }
          R := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
          if (R >= 0) and (R < Length(FInlined)) then
            FInlined[R] := True;
          { Now check for state (BaseReg+1) and initial (BaseReg+2) }
          for R := BaseReg + 1 to BaseReg + 2 do begin
            for ArgI := High(FSF^.Blocks[PredBlk].Nodes) downto 0 do begin
              N := FSF^.Blocks[PredBlk].Nodes[ArgI];
              if (N^.Dest.Reg = R) and
                 (N^.Kind <> SSA_PHI) and (N^.Kind <> SSA_NOP) then begin
                { Skip trailing nil values - "next, tbl" omits the nil }
                if N^.Kind = SSA_LOADNIL then begin
                  { Inline LOADNIL regardless }
                  CallIdx := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
                  if (CallIdx >= 0) and (CallIdx < Length(FInlined)) then
                    FInlined[CallIdx] := True;
                end else begin
                  IterExpr := IterExpr + ', ' + ExprOf(N^.Dest, N^.PC);
                  CallIdx := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
                  if (CallIdx >= 0) and (CallIdx < Length(FInlined)) then
                    FInlined[CallIdx] := True;
                end;
                Break;
              end;
            end;
          end;
          Break;
        end;
      end;
      if IterExpr <> '' then Break;
    end;
  end;

  if CallNode <> nil then begin
    { Build the call expression: func(args) }
    FuncExpr := ExprOf(CallNode^.OpA, CallNode^.PC);
    Args := '';
    ArgI := 0;
    { Check if it's a SELF-based call (skip first implicit arg) }
    if (CallNode^.OpA.Reg >= 0) and (CallNode^.OpA.Reg <> SSA_CONST_REG) then begin
      for I := 0 to High(FSF^.AllNodes) do
        if RefEqual(FSF^.AllNodes[I]^.Dest, CallNode^.OpA) and
           (FSF^.AllNodes[I]^.Kind = SSA_SELF) then begin
          ArgI := 1; Break;
        end;
    end;
    while ArgI <= High(CallNode^.ArgRefs) do begin
      if Args <> '' then Args := Args + ', ';
      Args := Args + ExprOf(CallNode^.ArgRefs[ArgI], CallNode^.PC);
      Inc(ArgI);
    end;
    IterExpr := FuncExpr + '(' + Args + ')';
    { If the CALL returns exactly 1 value (ImmC=2), the source used (f()) to
      adjust to a single value.  Wrap in extra parens to preserve semantics.
      Normal for-in initializers use ImmC=0 (variable) or ImmC=4 (3 values). }
    if CallNode^.ImmC = 2 then
      IterExpr := '(' + IterExpr + ')';
    { Mark the CALL node as inlined so it won't be emitted as a standalone statement }
    I := NodeIdx(CallNode^.Dest.Reg, CallNode^.Dest.Version);
    if (I >= 0) and (I < Length(FInlined)) then
      FInlined[I] := True;

    { Also inline any setup nodes in the predecessor block that are part of the
      for-loop initialization.  In 5.4, after the CALL, a LOADNIL initializes
      the state/control/to-be-closed variables (R(A+1)..R(A+3)).  In 5.1-5.3,
      these are covered by the CALL's multi-return. Mark them as inlined. }
    for I := 0 to High(Blk^.Preds) do begin
      PredBlk := Blk^.Preds[I];
      for J := 0 to High(FSF^.Blocks[PredBlk].Nodes) do begin
        N := FSF^.Blocks[PredBlk].Nodes[J];
        { LOADNIL to registers between BaseReg and BaseReg+3 (or +4 for 5.4) }
        if (N^.Kind = SSA_LOADNIL) and
           (N^.Dest.Reg >= BaseReg) and (N^.Dest.Reg <= BaseReg + 3) then begin
          R := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
          if (R >= 0) and (R < Length(FInlined)) then
            FInlined[R] := True;
        end;
        { Also inline GETGLOBAL/GETTABUP that set up the CALL arguments }
        if (N^.Kind in [SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL, SSA_LOADK]) and
           (N^.Dest.Reg >= BaseReg) and (N^.Dest.Reg <= BaseReg + 3) then begin
          R := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
          if (R >= 0) and (R < Length(FInlined)) then
            FInlined[R] := True;
        end;
      end;
    end;
  end;

  if IterExpr = '' then
    IterExpr := LocalName(BaseReg, Blk^.StartPC);

  { Build variable names from LocVars.  The loop variables (R(A+3) etc.)
    are only in scope inside the body block, not at the TFORLOOP instruction.
    The TFORLOOP block's first successor is a JMP block that leads to the body.
    Follow the JMP to find the actual body block's start PC. }
  BodyStart := -1;
  if Length(Blk^.Succs) > 0 then begin
    for I := 0 to High(Blk^.Succs) do begin
      J := Blk^.Succs[I];
      if (J >= 0) and (J < Length(FSF^.Blocks)) and
         (Length(FSF^.Blocks[J].Nodes) = 1) and
         { In 5.1-5.3, the intermediate block is a JMP; in 5.4+, it's a FORLOOP }
         (FSF^.Blocks[J].Nodes[0]^.Kind in [SSA_JUMP, SSA_FORLOOP]) and
         (Length(FSF^.Blocks[J].Succs) > 0) then begin
        { This is the intermediate block; find body among its successors }
        ExitBlk := FindLoopExit(BIdx);
        for R := 0 to High(FSF^.Blocks[J].Succs) do begin
          if FSF^.Blocks[J].Succs[R] <> ExitBlk then begin
            BodyStart := FSF^.Blocks[FSF^.Blocks[J].Succs[R]].StartPC;
            Break;
          end;
        end;
        if BodyStart < 0 then
          BodyStart := FSF^.Blocks[FSF^.Blocks[J].Succs[0]].StartPC;
        Break;
      end;
    end;
  end;
  if BodyStart < 0 then BodyStart := Blk^.StartPC;

  { User-visible loop variables.
    Lua 5.1-5.3, 5.5: R(A+3)..R(A+2+C), 3 internal vars
    Lua 5.4 only:      R(A+4)..R(A+3+C), 4 internal vars (to-be-closed slot added) }
  if FSF^.LuaVersion = $54 then
    VarBase := BaseReg + 4
  else
    VarBase := BaseReg + 3;
  VarNames := '';
  for R := 0 to TForNode^.ImmC - 1 do begin
    if VarNames <> '' then VarNames := VarNames + ', ';
    VarNames := VarNames + LocalName(VarBase + R, BodyStart);
  end;

  ForOpenIdx := FOutput.Count;
  if (TForNode <> nil) then FAnnotatePC := TForNode^.PC;
  EmitLine('for ' + VarNames + ' in ' + IterExpr + ' do');
  FAnnotatePC := -1;
  Indent;

  ExitBlk := FindLoopExit(BIdx);

  { Emit body blocks.
    In Lua 5.1, the TFORLOOP successor is a JMP block --> body block.
    In Lua 5.4+, the TFORLOOP successor is a FORLOOP block --> body block.
    The body blocks typically have LOWER indices than the TFORLOOP block
    (because the setup code jumps forward past the body to the TFORLOOP,
    with the body blocks in between).
    Follow the successor chain to find the actual body start block. }
  FEmitted[BIdx] := True;
  { Find body start by following TFORLOOP --> successor --> body }
  BodyStart := -1;
  for I := 0 to High(Blk^.Succs) do begin
    J := Blk^.Succs[I];
    if (J >= 0) and (J < Length(FSF^.Blocks)) and (J <> ExitBlk) then begin
      { This is the intermediate block (JMP in 5.1, FORLOOP in 5.4+) }
      FEmitted[J] := True;
      { Follow its successors to find the body block (not the exit) }
      for R := 0 to High(FSF^.Blocks[J].Succs) do begin
        if FSF^.Blocks[J].Succs[R] <> ExitBlk then begin
          BodyStart := FSF^.Blocks[J].Succs[R];
          Break;
        end;
      end;
      { If the intermediate block has only one successor that IS the body }
      if (BodyStart < 0) and (Length(FSF^.Blocks[J].Succs) = 1) then
        BodyStart := FSF^.Blocks[J].Succs[0];
      Break;
    end;
  end;
  if BodyStart < 0 then BodyStart := BIdx + 1;

  PushLoopExit(ExitBlk);
  if (BodyStart >= 0) and (BodyStart < Length(FSF^.Blocks)) and (BodyStart <> ExitBlk) then begin
    { Body blocks are between BodyStart and the TFORLOOP block (BIdx).
      Emit from BodyStart up to ExitBlk, but mark BIdx as already emitted
      so the walk stops before re-entering the TFORLOOP. }
    if BodyStart < BIdx then
      EmitRegion(BodyStart, ExitBlk)
    else
      EmitRegion(BodyStart, ExitBlk);
  end;
  PopLoopExit;

  Dedent;
  EmitLine('end');
  { Try single-line collapse: "for k, v in pairs(t) do body end"
    StartPC = body start (or TFORLOOP if no body), EndPC = JMP after TFORLOOP.
    Covers the body instructions + loop control to verify same source line. }
  if TForNode <> nil then begin
    if (BodyStart >= 0) and (BodyStart < Length(FSF^.Blocks)) then
      I := FSF^.Blocks[BodyStart].StartPC
    else
      I := TForNode^.PC;
    TryCollapseSingleLineBlock(ForOpenIdx, I,
      Min(TForNode^.PC + 1, Length(FProto^.LineInfo) - 1));
  end;
  Result := ExitBlk;
end;
function TDecompiler.TryBuildCompoundCond(BranchBlk: Integer;
                                           out CondExpr: AnsiString;
                                           out TrueTarget, FalseTarget: Integer): Boolean;

  { Check if a block is branch-only (only BRANCH + PHI/NOP/JUMP + optional LOADKs) }
  function IsBranchOnlyBlock(Blk: Integer): Boolean;
  var J, BranchCnt: Integer; Nd: PSSANode;
  begin
    Result := False;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) then Exit;
    if Length(FSF^.Blocks[Blk].Succs) < 2 then Exit;
    BranchCnt := 0;
    for J := 0 to High(FSF^.Blocks[Blk].Nodes) do begin
      Nd := FSF^.Blocks[Blk].Nodes[J];
      if Nd^.Kind = SSA_BRANCH then Inc(BranchCnt)
      else if not (Nd^.Kind in [SSA_PHI, SSA_NOP, SSA_JUMP, SSA_LOADK,
                                 SSA_LOADBOOL, SSA_LOADNIL]) then
        Exit; { has real statements - not branch-only }
    end;
    Result := (BranchCnt = 1);
  end;

  { Check if a block is a condition-evaluation block: it evaluates a SINGLE
    expression and branches on the result. The BRANCH must test the register
    that was DEFINED by the last non-BRANCH instruction in the block.
    This catches patterns like: GETUPVAL R0 + CALL R0 + BRANCH R0
    (function call used as condition) but rejects: GETUPVAL R3 + LOADK R4 +
    CALL R3 (side-effect call) + BRANCH R0 (branch on different register). }
  function IsCondEvalBlock(Blk: Integer): Boolean;
  var J, BranchCnt, CallCnt, DefCnt, DefsAfterCall: Integer;
      Nd, BrNode: PSSANode;
      BranchReg, LastDefReg: Integer;
      SeenCall: Boolean;
  begin
    Result := False;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) then Exit;
    if Length(FSF^.Blocks[Blk].Succs) < 2 then Exit;
    BranchCnt := 0;
    CallCnt := 0;
    DefCnt := 0;
    DefsAfterCall := 0;
    BrNode := nil;
    LastDefReg := -1;
    SeenCall := False;
    for J := 0 to High(FSF^.Blocks[Blk].Nodes) do begin
      Nd := FSF^.Blocks[Blk].Nodes[J];
      case Nd^.Kind of
        SSA_BRANCH: begin Inc(BranchCnt); BrNode := Nd; end;
        SSA_PHI, SSA_NOP, SSA_JUMP: { harmless };
        SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL: begin
          { If this defines a user-local register, it's a body statement
            (e.g., "local x = 3") not just condition computation }
          if IsUserLocal(Nd^.Dest.Reg, Nd^.PC) or
             IsUserLocal(Nd^.Dest.Reg, Nd^.PC + 1) or
             ShouldEmitAsLocal(Nd^.Dest.Reg, Nd^.PC) then
            Exit;
          Inc(DefCnt);
          LastDefReg := Nd^.Dest.Reg;
          if SeenCall then Inc(DefsAfterCall);
        end;
        SSA_GETUPVAL, SSA_GETGLOBAL, SSA_GETTABLE,
        SSA_SELF, SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT: begin
          Inc(DefCnt);
          LastDefReg := Nd^.Dest.Reg;
          if SeenCall then Inc(DefsAfterCall);
        end;
        SSA_CALL: begin
          Inc(CallCnt);
          Inc(DefCnt);
          LastDefReg := Nd^.Dest.Reg;
          SeenCall := True;
        end;
        else
          Exit; { has side-effecting writes or unknown instructions }
      end;
    end;
    if (BranchCnt <> 1) or (BrNode = nil) then Exit;
    if CallCnt > 1 then Exit; { multiple calls --> likely body + condition }
    { If there's a CALL followed by more definitions, the CALL's result
      is overwritten --> the CALL is a side-effect statement (e.g., f()),
      not part of condition evaluation. Reject this block. }
    if (CallCnt = 1) and (DefsAfterCall > 0) then Exit;
    { A condition evaluation block evaluates a single expression and branches
      on the result.  Typical pattern: GETGLOBAL(type) + MOVE(arg) + CALL +
      BRANCH = 4 defs.  Blocks with many definitions (e.g., MOVE + GETUPVAL +
      GETTABLE + GETTABLE + GETGLOBAL + MOVE + CALL = 7 defs) are if-then
      bodies with embedded conditions, not standalone condition evaluations. }
    if DefCnt > 4 then Exit;
    { The branch must test the register that was last defined.
      For comparison branches (EQ/LT/LE), check BOTH OpA and OpB since
      the defined register could be on either side of the comparison
      (e.g., LE 0 K11(0) R2 has OpA=K11, OpB=R2). }
    BranchReg := BrNode^.OpA.Reg;
    if (LastDefReg >= 0) and (BranchReg = LastDefReg) then begin
      Result := True; Exit;
    end;
    if BrNode^.RelOp in [ropEQ, ropLT, ropLE] then begin
      BranchReg := BrNode^.OpB.Reg;
      if (LastDefReg >= 0) and (BranchReg = LastDefReg) then begin
        Result := True; Exit;
      end;
    end;
  end;

  { Follow JMP-only trampoline blocks }
  function FollowJmp(Blk: Integer): Integer;
  var J: Integer; IsJmp: Boolean;
  begin
    Result := Blk;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) then Exit;
    if Length(FSF^.Blocks[Blk].Succs) <> 1 then Exit;
    IsJmp := True;
    for J := 0 to High(FSF^.Blocks[Blk].Nodes) do
      if not (FSF^.Blocks[Blk].Nodes[J]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
        IsJmp := False; Break;
      end;
    if IsJmp then
      Result := FSF^.Blocks[Blk].Succs[0];
  end;

  { Build condition expression for a single branch node }
  function SingleCondExpr(BNode: PSSANode; Invert: Boolean): AnsiString;
  begin
    if BNode = nil then begin Result := 'cond'; Exit; end;
    case BNode^.RelOp of
      ropEQ, ropLT, ropLE:
        Result := BuildCompare(BNode^.OpA, BNode^.OpB,
                               BNode^.RelOp, Invert xor BNode^.Invert,
                               BNode^.PC);
      ropTest, ropTestSet: begin
        if Invert xor BNode^.Invert then
          Result := 'not ' + ExprOf(BNode^.OpA, BNode^.PC)
        else
          Result := ExprOf(BNode^.OpA, BNode^.PC);
      end;
    else
      Result := 'cond';
    end;
  end;

var
  NBlks: Integer;
  { Chain of conditions we're collecting }
  ChainLen: Integer;
  ChainBlks: array[0..31] of Integer;     { block index for each condition }
  ChainOps: array[0..31] of AnsiString;   { 'and'/'or' connector BEFORE this condition }
  ChainConds: array[0..31] of AnsiString;  { condition expression }
  { Working vars }
  CurBlk: Integer;
  BNode: PSSANode;
  I, J, J2: Integer;
  Succ0, Succ1: Integer; { Succs[0]=JMP(false), Succs[1]=skip(true) as per CFG convention }
  Target0, Target1: Integer; { after following JMP trampolines }
  FoundBody, FoundMerge: Integer;
  NextCond: Integer;
  Connector: AnsiString;
  Safety: Integer;
  IsSimpleVal: Boolean;
begin
  Result := False;
  CondExpr := '';
  TrueTarget := -1;
  FalseTarget := -1;
  NBlks := Length(FSF^.Blocks);
  if NBlks = 0 then Exit;

  if FOpts.Debug then
    WriteLn(StdErr, 'TryBuildCompoundCond: start BB', BranchBlk);

  { Start from BranchBlk.  The first block may contain body statements before
    its branch (e.g., print("x") followed by if a or b then ...).  Those are
    emitted by the caller.  Only the continuation blocks must be branch-only.
    However, the first block must have at least one branch-only successor to
    form a compound condition (otherwise it's a simple single-condition branch). }
  if Length(FSF^.Blocks[BranchBlk].Succs) < 2 then begin
    if FOpts.Debug then
      WriteLn(StdErr, 'TryBuildCompoundCond: BB', BranchBlk, ' exit: < 2 succs');
    Exit;
  end;
  begin
    Succ0 := FSF^.Blocks[BranchBlk].Succs[0];
    Succ1 := FSF^.Blocks[BranchBlk].Succs[1];
    { At least one RAW successor must be a condition block (branch-only or cond-eval).
      Reject loop headers - a successor that is a loop header (has back-edges)
      is a while/repeat loop inside the if-body, not part of a compound condition.
      E.g. "if a then while b do ... end end" should NOT collapse to "if a and b then". }
    if not (((IsBranchOnlyBlock(Succ0) or IsCondEvalBlock(Succ0)) and
              (not IsLoopHeader(Succ0))) or
             ((IsBranchOnlyBlock(Succ1) or IsCondEvalBlock(Succ1)) and
              (not IsLoopHeader(Succ1)))) then begin
      if FOpts.Debug then
        WriteLn(StdErr, 'TryBuildCompoundCond: BB', BranchBlk,
                ' exit: no cond succ (Succ0=', Succ0, ' Succ1=', Succ1, ')');
      Exit;
    end;
  end;

  { Phase 1: Walk the chain of branch blocks, collecting candidates.
    The first block may have body statements; subsequent blocks must be branch-only.
    IMPORTANT: For chain continuation, check the RAW successors only - do NOT
    follow JMP trampolines. Trampolines lead to merge/body/elseif blocks that
    are not part of this compound chain. In a valid compound chain, the next
    condition block is always a DIRECT successor of the current one. }
  ChainLen := 0;
  CurBlk := BranchBlk;
  Safety := 0;

  while (CurBlk >= 0) and (CurBlk < NBlks) and
        ((CurBlk = BranchBlk) or
         ((IsBranchOnlyBlock(CurBlk) or IsCondEvalBlock(CurBlk)) and
          not IsLoopHeader(CurBlk))) and
        (ChainLen < 32) and (Safety < 64) do begin
    Inc(Safety);

    if Length(FSF^.Blocks[CurBlk].Succs) < 2 then Break;
    Succ0 := FSF^.Blocks[CurBlk].Succs[0];
    Succ1 := FSF^.Blocks[CurBlk].Succs[1];

    ChainBlks[ChainLen] := CurBlk;
    Inc(ChainLen);

    { Pick the next block to follow: check RAW successors (not followed through JMPs).
      In a compound condition chain, the next condition is always a direct successor.
      Accept both branch-only blocks and condition-evaluation blocks (for function calls
      in conditions like: if always_true() and always_true() then).
      Reject loop headers - they indicate a while/repeat inside the if-body. }
    if (IsBranchOnlyBlock(Succ1) or IsCondEvalBlock(Succ1)) and
       not IsLoopHeader(Succ1) then
      CurBlk := Succ1
    else if (IsBranchOnlyBlock(Succ0) or IsCondEvalBlock(Succ0)) and
            not IsLoopHeader(Succ0) then
      CurBlk := Succ0
    else
      Break; { Both non-branch - last condition in chain }
  end;

  if FOpts.Debug then
    WriteLn(StdErr, 'TryBuildCompoundCond: BB', BranchBlk, ' chainLen=', ChainLen);
  if ChainLen < 2 then Exit;

  { Phase 2: Determine FoundBody and FoundMerge from the LAST condition.
    The last condition's two successors are both non-branch blocks:
    one is the body, the other is the merge. Body = lower PC (comes first). }
  CurBlk := ChainBlks[ChainLen - 1];
  if Length(FSF^.Blocks[CurBlk].Succs) < 2 then Exit;
  Succ0 := FSF^.Blocks[CurBlk].Succs[0];
  Succ1 := FSF^.Blocks[CurBlk].Succs[1];
  Target0 := FollowJmp(Succ0);
  Target1 := FollowJmp(Succ1);

  { Both targets of the last condition should be non-condition blocks.
    A "condition block" is one that evaluates a condition and branches (branch-only
    or cond-eval). If one target is still a condition block, it may be an elseif. }
  if IsBranchOnlyBlock(Target0) or IsCondEvalBlock(Target0) or
     IsBranchOnlyBlock(Target1) or IsCondEvalBlock(Target1) then begin
    { One target is a condition block (e.g., an elseif block not in our chain).
      Collect non-condition targets from all chain blocks to find body.
      If we can't find a second distinct non-condition target for merge,
      use the condition-block target as the merge (it's the elseif block). }
    FoundBody := -1;
    FoundMerge := -1;
    for I := 0 to ChainLen - 1 do begin
      CurBlk := ChainBlks[I];
      if Length(FSF^.Blocks[CurBlk].Succs) < 2 then Continue;
      Target0 := FollowJmp(FSF^.Blocks[CurBlk].Succs[0]);
      Target1 := FollowJmp(FSF^.Blocks[CurBlk].Succs[1]);
      if not (IsBranchOnlyBlock(Target0) or IsCondEvalBlock(Target0)) then begin
        if FoundBody < 0 then FoundBody := Target0
        else if (Target0 <> FoundBody) and (FoundMerge < 0) then
          FoundMerge := Target0;
      end;
      if not (IsBranchOnlyBlock(Target1) or IsCondEvalBlock(Target1)) then begin
        if FoundBody < 0 then FoundBody := Target1
        else if (Target1 <> FoundBody) and (FoundMerge < 0) then
          FoundMerge := Target1;
      end;
    end;
    { If only FoundBody was found (no second non-condition target), use the
      condition-block target from the last condition as the merge/elseif block }
    if (FoundBody >= 0) and (FoundMerge < 0) then begin
      CurBlk := ChainBlks[ChainLen - 1];
      Target0 := FollowJmp(FSF^.Blocks[CurBlk].Succs[0]);
      Target1 := FollowJmp(FSF^.Blocks[CurBlk].Succs[1]);
      if (IsBranchOnlyBlock(Target0) or IsCondEvalBlock(Target0)) and (Target0 <> FoundBody) then
        FoundMerge := Target0
      else if (IsBranchOnlyBlock(Target1) or IsCondEvalBlock(Target1)) and (Target1 <> FoundBody) then
        FoundMerge := Target1;
    end;
  end else begin
    { Standard case: last condition's both targets are non-branch }
    if Target0 < Target1 then begin
      FoundBody := Target0; FoundMerge := Target1;
    end else begin
      FoundBody := Target1; FoundMerge := Target0;
    end;
  end;

  if FOpts.Debug then
    WriteLn(StdErr, 'TryBuildCompoundCond: BB', BranchBlk,
            ' FoundBody=', FoundBody, ' FoundMerge=', FoundMerge);
  if (FoundBody < 0) or (FoundMerge < 0) then Exit;
  if FoundBody = FoundMerge then Exit;

  { Reject compound-condition when the merge block is the current loop exit.
    In this case, the individual branches are break statements and should be
    handled separately by TryEmitBreakIf, not collapsed into a compound
    condition.  Example: for i=1,100 do x=compute(i); if x==nil then break end;
    y=process(x); if y<0 then break end; store(y); end }
  if IsBreakTarget(FoundMerge) then begin
    if FOpts.Debug then
      WriteLn(StdErr, 'TryBuildCompoundCond: BB', BranchBlk,
              ' rejected - merge BB', FoundMerge, ' is loop exit (break pattern)');
    Exit;
  end;

  { Reject compound-condition when pattern is actually a chained or/and VALUE
    expression: "x = a and b and c and d" compiles to a chain of branch-only
    blocks with a PHI at the merge. The "body" block is just a simple value
    producer (GETGLOBAL, LOADK, etc.) with no side effects.
    Key indicators:
    1. FoundMerge has a PHI with 3+ operands
    2. FoundBody is a simple value block (no CALL, SETTABLE, SETGLOBAL, etc.)
    If both conditions hold, reject so TryEmitOrAnd can handle it. }
  if (FoundMerge >= 0) and (FoundMerge < NBlks) then begin
    for I := 0 to High(FSF^.Blocks[FoundMerge].Nodes) do begin
      if (FSF^.Blocks[FoundMerge].Nodes[I]^.Kind = SSA_PHI) and
         (Length(FSF^.Blocks[FoundMerge].Nodes[I]^.PhiBlocks) >= 3) then begin
        { Found a multi-operand PHI at merge. Check if FoundBody is a simple value block. }
        IsSimpleVal := True;
        for J2 := 0 to High(FSF^.Blocks[FoundBody].Nodes) do begin
          BNode := FSF^.Blocks[FoundBody].Nodes[J2];
          if BNode^.Kind in [SSA_CALL, SSA_SETTABLE, SSA_SETGLOBAL, SSA_SETUPVAL,
                              SSA_SETLIST] then begin
            IsSimpleVal := False; Break;
          end;
        end;
        if IsSimpleVal then begin
          if FOpts.Debug then
            WriteLn(StdErr, 'TryBuildCompoundCond: BB', BranchBlk,
                    ' rejected - chained or/and value pattern (PHI at merge BB',
                    FoundMerge, ' with ', Length(FSF^.Blocks[FoundMerge].Nodes[I]^.PhiBlocks),
                    ' operands)');
          Exit;
        end;
        Break;
      end;
    end;
  end;

  { Validate compound-condition: every non-chain successor of each chain
    block must converge to FoundBody or FoundMerge.  If validation fails,
    try progressively shorter chains (ChainLen-1, ChainLen-2, ..., 2)
    until a valid chain is found or we run out of options. }
  NextCond := ChainLen; { remember original length to detect when recomputation is needed }
  while ChainLen >= 2 do begin
    { Recompute FoundBody/FoundMerge when chain was shortened }
    if ChainLen <> NextCond then begin
      NextCond := ChainLen;
      CurBlk := ChainBlks[ChainLen - 1];
      if Length(FSF^.Blocks[CurBlk].Succs) < 2 then begin Dec(ChainLen); Continue; end;
      Succ0 := FSF^.Blocks[CurBlk].Succs[0];
      Succ1 := FSF^.Blocks[CurBlk].Succs[1];
      Target0 := FollowJmp(Succ0);
      Target1 := FollowJmp(Succ1);
      { Body = lower PC, Merge = higher PC (body comes before merge in bytecode) }
      if Target0 < Target1 then begin
        FoundBody := Target0; FoundMerge := Target1;
      end else begin
        FoundBody := Target1; FoundMerge := Target0;
      end;
      if (FoundBody < 0) or (FoundMerge < 0) or (FoundBody = FoundMerge) then begin
        Dec(ChainLen); Continue;
      end;
    end;

    { Validate all chain links }
    Safety := 1; { overall valid flag }
    for I := 0 to ChainLen - 1 do begin
      CurBlk := ChainBlks[I];
      if Length(FSF^.Blocks[CurBlk].Succs) < 2 then Continue;
      Succ0 := FSF^.Blocks[CurBlk].Succs[0];
      Succ1 := FSF^.Blocks[CurBlk].Succs[1];
      Target0 := FollowJmp(Succ0);
      Target1 := FollowJmp(Succ1);
      J2 := -1;
      if I < ChainLen - 1 then J2 := ChainBlks[I + 1];

      { Check Target0: valid if it is the next chain block, any chain block,
        FoundBody, FoundMerge, or a LOADBOOL leading to Body/Merge. }
      IsSimpleVal := (Target0 = J2) or (Target0 = FoundBody) or (Target0 = FoundMerge);
      if not IsSimpleVal then begin
        { Check if Target0 is ANY chain block (not just the next one).
          This handles grouped conditions like (a or b) and (x or y)
          where the "or" jump skips ahead to a later chain block. }
        for J := 0 to ChainLen - 1 do
          if ChainBlks[J] = Target0 then begin IsSimpleVal := True; Break; end;
      end;
      if not IsSimpleVal then begin
        if (Target0 >= 0) and (Target0 < NBlks) and
           (Length(FSF^.Blocks[Target0].Nodes) = 1) and
           (FSF^.Blocks[Target0].Nodes[0]^.Kind = SSA_LOADBOOL) and
           (Length(FSF^.Blocks[Target0].Succs) >= 1) then begin
          if (FSF^.Blocks[Target0].Succs[0] = FoundBody) or
             (FSF^.Blocks[Target0].Succs[0] = FoundMerge) then
            IsSimpleVal := True;
        end;
        if not IsSimpleVal then begin Safety := 0; Break; end;
      end;
      { Check Target1 }
      IsSimpleVal := (Target1 = J2) or (Target1 = FoundBody) or (Target1 = FoundMerge);
      if not IsSimpleVal then begin
        for J := 0 to ChainLen - 1 do
          if ChainBlks[J] = Target1 then begin IsSimpleVal := True; Break; end;
      end;
      if not IsSimpleVal then begin
        if (Target1 >= 0) and (Target1 < NBlks) and
           (Length(FSF^.Blocks[Target1].Nodes) = 1) and
           (FSF^.Blocks[Target1].Nodes[0]^.Kind = SSA_LOADBOOL) and
           (Length(FSF^.Blocks[Target1].Succs) >= 1) then begin
          if (FSF^.Blocks[Target1].Succs[0] = FoundBody) or
             (FSF^.Blocks[Target1].Succs[0] = FoundMerge) then
            IsSimpleVal := True;
        end;
        if not IsSimpleVal then begin Safety := 0; Break; end;
      end;
    end;

    if Safety = 1 then begin
      NextCond := ChainLen; { mark as computed for this length }
      Break; { Chain is valid at current length }
    end;

    { Validation failed, try shorter chain }
    if FOpts.Debug then
      WriteLn(StdErr, 'TryBuildCompoundCond: BB', BranchBlk,
              ' truncate chain from ', ChainLen, ' to ', ChainLen - 1);
    Dec(ChainLen);
  end;
  if ChainLen < 2 then Exit;

  { Reject or/and VALUE expression patterns.
    In a genuine compound if-condition (if a and b then body end), the "body"
    block contains side-effect statements like CALL, SETTABLE, etc.
    In an or/and value expression (y = (x>5) and "big" or "small"), the "body"
    block is a trivial value-producing block (LOADK + JMP) that feeds a PHI at
    the merge block.  Detect this and reject to let TryEmitOrAnd handle it.

    Check: if FoundBody has NO side-effect statements AND FoundMerge has a PHI
    node on the same register as a value defined in FoundBody, this is a value
    expression, not an if-condition.

    Also check: if BOTH FoundBody and FoundMerge are simple LOADBOOL blocks
    (each with only a single LOADBOOL node), this is a boolean value computation
    (e.g., assert(type(x) == 'number' and x > 0, msg)) that feeds into a PHI
    at a shared successor.  Reject to let the LOADBOOL comparison pattern or
    EmitBlock's PHI resolution handle it. }
  begin
    I := -1;  { reuse I temporarily for "value register" }
    Safety := 0; { reuse as "has side effect" flag }
    for CurBlk := 0 to High(FSF^.Blocks[FoundBody].Nodes) do begin
      BNode := FSF^.Blocks[FoundBody].Nodes[CurBlk];
      case BNode^.Kind of
        SSA_JUMP, SSA_PHI, SSA_NOP: { harmless };
        SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL, SSA_MOVE,
        SSA_GETTABLE, SSA_GETGLOBAL, SSA_GETUPVAL,
        SSA_BINOP, SSA_UNOP, SSA_CONCAT, SSA_NEWTABLE:
          I := BNode^.Dest.Reg; { track last value register }
        SSA_BRANCH: begin
          { TESTSET branches define a value - still a value expression.
            Comparison branches (EQ/LT/LE) that feed LOADBOOL blocks are
            also value expressions.
            TEST branches with 2+ successors indicate an inner if-statement
            --> reject as value expression. }
          if BNode^.RelOp = ropTestSet then
            I := BNode^.OpA.Reg
          else if BNode^.RelOp = ropTest then begin
            if (FoundBody >= 0) and (FoundBody < Length(FSF^.Blocks)) and
               (Length(FSF^.Blocks[FoundBody].Succs) >= 2) then
              Safety := 1; { inner TEST conditional --> not a simple value }
          end;
          { EQ/LT/LE comparisons are value-producing (via LOADBOOL), keep Safety=0 }
        end;
      else
        Safety := 1; { has side-effect --> not a value expression }
      end;
    end;
    if (Safety = 0) and (I >= 0) then begin
      { Check if FoundMerge has a PHI on the same register }
      for CurBlk := 0 to High(FSF^.Blocks[FoundMerge].Nodes) do begin
        BNode := FSF^.Blocks[FoundMerge].Nodes[CurBlk];
        if (BNode^.Kind = SSA_PHI) and (BNode^.Dest.Reg = I) then
          Exit; { This is a value expression, not a compound if-condition }
      end;
      { Check if both FoundBody and FoundMerge are simple LOADBOOL blocks
        that converge to a common successor with a PHI.  This pattern occurs
        when a compound boolean expression is computed as a function argument
        (e.g., assert(cond1 and cond2, msg)).  Instead of rejecting, we handle
        it: build the compound expression using the chain, mark LOADBOOL blocks
        emitted, cache the expression in the PHI, and return with CondExpr=''
        to signal the caller to just advance (no if-statement needed). }
      if (Length(FSF^.Blocks[FoundBody].Succs) >= 1) and
         (Length(FSF^.Blocks[FoundMerge].Succs) >= 1) and
         (FSF^.Blocks[FoundBody].Succs[0] = FSF^.Blocks[FoundMerge].Succs[0]) then begin
        { Both converge to the same successor - check if they're LOADBOOL-only }
        NextCond := FSF^.Blocks[FoundBody].Succs[0];
        Safety := 0; { reuse: 0=all LOADBOOL, 1=has other }
        for CurBlk := 0 to High(FSF^.Blocks[FoundBody].Nodes) do begin
          BNode := FSF^.Blocks[FoundBody].Nodes[CurBlk];
          if not (BNode^.Kind in [SSA_LOADBOOL, SSA_PHI, SSA_NOP, SSA_JUMP]) then begin
            Safety := 1; Break;
          end;
        end;
        if Safety = 0 then begin
          for CurBlk := 0 to High(FSF^.Blocks[FoundMerge].Nodes) do begin
            BNode := FSF^.Blocks[FoundMerge].Nodes[CurBlk];
            if not (BNode^.Kind in [SSA_LOADBOOL, SSA_PHI, SSA_NOP, SSA_JUMP]) then begin
              Safety := 1; Break;
            end;
          end;
        end;
        if (Safety = 0) and (NextCond >= 0) and (NextCond < Length(FSF^.Blocks)) then begin
          { Both are LOADBOOL-only and converge - check for PHI at their successor. }
          for CurBlk := 0 to High(FSF^.Blocks[NextCond].Nodes) do begin
            BNode := FSF^.Blocks[NextCond].Nodes[CurBlk];
            if (BNode^.Kind = SSA_PHI) and (BNode^.Dest.Reg = I) then begin
              { Found PHI.  Determine which LOADBOOL is the "true" value.
                The chain was built with FoundBody as the "true" target.
                Check which LOADBOOL value FoundBody has. }
              Target0 := 0; { FoundBody's LOADBOOL value }
              for Safety := 0 to High(FSF^.Blocks[FoundBody].Nodes) do begin
                if FSF^.Blocks[FoundBody].Nodes[Safety]^.Kind = SSA_LOADBOOL then begin
                  Target0 := FSF^.Blocks[FoundBody].Nodes[Safety]^.ImmA;
                  Break;
                end;
              end;
              { Now fall through to the chain-building code below (Phase 3 +
                expression building).  The chain is already validated.
                After the expression is built, we'll cache it in the PHI and
                return with CondExpr='' to signal "no if-statement needed".
                We need to set a flag so the code after expression building
                knows to do LOADBOOL caching instead of normal return. }
              { We'll handle this by NOT exiting here, but by letting the
                chain-building code run, then checking afterward.
                However, the code flow makes this complex.  Instead, build
                the expression inline here using the same logic. }

              { Build compound expression from chain }
              CondExpr := '';
              for Safety := 0 to ChainLen - 1 do begin
                { Find BRANCH node in this chain block }
                BNode := nil;
                for Target1 := 0 to High(FSF^.Blocks[ChainBlks[Safety]].Nodes) do
                  if FSF^.Blocks[ChainBlks[Safety]].Nodes[Target1]^.Kind = SSA_BRANCH then begin
                    BNode := FSF^.Blocks[ChainBlks[Safety]].Nodes[Target1]; Break;
                  end;
                if BNode = nil then begin Result := False; Exit; end;
                if Length(FSF^.Blocks[ChainBlks[Safety]].Succs) < 2 then begin Result := False; Exit; end;

                Succ0 := FSF^.Blocks[ChainBlks[Safety]].Succs[0];
                Succ1 := FSF^.Blocks[ChainBlks[Safety]].Succs[1];
                Target0 := FollowJmp(Succ0);
                Target1 := FollowJmp(Succ1);

                Connector := 'and';
                NextCond := -1;
                if Safety < ChainLen - 1 then
                  NextCond := ChainBlks[Safety + 1];

                if Safety = ChainLen - 1 then begin
                  if Target1 = FoundBody then
                    ChainConds[Safety] := SingleCondExpr(BNode, False)
                  else if Target0 = FoundBody then
                    ChainConds[Safety] := SingleCondExpr(BNode, True)
                  else
                    ChainConds[Safety] := SingleCondExpr(BNode, False);
                  Connector := '';
                end
                else if Target1 = NextCond then begin
                  if Target0 = FoundBody then begin
                    ChainConds[Safety] := SingleCondExpr(BNode, True);
                    Connector := 'or';
                  end else begin
                    ChainConds[Safety] := SingleCondExpr(BNode, False);
                    Connector := 'and';
                  end;
                end
                else if Target0 = NextCond then begin
                  if Target1 = FoundBody then begin
                    ChainConds[Safety] := SingleCondExpr(BNode, False);
                    Connector := 'or';
                  end else begin
                    ChainConds[Safety] := SingleCondExpr(BNode, True);
                    Connector := 'and';
                  end;
                end
                else begin
                  if (Target0 = FoundBody) or (Target0 = FoundMerge) then begin
                    ChainConds[Safety] := SingleCondExpr(BNode, Target0 = FoundBody);
                    if Target0 = FoundBody then Connector := 'or'
                    else Connector := 'and';
                  end
                  else if (Target1 = FoundBody) or (Target1 = FoundMerge) then begin
                    ChainConds[Safety] := SingleCondExpr(BNode, Target1 = FoundMerge);
                    if Target1 = FoundBody then Connector := 'or'
                    else Connector := 'and';
                  end
                  else begin
                    Result := False; Exit;
                  end;
                end;
                ChainOps[Safety] := Connector;
              end;
              { Assemble final expression (simple join).
                Grouping for mixed and/or happens AFTER De Morgan,
                since De Morgan swaps and↔or. }
              CondExpr := ChainConds[0];
              for Safety := 1 to ChainLen - 1 do
                CondExpr := CondExpr + ' ' + ChainOps[Safety - 1] + ' ' + ChainConds[Safety];

              { Determine if the LOADBOOL "true" block is FoundBody.
                FoundBody was the lower-PC block, treated as the "true" path
                by the chain-building logic above. Check FoundBody's LOADBOOL value. }
              Target0 := 0;
              for Safety := 0 to High(FSF^.Blocks[FoundBody].Nodes) do begin
                if FSF^.Blocks[FoundBody].Nodes[Safety]^.Kind = SSA_LOADBOOL then begin
                  Target0 := FSF^.Blocks[FoundBody].Nodes[Safety]^.ImmA;
                  Break;
                end;
              end;
              { If FoundBody has LOADBOOL(false), the chain condition leads to
                the "false" result, so we need to negate it.  If FoundBody has
                LOADBOOL(true), the condition directly produces the boolean.
                Apply De Morgan's law for cleaner output instead of wrapping
                with not(...): "x or a ~= b" --> "(not x) and (a == b)" }
              if Target0 = 0 then
                CondExpr := ApplyDeMorgan(CondExpr);

              { Group "or" sub-expressions in parens when adjacent to "and".
                e.g. "a and c == d or c == e and f" --> "a and (c == d or c == e) and f" }
              CondExpr := GroupMixedAndOr(CondExpr);

              { Parenthesize comparisons when mixed with "not" expressions.
                e.g. "(not x) and a == b" --> "(not x) and (a == b)" }
              CondExpr := ParenthesizeMixedNotCompare(CondExpr);

              { Cache in PHI's FExprStr }
              { Re-find the PHI node (inner loops may have changed BNode/CurBlk) }
              NextCond := -1;
              for Target1 := 0 to High(FSF^.Blocks[FSF^.Blocks[FoundBody].Succs[0]].Nodes) do begin
                BNode := FSF^.Blocks[FSF^.Blocks[FoundBody].Succs[0]].Nodes[Target1];
                if (BNode^.Kind = SSA_PHI) and (BNode^.Dest.Reg = I) then begin
                  NextCond := NodeIdx(BNode^.Dest.Reg, BNode^.Dest.Version);
                  Break;
                end;
              end;
              if (NextCond >= 0) and (NextCond < Length(FExprStr)) then
                FExprStr[NextCond] := CondExpr;

              if FOpts.Debug then
                WriteLn(StdErr, 'TryBuildCompoundCond: LOADBOOL pattern BB', BranchBlk,
                        ' cached "', CondExpr, '" in PHI');

              { Mark all chain blocks, LOADBOOL blocks, and JMP trampolines as emitted }
              FEmitted[FoundBody] := True;
              FEmitted[FoundMerge] := True;
              for Safety := 1 to ChainLen - 1 do begin
                FEmitted[ChainBlks[Safety]] := True;
                { Also mark JMP trampoline successors }
                if Length(FSF^.Blocks[ChainBlks[Safety]].Succs) >= 2 then begin
                  Succ0 := FSF^.Blocks[ChainBlks[Safety]].Succs[0];
                  if (Succ0 >= 0) and (Succ0 < NBlks) and
                     (Succ0 <> FoundBody) and (Succ0 <> FoundMerge) and
                     (Length(FSF^.Blocks[Succ0].Succs) = 1) then
                    FEmitted[Succ0] := True;
                end;
              end;

              { Return with CondExpr='' to signal "expression cached in PHI,
                no if-statement needed".  Set TrueTarget to the PHI merge block
                so the caller knows where to advance. }
              CondExpr := '';
              TrueTarget := FSF^.Blocks[FoundBody].Succs[0];
              FalseTarget := TrueTarget;
              Result := True;
              Exit;
            end;
          end;
        end;
      end;
    end;
  end;

  { Phase 3: Validate and strip leading blocks that are outer 'if' wrappers.
    Each block's non-chain targets must be FoundBody, FoundMerge, or another
    block IN THE CHAIN. If the first block has a target outside these, strip it.
    A condition block that is NOT in the chain (e.g., an elseif block) should
    also cause stripping - it's not part of this compound condition. }
  while ChainLen >= 2 do begin
    CurBlk := ChainBlks[0];
    if Length(FSF^.Blocks[CurBlk].Succs) < 2 then Break;
    Target0 := FollowJmp(FSF^.Blocks[CurBlk].Succs[0]);
    Target1 := FollowJmp(FSF^.Blocks[CurBlk].Succs[1]);
    { Check if Target0 is valid (body, merge, or in chain) }
    NextCond := 0; { reuse as "needs strip" flag: 0=ok, 1=strip }
    if (Target0 <> FoundBody) and (Target0 <> FoundMerge) then begin
      { Check if Target0 is in the chain }
      Safety := 0; { reuse as "found in chain" flag }
      for I := 0 to ChainLen - 1 do
        if ChainBlks[I] = Target0 then begin Safety := 1; Break; end;
      if Safety = 0 then NextCond := 1;
    end;
    if NextCond = 0 then begin
      { Also check Target1 }
      if (Target1 <> FoundBody) and (Target1 <> FoundMerge) then begin
        Safety := 0;
        for I := 0 to ChainLen - 1 do
          if ChainBlks[I] = Target1 then begin Safety := 1; Break; end;
        if Safety = 0 then NextCond := 1;
      end;
    end;
    if NextCond = 1 then begin
      { Strip this outer 'if' block from chain }
      for I := 0 to ChainLen - 2 do
        ChainBlks[I] := ChainBlks[I + 1];
      Dec(ChainLen);
      Continue;
    end;
    Break;
  end;
  if ChainLen < 2 then Exit;

  { If BranchBlk was stripped from the chain, bail out.  Let the caller handle
    BranchBlk as a normal if-statement; the compound condition starting at
    ChainBlks[0] will be detected when EmitRegion recurses into that block. }
  if ChainBlks[0] <> BranchBlk then Exit;

  { Second pass: build condition expressions with AND/OR connectors.
    For each branch in the chain, determine the condition and connector
    based on where its two targets lead.

    CFG convention:
      Succs[0] = JMP (condition FALSE path / fallthrough)
      Succs[1] = skip target (condition TRUE path)

    Rules for determining connector and inversion:
    Let NextBlk = ChainBlks[i+1] for non-last conditions.

    Case 1: Next condition on Succs[1] (true path), other on Succs[0]:
      - If Succs[0]-->body: TRUE=next(fail), FALSE=body(pass) --> INVERT cond, connector=or
      - If Succs[0]-->merge: TRUE=next(pass/AND), FALSE=fail --> no invert, connector=and
      - If Succs[0]-->another branch: TRUE=next(pass/AND), FALSE=OR-branch --> no invert, connector=and

    Case 2: Next condition on Succs[0] (false path), other on Succs[1]:
      - If Succs[1]-->body: TRUE=body(pass), FALSE=next(try OR) --> no invert, connector=or
      - If Succs[1]-->merge: TRUE=fail, FALSE=next(AND) --> INVERT, connector=and
      - If Succs[1]-->another branch: ambiguous

    For the last condition (no next):
      - If Succs[1]-->body and Succs[0]-->merge: no invert
      - If Succs[0]-->body and Succs[1]-->merge: invert }
  CondExpr := '';
  for I := 0 to ChainLen - 1 do begin
    CurBlk := ChainBlks[I];

    BNode := nil;
    for Safety := 0 to High(FSF^.Blocks[CurBlk].Nodes) do
      if FSF^.Blocks[CurBlk].Nodes[Safety]^.Kind = SSA_BRANCH then begin
        BNode := FSF^.Blocks[CurBlk].Nodes[Safety]; Break;
      end;
    if BNode = nil then begin Result := False; Exit; end;

    if Length(FSF^.Blocks[CurBlk].Succs) < 2 then begin Result := False; Exit; end;
    Succ0 := FSF^.Blocks[CurBlk].Succs[0]; { JMP/false }
    Succ1 := FSF^.Blocks[CurBlk].Succs[1]; { skip/true }
    Target0 := FollowJmp(Succ0);
    Target1 := FollowJmp(Succ1);

    Connector := 'and'; { default }
    NextCond := -1;
    if I < ChainLen - 1 then
      NextCond := ChainBlks[I + 1];

    if I = ChainLen - 1 then begin
      { Last condition: one path goes to body, other to merge }
      if Target1 = FoundBody then
        ChainConds[I] := SingleCondExpr(BNode, False)
      else if Target0 = FoundBody then
        ChainConds[I] := SingleCondExpr(BNode, True)
      else begin
        { Neither goes to body directly - use default }
        ChainConds[I] := SingleCondExpr(BNode, False);
      end;
      Connector := ''; { no connector after last }
    end
    else if Target1 = NextCond then begin
      { TRUE path --> next condition }
      if Target0 = FoundBody then begin
        { TRUE=next, FALSE=body: inverted cond, connector=or }
        ChainConds[I] := SingleCondExpr(BNode, True);
        Connector := 'or';
      end
      else begin
        { Check if Target0 is a later chain block (skip-ahead for OR group) }
        IsSimpleVal := False;
        for J := I + 2 to ChainLen - 1 do
          if ChainBlks[J] = Target0 then begin IsSimpleVal := True; Break; end;
        if IsSimpleVal then begin
          { OR group: condition true --> skip ahead to later chain block }
          ChainConds[I] := SingleCondExpr(BNode, True);
          Connector := 'or';
        end else begin
          { TRUE=next(AND), FALSE=merge/OR-branch: no invert, connector=and }
          ChainConds[I] := SingleCondExpr(BNode, False);
          Connector := 'and';
        end;
      end;
    end
    else if Target0 = NextCond then begin
      { FALSE path --> next condition }
      if Target1 = FoundBody then begin
        { TRUE=body, FALSE=next: no invert, connector=or }
        ChainConds[I] := SingleCondExpr(BNode, False);
        Connector := 'or';
      end
      else begin
        { Check if Target1 is a later chain block (skip-ahead for OR group) }
        IsSimpleVal := False;
        for J := I + 2 to ChainLen - 1 do
          if ChainBlks[J] = Target1 then begin IsSimpleVal := True; Break; end;
        if IsSimpleVal then begin
          { OR group: condition true --> skip ahead to later chain block }
          ChainConds[I] := SingleCondExpr(BNode, False);
          Connector := 'or';
        end else begin
          { TRUE=merge, FALSE=next(AND): invert, connector=and }
          ChainConds[I] := SingleCondExpr(BNode, True);
          Connector := 'and';
        end;
      end;
    end
    else begin
      { Next condition is not a direct successor - check if it's reachable
        through one of the successors (which may also be a branch block) }
      { Default: try to figure it out from what the other path leads to }
      if (Target0 = FoundBody) or (Target0 = FoundMerge) then begin
        ChainConds[I] := SingleCondExpr(BNode, Target0 = FoundBody);
        if Target0 = FoundBody then Connector := 'or'
        else Connector := 'and';
      end
      else if (Target1 = FoundBody) or (Target1 = FoundMerge) then begin
        ChainConds[I] := SingleCondExpr(BNode, Target1 = FoundMerge);
        if Target1 = FoundBody then Connector := 'or'
        else Connector := 'and';
      end
      else begin
        { Can't determine - bail out }
        Result := False; Exit;
      end;
    end;

    ChainOps[I] := Connector;
  end;

  { Build the final expression with proper parenthesization.
    In Lua, "and" binds tighter than "or", so "a or b and c" means "a or (b and c)".
    When we have "(a or b) and c", we need explicit parentheses around the "or" group.
    Strategy: identify contiguous groups with the same operator. When an "or" group
    appears as an operand of "and", wrap it in parentheses. }
  begin
    { Check if we have mixed operators }
    IsSimpleVal := False; { reuse: True = has mixed and/or }
    for I := 0 to ChainLen - 2 do
      if (ChainOps[I] <> '') and (I > 0) and (ChainOps[I] <> ChainOps[I - 1]) then begin
        IsSimpleVal := True; Break;
      end;

    if not IsSimpleVal then begin
      { All same operator - simple chain assembly, then apply
        parenthesization for mixed not/comparison expressions }
      CondExpr := ChainConds[0];
      for I := 1 to ChainLen - 1 do
        CondExpr := CondExpr + ' ' + ChainOps[I - 1] + ' ' + ChainConds[I];
      CondExpr := ParenthesizeMixedNotCompare(CondExpr);
    end else begin
      { Mixed operators - group "or" segments with parentheses when
        adjacent to "and" segments.
        Walk through the chain building groups: collect consecutive conditions
        with the same operator, wrap "or" groups in parens when the next/prev
        operator is "and". }
      CondExpr := '';
      I := 0;
      while I < ChainLen do begin
        { Start of a new group at position I }
        J := I;
        { Find the end of this contiguous operator group }
        while (J < ChainLen - 1) and (ChainOps[J] <> '') and
              ((J = I) or (ChainOps[J] = ChainOps[I])) do
          Inc(J);
        { Group is from I to J (inclusive) with operator ChainOps[I] }
        { Build sub-expression for this group }
        Connector := '';
        for Safety := I to J do begin
          if Safety > I then
            Connector := Connector + ' ' + ChainOps[I] + ' ';
          Connector := Connector + ChainConds[Safety];
        end;
        { Wrap in parens if this is an "or" group and there are "and" operators adjacent }
        if (ChainOps[I] = 'or') and (J > I) then begin
          { Check if there's an "and" before or after }
          IsSimpleVal := False;
          if (I > 0) and (ChainOps[I - 1] = 'and') then IsSimpleVal := True;
          if (J < ChainLen - 1) and (ChainOps[J] = 'and') then IsSimpleVal := True;
          if IsSimpleVal then
            Connector := '(' + Connector + ')';
        end;
        { Append to final expression }
        if CondExpr <> '' then begin
          { The connector between this group and the previous one is ChainOps[I-1] }
          if I > 0 then
            CondExpr := CondExpr + ' ' + ChainOps[I - 1] + ' ' + Connector
          else
            CondExpr := Connector;
        end else
          CondExpr := Connector;
        I := J + 1;
      end;
    end;
  end;

  TrueTarget := FoundBody;
  FalseTarget := FoundMerge;

  { Mark all intermediate branch-only blocks and their JMP trampolines as emitted.
    Note: do NOT mark FoundBody or FoundMerge - those are the then/else targets
    that the caller (EmitIfRegion) will handle. }
  for I := 0 to ChainLen - 1 do begin
    CurBlk := ChainBlks[I];
    if CurBlk <> BranchBlk then
      FEmitted[CurBlk] := True;
    { Also mark JMP-only trampoline blocks between chain blocks }
    if Length(FSF^.Blocks[CurBlk].Succs) >= 2 then begin
      Succ0 := FSF^.Blocks[CurBlk].Succs[0];
      Succ1 := FSF^.Blocks[CurBlk].Succs[1];
      if (Succ0 >= 0) and (Succ0 < NBlks) and
         (Length(FSF^.Blocks[Succ0].Succs) = 1) then begin
        Target0 := Succ0;
        Safety := 0;
        for Safety := 0 to High(FSF^.Blocks[Target0].Nodes) do
          if not (FSF^.Blocks[Target0].Nodes[Safety]^.Kind in
                  [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
            Target0 := -1; Break;
          end;
        if (Target0 >= 0) and (Target0 <> FoundBody) and (Target0 <> FoundMerge) then
          FEmitted[Succ0] := True;
      end;
    end;
  end;

  if FOpts.Debug then
    WriteLn(StdErr, 'TryBuildCompoundCond: success BB', BranchBlk,
            ' cond="', CondExpr, '" body=', TrueTarget, ' merge=', FalseTarget);
  Result := True;
end;

{ ======================================================================
  EmitIfRegionCompound - emit if/then/else using a pre-built compound
  condition expression.  Used when TryBuildCompoundCond has collected a
  chain of branch blocks into a single expression string.
  ====================================================================== }

procedure TDecompiler.EmitIfRegionCompound(BranchBlk, TrueBlk, FalseBlk,
                                            MergeBlk: Integer;
                                            const CompoundCond: AnsiString);

  function FollowJmpOnly(Blk: Integer; Merge: Integer): Integer;
  var J: Integer; Jmp: Boolean;
  begin
    Result := Blk;
    if (Blk >= 0) and (Blk < Length(FSF^.Blocks)) and
       (Blk <> Merge) and
       (Length(FSF^.Blocks[Blk].Succs) = 1) then begin
      Jmp := True;
      for J := 0 to High(FSF^.Blocks[Blk].Nodes) do
        if not (FSF^.Blocks[Blk].Nodes[J]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
          Jmp := False; Break;
        end;
      if Jmp then begin
        FEmitted[Blk] := True;
        Result := FSF^.Blocks[Blk].Succs[0];
      end;
    end;
  end;

var
  ActualTrueBlk, ActualFalseBlk: Integer;
  HasTrueBody, HasFalseBody: Boolean;
  I, J2: Integer;
  N: PSSANode;
  TmpFlag: Boolean;
  FalseBodyStartCount, ElseLineIdx: Integer;
begin
  { Mark branch block (and all intermediate chain blocks already marked) }
  FEmitted[BranchBlk] := True;

  { Emit non-branch statements in branch block first.
    The first block in the compound chain may contain body statements
    before its branch (e.g., print("check 1") followed by if a or b then ...).
    Subsequent chain blocks are branch-only, but the first one may not be. }
  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;

  { Follow JMP-only trampoline blocks to find real bodies }
  ActualTrueBlk := FollowJmpOnly(TrueBlk, MergeBlk);
  ActualFalseBlk := FollowJmpOnly(FalseBlk, MergeBlk);

  HasTrueBody := (ActualTrueBlk >= 0) and (ActualTrueBlk <> MergeBlk) and
                 (ActualTrueBlk < Length(FSF^.Blocks));
  HasFalseBody := (ActualFalseBlk >= 0) and (ActualFalseBlk <> MergeBlk) and
                  (ActualFalseBlk < Length(FSF^.Blocks));

  EmitLine('if ' + CompoundCond + ' then');
  Indent;
  if HasTrueBody then
    EmitRegion(ActualTrueBlk, MergeBlk);
  Dedent;

  { Re-check HasFalseBody after body emission: the body's internal control
    flow (e.g., nested if with shared return target) may have already emitted
    the false-body block, making the else body effectively empty. }
  if HasFalseBody and (ActualFalseBlk >= 0) and
     (ActualFalseBlk < Length(FSF^.Blocks)) and
     FEmitted[ActualFalseBlk] then
    HasFalseBody := False;

  { Check if the true branch ends with return/tailcall (no successors).
    If so, skip "else" - emit the false body as continuation after "end". }
  if HasFalseBody then begin
    if (ActualTrueBlk >= 0) and (ActualTrueBlk < Length(FSF^.Blocks)) and
       (Length(FSF^.Blocks[ActualTrueBlk].Succs) = 0) then begin
      { True branch ends with return --> continuation, not else }
      EmitLine('end');
      EmitRegion(ActualFalseBlk, MergeBlk);
    end else begin
      { Check if the else body is empty (only PHI/NOP/JUMP/CLOSE nodes).
        If so, suppress the empty "else" to avoid emitting "else\nend". }
      TmpFlag := (ActualFalseBlk = MergeBlk);
      if (not TmpFlag) and (ActualFalseBlk >= 0) and
         (ActualFalseBlk < Length(FSF^.Blocks)) then begin
        TmpFlag := True;  { assume empty until proven otherwise }
        for I := ActualFalseBlk to MergeBlk - 1 do begin
          if (I < 0) or (I >= Length(FSF^.Blocks)) then Break;
          for J2 := 0 to High(FSF^.Blocks[I].Nodes) do
            if not (FSF^.Blocks[I].Nodes[J2]^.Kind in
                    [SSA_PHI, SSA_NOP, SSA_JUMP, SSA_CLOSE]) then begin
              TmpFlag := False; Break;
            end;
          if not TmpFlag then Break;
        end;
      end;
      if TmpFlag then
        EmitLine('end')
      else begin
        ElseLineIdx := FOutput.Count;
        EmitLine('else');
        Indent;
        FalseBodyStartCount := FOutput.Count;
        EmitRegion(ActualFalseBlk, MergeBlk);
        Dedent;
        if FOutput.Count = FalseBodyStartCount then
          if FOutput.Count = ElseLineIdx + 1 then
            FOutput.DeleteLast;
        EmitLine('end');
      end;
    end;
  end else
    EmitLine('end');
end;

{ ======================================================================
  EmitIfRegion
  ====================================================================== }

procedure TDecompiler.EmitIfRegion(BranchBlk, TrueBlk, FalseBlk, MergeBlk: Integer);

  function BuildCondExpr(BNode: PSSANode): AnsiString;
  begin
    if BNode <> nil then begin
      case BNode^.RelOp of
        ropEQ, ropLT, ropLE:
          Result := BuildCompare(BNode^.OpA, BNode^.OpB,
                                  BNode^.RelOp, BNode^.Invert,
                                  BNode^.PC);
        ropTest, ropTestSet: begin
          if BNode^.Invert then
            Result := 'not ' + ExprOf(BNode^.OpA, BNode^.PC)
          else
            Result := ExprOf(BNode^.OpA, BNode^.PC);
        end;
      else
        Result := 'cond';
      end;
    end else
      Result := 'cond';
  end;

  function FollowJmpOnly(Blk: Integer; Merge: Integer): Integer;
  var J: Integer; Jmp: Boolean;
  begin
    Result := Blk;
    if (Blk >= 0) and (Blk < Length(FSF^.Blocks)) and
       (Blk <> Merge) and
       (Length(FSF^.Blocks[Blk].Succs) = 1) then begin
      Jmp := True;
      for J := 0 to High(FSF^.Blocks[Blk].Nodes) do
        if not (FSF^.Blocks[Blk].Nodes[J]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
          Jmp := False; Break;
        end;
      if Jmp then begin
        FEmitted[Blk] := True;
        Result := FSF^.Blocks[Blk].Succs[0];
      end;
    end;
  end;

  function IsElseIfBlock(Blk, Merge: Integer): Boolean;
  { Returns true if the block is an elseif candidate: it contains only
    condition-setup nodes + exactly one comparison BRANCH (EQ/LT/LE),
    plus has 2 successors.  TEST/TESTSET branches are value-expression
    branches (for or/and patterns) and do NOT qualify as elseif conditions.
    Condition setup includes: PHI, NOP, JUMP, constants, loads (GETGLOBAL,
    GETTABLE, GETUPVAL), MOVE, and pure expression nodes (BINOP, UNOP,
    CONCAT) that compute the branch operand. Side-effect nodes like CALL,
    SETTABLE, SETGLOBAL, etc. disqualify the block.
    Loop headers are NOT elseif candidates - they are while/repeat loops. }
  var
    J, BranchCnt, SideEffectCnt: Integer;
    Nd: PSSANode;
    HasComparisonBranch: Boolean;
    S0, S1, LBReg0, LBReg1: Integer;
    IsJmp: Boolean;
  begin
    Result := False;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) or (Blk = Merge) then Exit;
    if Length(FSF^.Blocks[Blk].Succs) < 2 then Exit;
    { Reject loop headers - they have back-edge predecessors }
    if IsLoopHeader(Blk) then Exit;
    BranchCnt := 0; SideEffectCnt := 0;
    HasComparisonBranch := False;
    for J := 0 to High(FSF^.Blocks[Blk].Nodes) do begin
      Nd := FSF^.Blocks[Blk].Nodes[J];
      if Nd^.Kind = SSA_BRANCH then begin
        Inc(BranchCnt);
        if Nd^.RelOp in [ropEQ, ropLT, ropLE] then
          HasComparisonBranch := True;
      end
      else if Nd^.Kind = SSA_CALL then
        { CALL setup cannot be emitted inside an "elseif" header.  Even when
          value-producing, it may need a preceding local temp in stripped code;
          forcing this block to a nested if keeps Lua syntax valid. }
        Inc(SideEffectCnt)
      else if not (Nd^.Kind in [SSA_PHI, SSA_NOP, SSA_JUMP,
                                SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                                SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                                SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then
        Inc(SideEffectCnt);
    end;
    Result := (BranchCnt = 1) and (SideEffectCnt = 0) and HasComparisonBranch;
    { Reject blocks where "neutral" nodes write to parameter registers.
      Parameters (registers 0..NumParams-1) are user-visible variables;
      overwriting them is a side-effect statement, not condition setup.
      Example: "t = t / d * 2; if t < 1 then" compiles to
      BINOP R0_1 := R4_1 * K(2) overwriting parameter t (R0),
      then BRANCH [<] R0_1 K(1). This is NOT an elseif - it's an
      assignment followed by an if. Also catches value-producing CALLs
      that store results into parameter registers. }
    if Result then begin
      for J := 0 to High(FSF^.Blocks[Blk].Nodes) do begin
        Nd := FSF^.Blocks[Blk].Nodes[J];
        if (Nd^.Dest.Reg >= 0) and (Nd^.Dest.Reg < FProto^.NumParams) and
           (Nd^.Kind in [SSA_BINOP, SSA_UNOP, SSA_CONCAT, SSA_MOVE,
                         SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                         SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                         SSA_CALL]) then begin
          Result := False;
          Break;
        end;
      end;
    end;
    { Reject LOADBOOL pair pattern: value computation disguised as comparison branch.
      If both successors (after resolving JMP-only trampolines) lead to LOADBOOL
      blocks for the same register, this is a boolean value expression, not elseif.
      Example: assert(targetType == "number", ...) compiles to EQ + LOADBOOL pair. }
    if Result and (Length(FSF^.Blocks[Blk].Succs) >= 2) then begin
      S0 := FSF^.Blocks[Blk].Succs[0];
      S1 := FSF^.Blocks[Blk].Succs[1];
      if (S0 >= 0) and (S0 < Length(FSF^.Blocks)) and
         (S1 >= 0) and (S1 < Length(FSF^.Blocks)) then begin
        { Resolve S0 through JMP-only trampoline }
        IsJmp := True;
        for J := 0 to High(FSF^.Blocks[S0].Nodes) do
          if not (FSF^.Blocks[S0].Nodes[J]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
            IsJmp := False; Break;
          end;
        if IsJmp and (Length(FSF^.Blocks[S0].Succs) = 1) then
          S0 := FSF^.Blocks[S0].Succs[0];
        { Resolve S1 through JMP-only trampoline }
        IsJmp := True;
        for J := 0 to High(FSF^.Blocks[S1].Nodes) do
          if not (FSF^.Blocks[S1].Nodes[J]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
            IsJmp := False; Break;
          end;
        if IsJmp and (Length(FSF^.Blocks[S1].Succs) = 1) then
          S1 := FSF^.Blocks[S1].Succs[0];
        { Check if both resolved targets start with LOADBOOL for same register }
        LBReg0 := -1; LBReg1 := -1;
        if (S0 >= 0) and (S0 < Length(FSF^.Blocks)) then
          for J := 0 to High(FSF^.Blocks[S0].Nodes) do begin
            if FSF^.Blocks[S0].Nodes[J]^.Kind in [SSA_PHI, SSA_NOP] then Continue;
            if FSF^.Blocks[S0].Nodes[J]^.Kind = SSA_LOADBOOL then
              LBReg0 := FSF^.Blocks[S0].Nodes[J]^.Dest.Reg;
            Break;
          end;
        if (S1 >= 0) and (S1 < Length(FSF^.Blocks)) then
          for J := 0 to High(FSF^.Blocks[S1].Nodes) do begin
            if FSF^.Blocks[S1].Nodes[J]^.Kind in [SSA_PHI, SSA_NOP] then Continue;
            if FSF^.Blocks[S1].Nodes[J]^.Kind = SSA_LOADBOOL then
              LBReg1 := FSF^.Blocks[S1].Nodes[J]^.Dest.Reg;
            Break;
          end;
        if (LBReg0 >= 0) and (LBReg0 = LBReg1) then
          Result := False;
      end;
    end;
  end;

  function TrueBodyEndsWithReturn(StartBlk, StopBlk: Integer): Boolean;
  { Check if the blocks between StartBlk and StopBlk contain a RETURN/TAILCALL. }
  var
    BI, NI: Integer;
    Nd: PSSANode;
  begin
    Result := False;
    for BI := StartBlk to StopBlk - 1 do begin
      if (BI < 0) or (BI >= Length(FSF^.Blocks)) then Continue;
      for NI := 0 to High(FSF^.Blocks[BI].Nodes) do begin
        Nd := FSF^.Blocks[BI].Nodes[NI];
        if Nd^.Kind in [SSA_RETURN, SSA_TAILCALL] then begin
          Result := True; Exit;
        end;
      end;
    end;
  end;

  function ResolveEarlyExit(Blk: Integer): Integer;
  { Chase JMP-only trampoline chains to find terminal RETURN/TAILCALL block.
    Returns block index if found, -1 otherwise.
    Side effect: marks all intermediate JMP-only trampolines as emitted
    (FEmitted[trampoline] := True) to prevent noise during region traversal.
    MaxSteps = min(64, NBlks) to handle obfuscated chains. }
  var
    Cur, Steps, J, MaxSteps: Integer;
    IsJmp, HasRet: Boolean;
  begin
    Result := -1;
    MaxSteps := Length(FSF^.Blocks);
    if MaxSteps > 64 then MaxSteps := 64;
    Cur := Blk;
    for Steps := 0 to MaxSteps - 1 do begin
      if (Cur < 0) or (Cur >= Length(FSF^.Blocks)) then Exit;
      { Check if this block has RETURN/TAILCALL }
      HasRet := False;
      for J := 0 to High(FSF^.Blocks[Cur].Nodes) do
        if FSF^.Blocks[Cur].Nodes[J]^.Kind in [SSA_RETURN, SSA_TAILCALL] then begin
          HasRet := True; Break;
        end;
      if HasRet and (Length(FSF^.Blocks[Cur].Succs) = 0) then begin
        Result := Cur; Exit;
      end;
      { Follow JMP-only chain }
      if Length(FSF^.Blocks[Cur].Succs) <> 1 then Exit;
      IsJmp := True;
      for J := 0 to High(FSF^.Blocks[Cur].Nodes) do
        if not (FSF^.Blocks[Cur].Nodes[J]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
          IsJmp := False; Break;
        end;
      if not IsJmp then Exit;
      { Mark this trampoline as emitted before following }
      FEmitted[Cur] := True;
      Cur := FSF^.Blocks[Cur].Succs[0];
    end;
  end;

  function NegateCondExpr(const Cond: AnsiString): AnsiString;
  { Negate a condition expression.
    For atomic conditions: use InvertAtom (flips comparison operators).
    For compound conditions (and/or): wrap with not(...) as safe fallback. }
  begin
    if (Pos(' and ', Cond) > 0) or (Pos(' or ', Cond) > 0) then
      Result := 'not (' + Cond + ')'
    else
      Result := InvertAtom(Cond);
  end;

  function CanCloneSimpleElseBody(Blk, StopBlk: Integer): Boolean;
  { Nested ifs can share the same compiler-generated else block.  EmitRegion
    marks that block after the first nested path, so later else arms would
    otherwise become empty.  Only clone straight-line side-effect blocks where
    repeating the emitted source is safer than dropping the path. }
  var
    J: Integer;
    Nd: PSSANode;
    HasSideEffect: Boolean;
  begin
    Result := False;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) or (Blk = StopBlk) then Exit;
    if Length(FSF^.Blocks[Blk].Succs) > 1 then Exit;
    if (Length(FSF^.Blocks[Blk].Succs) = 1) and
       (StopBlk >= 0) and (FSF^.Blocks[Blk].Succs[0] <> StopBlk) then
      Exit;

    HasSideEffect := False;
    for J := 0 to High(FSF^.Blocks[Blk].Nodes) do begin
      Nd := FSF^.Blocks[Blk].Nodes[J];
      case Nd^.Kind of
        SSA_PHI, SSA_NOP, SSA_JUMP, SSA_CLOSE:
          ;
        SSA_CALL: begin
          if Nd^.ImmC > 1 then Exit;
          HasSideEffect := True;
        end;
        SSA_SETTABLE, SSA_SETGLOBAL, SSA_SETUPVAL, SSA_SETLIST: begin
          HasSideEffect := True;
        end;
        SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL, SSA_GETGLOBAL, SSA_GETTABLE,
        SSA_GETUPVAL, SSA_SELF, SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT,
        SSA_NEWTABLE:
          ;
      else
        Exit;
      end;
    end;

    Result := HasSideEffect;
  end;

  procedure RefreshFalseBodyAfterNestedEmission(Blk, StopBlk: Integer;
    var HasBody: Boolean; var CloneAlreadyEmitted: Boolean);
  begin
    CloneAlreadyEmitted := False;
    if not HasBody then Exit;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) then begin
      HasBody := False;
      Exit;
    end;
    if FEmitted[Blk] then begin
      if CanCloneSimpleElseBody(Blk, StopBlk) then
        CloneAlreadyEmitted := True
      else
        HasBody := False;
    end;
  end;

  procedure EmitMaybeClonedRegion(Blk, StopBlk: Integer;
    CloneAlreadyEmitted: Boolean);
  begin
    if CloneAlreadyEmitted then
      EmitBlock(Blk)
    else
      EmitRegion(Blk, StopBlk);
  end;

var
  BranchNode: PSSANode;
  I: Integer;
  CondExpr: AnsiString;
  N: PSSANode;
  ActualTrueBlk, ActualFalseBlk: Integer;
  HasTrueBody, HasFalseBody: Boolean;
  FalseBodyClone: Boolean;
  TmpFlag: Boolean;
  ElseIfBranch: PSSANode;
  ElseIfTrue, ElseIfFalse: Integer;
  ElseIfMerge: Integer;
  NextMerge: Integer;
  GuardClauseFlattened: Boolean;
  GuardLine, GuardIfLine: AnsiString;
  GuardIdx: Integer;
  GuardSameLine: Boolean;
  RetPC: Integer;
  IfOpenIdx: Integer;
  IfEndPC: Integer;
  TrueBodyStartCount: Integer;
  FalseBodyStartCount: Integer;
  ElseLineIdx: Integer;
  LastElseIfLineIdx: Integer;
  LastElseIfHadBody: Boolean;
  ExitBlk: Integer;
  NegCond: AnsiString;
  PredCount, PredI, PredJ: Integer;
begin
  GuardClauseFlattened := False;
  LastElseIfLineIdx := -1;
  LastElseIfHadBody := True;
  if FOpts.Debug then
    WriteLn(StdErr, 'EmitIfRegion: BranchBlk=BB', BranchBlk,
            ' TrueBlk=BB', TrueBlk, ' FalseBlk=BB', FalseBlk,
            ' MergeBlk=BB', MergeBlk);

  { Find the branch node }
  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;

  { Follow JMP-only trampoline blocks to find real bodies }
  ActualTrueBlk := FollowJmpOnly(TrueBlk, MergeBlk);
  ActualFalseBlk := FollowJmpOnly(FalseBlk, MergeBlk);
  FalseBodyClone := False;

  { Emit non-branch statements in branch block BEFORE building the condition
    expression.  This ensures that registers cached by EmitNode (e.g. temp
    variables for GETTABLE/MOVE) are properly named so the condition doesn't
    inline full expressions that were already emitted as statements. }
  FEmitted[BranchBlk] := True;
  EmitBlock(BranchBlk);

  CondExpr := BuildCondExpr(BranchNode);

  { Determine if each branch has a body to emit.
    Suppress body if the target is already emitted (e.g., loop back-edge).
    A back-edge to a loop header (target <= branch block) is a continuation,
    not a body - suppress those too. Forward jumps to loop headers are fine
    (entering a while loop body inside an if). }
  HasTrueBody := (ActualTrueBlk >= 0) and (ActualTrueBlk <> MergeBlk) and
                 (ActualTrueBlk < Length(FSF^.Blocks)) and
                 (not FEmitted[ActualTrueBlk]) and
                 (not ((ActualTrueBlk <= BranchBlk) and IsLoopHeader(ActualTrueBlk)));
  HasFalseBody := (ActualFalseBlk >= 0) and (ActualFalseBlk <> MergeBlk) and
                  (ActualFalseBlk < Length(FSF^.Blocks)) and
                  (not FEmitted[ActualFalseBlk]) and
                  (not ((ActualFalseBlk <= BranchBlk) and IsLoopHeader(ActualFalseBlk)));

  { Suppress false body if the block only contains RETURN/PHI/NOP/JUMP/CLOSE -
    no real statements.  This avoids emitting a spurious "else\nend" for blocks
    that are just the implicit trailing RETURN of a function or a CLOSE-only
    merge path (Lua 5.4+ to-be-closed variable cleanup). }
  if HasFalseBody then begin
    TmpFlag := False;
    for I := 0 to High(FSF^.Blocks[ActualFalseBlk].Nodes) do
      if not (FSF^.Blocks[ActualFalseBlk].Nodes[I]^.Kind in
              [SSA_RETURN, SSA_NOP, SSA_JUMP, SSA_PHI, SSA_CLOSE]) then begin
        TmpFlag := True; Break;
      end;
    if not TmpFlag then
      HasFalseBody := False;
  end;

  { Inverted guard clause: no true body, false body is an early exit.
    When FindMerge returns MergeBlk = TrueBlk (continuation), the true
    branch has no body (it IS the continuation) and the false branch
    jumps to a RETURN/TAILCALL block via trampoline(s).
    Emit: if NegateCondExpr(cond) then return ... end
    then continue from MergeBlk. }
  if (not HasTrueBody) and HasFalseBody then begin
    ExitBlk := ResolveEarlyExit(ActualFalseBlk);
    if ExitBlk >= 0 then begin
      NegCond := NegateCondExpr(CondExpr);
      IfOpenIdx := FOutput.Count;
      if (BranchNode <> nil) then FAnnotatePC := BranchNode^.PC;
      EmitLine('if ' + NegCond + ' then');
      FAnnotatePC := -1;
      Indent;
      EmitReturnOnly(ExitBlk);
      { Mark ExitBlk as emitted only if it has a single predecessor -
        prevents duplicate emission for unique return blocks while
        preserving shared return blocks for subsequent guard clauses. }
      PredCount := 0;
      for PredI := 0 to High(FSF^.Blocks) do
        for PredJ := 0 to High(FSF^.Blocks[PredI].Succs) do
          if FSF^.Blocks[PredI].Succs[PredJ] = ExitBlk then begin
            Inc(PredCount); Break;
          end;
      if PredCount <= 1 then
        FEmitted[ExitBlk] := True;
      Dedent;
      EmitLine('end');
      { Single-line collapse }
      if (BranchNode <> nil) and (BranchNode^.PC >= 0) then begin
        IfEndPC := -1;
        if (ExitBlk >= 0) and (ExitBlk < Length(FSF^.Blocks)) then
          IfEndPC := FSF^.Blocks[ExitBlk].StartPC +
                     Length(FSF^.Blocks[ExitBlk].Nodes) - 1;
        TryCollapseSingleLineBlock(IfOpenIdx, BranchNode^.PC, IfEndPC);
      end;
      Exit;
    end;
  end;

  if (not HasTrueBody) and (not HasFalseBody) then
    Exit;

  IfOpenIdx := FOutput.Count;
  if (BranchNode <> nil) then FAnnotatePC := BranchNode^.PC;
  EmitLine('if ' + CondExpr + ' then');
  FAnnotatePC := -1;
  Indent;

  TrueBodyStartCount := FOutput.Count;
  if HasTrueBody then begin
    EmitRegion(ActualTrueBlk, MergeBlk);
    if FOutput.Count = TrueBodyStartCount then
      HasTrueBody := False;
  end;

  Dedent;
  RefreshFalseBodyAfterNestedEmission(ActualFalseBlk, MergeBlk,
                                      HasFalseBody, FalseBodyClone);
  if (not HasTrueBody) and (not HasFalseBody) then begin
    if FOutput.Count = IfOpenIdx + 1 then
      FOutput.DeleteLast;
    Exit;
  end;

  { Elseif chain detection: if the else body is itself a pure branch block
    (only PHI/NOP + BRANCH), emit "elseif" instead of "else" + nested "if...end".
    This handles Lua's elseif chain pattern. }
  if HasFalseBody and IsElseIfBlock(ActualFalseBlk, MergeBlk) then begin
    { Recursive elseif: mark this block, find its branch, and recurse }
    ElseIfBranch := nil;
    for I := 0 to High(FSF^.Blocks[ActualFalseBlk].Nodes) do
      if FSF^.Blocks[ActualFalseBlk].Nodes[I]^.Kind = SSA_BRANCH then begin
        ElseIfBranch := FSF^.Blocks[ActualFalseBlk].Nodes[I]; Break;
      end;
    if ElseIfBranch <> nil then begin
      FEmitted[ActualFalseBlk] := True;
      CondExpr := BuildCondExpr(ElseIfBranch);
      { Get true/false successors using same swap convention as EmitRegion }
      if Length(FSF^.Blocks[ActualFalseBlk].Succs) >= 2 then begin
        ElseIfTrue := FSF^.Blocks[ActualFalseBlk].Succs[1]; { skip target = true }
        ElseIfFalse := FSF^.Blocks[ActualFalseBlk].Succs[0]; { JMP block = false }
      end else begin
        ElseIfTrue := -1; ElseIfFalse := -1;
      end;

      { Emit non-branch nodes from elseif block (e.g. LOADKs) }
      for I := 0 to High(FSF^.Blocks[ActualFalseBlk].Nodes) do begin
        N := FSF^.Blocks[ActualFalseBlk].Nodes[I];
        if not (N^.Kind in [SSA_BRANCH, SSA_PHI, SSA_NOP, SSA_JUMP,
                            SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                            SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                            SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then
          EmitNode(N, ActualFalseBlk);
      end;

      { Follow JMP-only trampolines for the elseif's branches }
      ActualTrueBlk := FollowJmpOnly(ElseIfTrue, MergeBlk);
      ActualFalseBlk := FollowJmpOnly(ElseIfFalse, MergeBlk);

      HasTrueBody := (ActualTrueBlk >= 0) and (ActualTrueBlk <> MergeBlk) and
                     (ActualTrueBlk < Length(FSF^.Blocks));
      HasFalseBody := (ActualFalseBlk >= 0) and (ActualFalseBlk <> MergeBlk) and
                      (ActualFalseBlk < Length(FSF^.Blocks));
      FalseBodyClone := False;

      LastElseIfLineIdx := FOutput.Count;
      EmitLine('elseif ' + CondExpr + ' then');
      Indent;
      TrueBodyStartCount := FOutput.Count;
      if HasTrueBody then begin
        { Bound body at the next elseif/else block to prevent consuming siblings }
        ElseIfMerge := MergeBlk;
        if (ActualFalseBlk >= 0) and (ActualFalseBlk > ActualTrueBlk) and
           (ActualFalseBlk < MergeBlk) then
          ElseIfMerge := ActualFalseBlk;
        EmitRegion(ActualTrueBlk, ElseIfMerge);
        if FOutput.Count = TrueBodyStartCount then
          HasTrueBody := False;
      end;
      Dedent;
      LastElseIfHadBody := HasTrueBody;
      RefreshFalseBodyAfterNestedEmission(ActualFalseBlk, MergeBlk,
                                          HasFalseBody, FalseBodyClone);

      { Continue elseif chain: keep peeling elseifs until we hit a non-branch else }
      while HasFalseBody and IsElseIfBlock(ActualFalseBlk, MergeBlk) do begin
        ElseIfBranch := nil;
        for I := 0 to High(FSF^.Blocks[ActualFalseBlk].Nodes) do
          if FSF^.Blocks[ActualFalseBlk].Nodes[I]^.Kind = SSA_BRANCH then begin
            ElseIfBranch := FSF^.Blocks[ActualFalseBlk].Nodes[I]; Break;
          end;
        if ElseIfBranch = nil then Break;
        FEmitted[ActualFalseBlk] := True;
        CondExpr := BuildCondExpr(ElseIfBranch);
        if Length(FSF^.Blocks[ActualFalseBlk].Succs) >= 2 then begin
          ElseIfTrue := FSF^.Blocks[ActualFalseBlk].Succs[1];
          ElseIfFalse := FSF^.Blocks[ActualFalseBlk].Succs[0];
        end else Break;

        { Emit non-branch nodes from elseif block }
        for I := 0 to High(FSF^.Blocks[ActualFalseBlk].Nodes) do begin
          N := FSF^.Blocks[ActualFalseBlk].Nodes[I];
          if not (N^.Kind in [SSA_BRANCH, SSA_PHI, SSA_NOP, SSA_JUMP,
                              SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL]) then
            EmitNode(N, ActualFalseBlk);
        end;

        ActualTrueBlk := FollowJmpOnly(ElseIfTrue, MergeBlk);
        ActualFalseBlk := FollowJmpOnly(ElseIfFalse, MergeBlk);

        HasTrueBody := (ActualTrueBlk >= 0) and (ActualTrueBlk <> MergeBlk) and
                       (ActualTrueBlk < Length(FSF^.Blocks));
        HasFalseBody := (ActualFalseBlk >= 0) and (ActualFalseBlk <> MergeBlk) and
                        (ActualFalseBlk < Length(FSF^.Blocks));
        FalseBodyClone := False;

        LastElseIfLineIdx := FOutput.Count;
        EmitLine('elseif ' + CondExpr + ' then');
        Indent;
        TrueBodyStartCount := FOutput.Count;
        if HasTrueBody then begin
          { Bound body at the next elseif/else block to prevent consuming siblings }
          ElseIfMerge := MergeBlk;
          if (ActualFalseBlk >= 0) and (ActualFalseBlk > ActualTrueBlk) and
             (ActualFalseBlk < MergeBlk) then
            ElseIfMerge := ActualFalseBlk;
          EmitRegion(ActualTrueBlk, ElseIfMerge);
          if FOutput.Count = TrueBodyStartCount then
            HasTrueBody := False;
        end;
        Dedent;
        LastElseIfHadBody := HasTrueBody;
        RefreshFalseBodyAfterNestedEmission(ActualFalseBlk, MergeBlk,
                                            HasFalseBody, FalseBodyClone);
      end;

      { Final else if there's still a false body }
      if HasFalseBody then begin
        { Guard clause detection for elseif chain final else.
          Bound the scan at ActualFalseBlk so we only check the TRUE body,
          not the false body (which may contain its own RETURN). }
        TmpFlag := False;
        if TrueBodyEndsWithReturn(ActualTrueBlk, ActualFalseBlk) then begin
          TmpFlag := True;
          for I := ActualTrueBlk + 1 to ActualFalseBlk - 1 do begin
            if (I < 0) or (I >= Length(FSF^.Blocks)) then Continue;
            if Length(FSF^.Blocks[I].Preds) > 0 then Continue;
            for ElseIfTrue := 0 to High(FSF^.Blocks[I].Nodes) do
              if FSF^.Blocks[I].Nodes[ElseIfTrue]^.Kind = SSA_JUMP then begin
                TmpFlag := False; Break;
              end;
            if not TmpFlag then Break;
          end;
        end;
        if TmpFlag then begin
          { Try single-line collapse for elseif chain guard clause.
            Only if BRANCH and RETURN are on the same source line. }
          GuardSameLine := False;
          if (ElseIfBranch <> nil) and (ElseIfBranch^.PC >= 0) and
             (ElseIfBranch^.PC < Length(FProto^.LineInfo)) then begin
            RetPC := -1;
            for I := ActualTrueBlk to ActualFalseBlk - 1 do begin
              if (I < 0) or (I >= Length(FSF^.Blocks)) then Continue;
              for ElseIfTrue := 0 to High(FSF^.Blocks[I].Nodes) do
                if FSF^.Blocks[I].Nodes[ElseIfTrue]^.Kind in
                   [SSA_RETURN, SSA_TAILCALL] then begin
                  RetPC := FSF^.Blocks[I].Nodes[ElseIfTrue]^.PC;
                  Break;
                end;
              if RetPC >= 0 then Break;
            end;
            if (RetPC >= 0) and (RetPC < Length(FProto^.LineInfo)) and
               (FProto^.LineInfo[ElseIfBranch^.PC] = FProto^.LineInfo[RetPC]) then
              GuardSameLine := True;
          end;
          GuardIdx := FOutput.Count;
          if GuardSameLine and (GuardIdx >= 2) then begin
            GuardLine := Trim(FOutput.GetLine(GuardIdx - 1));
            GuardIfLine := Trim(FOutput.GetLine(GuardIdx - 2));
            if (Length(GuardLine) >= 6) and (Copy(GuardLine, 1, 6) = 'return') and
               (Length(GuardIfLine) >= 4) and
               (Copy(GuardIfLine, Length(GuardIfLine) - 3, 4) = 'then') and
               (FIndent * 2 + Length(GuardIfLine) + 1 + Length(GuardLine) + 4 < 80) then begin
              FOutput.DeleteLast;
              FOutput.SetLine(GuardIdx - 2,
                StringOfChar(' ', FIndent * 2) + GuardIfLine + ' ' + GuardLine + ' end');
            end else
              EmitLine('end');
          end else
            EmitLine('end');
          EmitMaybeClonedRegion(ActualFalseBlk, MergeBlk, FalseBodyClone);
          GuardClauseFlattened := True;
        end else begin
          ElseLineIdx := FOutput.Count;
          EmitLine('else');
          Indent;
          FalseBodyStartCount := FOutput.Count;
          EmitMaybeClonedRegion(ActualFalseBlk, MergeBlk, FalseBodyClone);
          Dedent;
          if FOutput.Count = FalseBodyStartCount then begin
            if FOutput.Count = ElseLineIdx + 1 then
              FOutput.DeleteLast;
            HasFalseBody := False;
          end;
        end;
      end;
      if (not LastElseIfHadBody) and (not HasFalseBody) and
         (LastElseIfLineIdx >= 0) and
         (FOutput.Count = LastElseIfLineIdx + 1) then
        FOutput.DeleteLast;
    end else begin
      ElseLineIdx := FOutput.Count;
      EmitLine('else');
      Indent;
      FalseBodyStartCount := FOutput.Count;
      EmitMaybeClonedRegion(ActualFalseBlk, MergeBlk, FalseBodyClone);
      Dedent;
      if FOutput.Count = FalseBodyStartCount then begin
        if FOutput.Count = ElseLineIdx + 1 then
          FOutput.DeleteLast;
        HasFalseBody := False;
      end;
    end;
  end else if HasFalseBody then begin
    { Detect guard clause pattern: true body ends with RETURN/TAILCALL
      and there's no dead JMP block between true/false bodies.  The Lua
      compiler always generates a dead JMP at the end of the true block
      when there's an explicit 'else' keyword, even if the true body ends
      with RETURN/TAILCALL.  If no such dead JMP exists, the original
      source used the guard clause pattern: if cond then return X end; ... }
    TmpFlag := False; { True = guard clause detected }
    if TrueBodyEndsWithReturn(ActualTrueBlk, ActualFalseBlk) then begin
      TmpFlag := True; { assume guard clause until we find dead JMP }
      for I := ActualTrueBlk + 1 to ActualFalseBlk - 1 do begin
        if (I < 0) or (I >= Length(FSF^.Blocks)) then Continue;
        if Length(FSF^.Blocks[I].Preds) > 0 then Continue; { not dead }
        for ElseIfTrue := 0 to High(FSF^.Blocks[I].Nodes) do
          if FSF^.Blocks[I].Nodes[ElseIfTrue]^.Kind = SSA_JUMP then begin
            TmpFlag := False; Break; { dead JMP found => else pattern }
          end;
        if not TmpFlag then Break;
      end;
    end;
    if TmpFlag then begin
      { Guard clause: close the if block and emit false body as continuation.
        Try single-line collapse: "if cond then return value end"
        Only collapse if BRANCH and RETURN are on the same source line (LineInfo). }
      GuardSameLine := False;
      if (BranchNode <> nil) and (BranchNode^.PC >= 0) and
         (BranchNode^.PC < Length(FProto^.LineInfo)) then begin
        RetPC := -1;
        for ElseIfTrue := ActualTrueBlk to ActualFalseBlk - 1 do begin
          if (ElseIfTrue < 0) or (ElseIfTrue >= Length(FSF^.Blocks)) then Continue;
          for ElseIfFalse := 0 to High(FSF^.Blocks[ElseIfTrue].Nodes) do
            if FSF^.Blocks[ElseIfTrue].Nodes[ElseIfFalse]^.Kind in
               [SSA_RETURN, SSA_TAILCALL] then begin
              RetPC := FSF^.Blocks[ElseIfTrue].Nodes[ElseIfFalse]^.PC;
              Break;
            end;
          if RetPC >= 0 then Break;
        end;
        if (RetPC >= 0) and (RetPC < Length(FProto^.LineInfo)) and
           (FProto^.LineInfo[BranchNode^.PC] = FProto^.LineInfo[RetPC]) then
          GuardSameLine := True;
      end;
      GuardIdx := FOutput.Count;
      if GuardSameLine and (GuardIdx >= 2) then begin
        GuardLine := Trim(FOutput.GetLine(GuardIdx - 1));
        GuardIfLine := Trim(FOutput.GetLine(GuardIdx - 2));
        if (Length(GuardLine) >= 6) and (Copy(GuardLine, 1, 6) = 'return') and
           (Length(GuardIfLine) >= 4) and
           (Copy(GuardIfLine, Length(GuardIfLine) - 3, 4) = 'then') and
           (FIndent * 2 + Length(GuardIfLine) + 1 + Length(GuardLine) + 4 < 80) then begin
          { Collapse: replace "if ... then\n  return ...\n" with single line }
          FOutput.DeleteLast;  { remove "  return ..." }
          FOutput.SetLine(GuardIdx - 2,
            StringOfChar(' ', FIndent * 2) + GuardIfLine + ' ' + GuardLine + ' end');
        end else
          EmitLine('end');
      end else
        EmitLine('end');
      EmitMaybeClonedRegion(ActualFalseBlk, MergeBlk, FalseBodyClone);
      GuardClauseFlattened := True;
    end else begin
      ElseLineIdx := FOutput.Count;
      EmitLine('else');
      Indent;
      FalseBodyStartCount := FOutput.Count;
      EmitMaybeClonedRegion(ActualFalseBlk, MergeBlk, FalseBodyClone);
      Dedent;
      if FOutput.Count = FalseBodyStartCount then begin
        if FOutput.Count = ElseLineIdx + 1 then
          FOutput.DeleteLast;
        HasFalseBody := False;
      end;
    end;
  end else if (not HasFalseBody) and HasTrueBody and
              (MergeBlk >= 0) and (MergeBlk < Length(FSF^.Blocks)) and
              (not FEmitted[MergeBlk]) and
              IsElseIfBlock(MergeBlk, -1) and
              TrueBodyEndsWithReturn(ActualTrueBlk, MergeBlk) then begin
    { Elseif-via-return pattern: "if cond then return X elseif cond2 then ..."
      The true body ends with RETURN, and MergeBlk is a branch block that
      should be an elseif continuation.
      BUT: distinguish from guard clause pattern (separate if blocks):
      "if cond then return X end; if cond2 then ...".
      The Lua compiler generates a dead JMP after RETURN when there's an
      explicit elseif keyword.  If no dead JMP exists between the true body
      and MergeBlk, this is two separate guard clauses - emit end+continuation. }
    TmpFlag := False; { True = dead JMP found --> genuine elseif }
    for I := ActualTrueBlk + 1 to MergeBlk - 1 do begin
      if (I < 0) or (I >= Length(FSF^.Blocks)) then Continue;
      if Length(FSF^.Blocks[I].Preds) > 0 then Continue; { not dead }
      for ElseIfTrue := 0 to High(FSF^.Blocks[I].Nodes) do
        if FSF^.Blocks[I].Nodes[ElseIfTrue]^.Kind = SSA_JUMP then begin
          TmpFlag := True; Break;
        end;
      if TmpFlag then Break;
    end;
    if not TmpFlag then begin
      { Guard clause: emit end + continuation instead of elseif chain.
        Try single-line collapse if BRANCH and RETURN are on same source line. }
      GuardSameLine := False;
      if (BranchNode <> nil) and (BranchNode^.PC >= 0) and
         (BranchNode^.PC < Length(FProto^.LineInfo)) then begin
        RetPC := -1;
        for I := ActualTrueBlk to MergeBlk - 1 do begin
          if (I < 0) or (I >= Length(FSF^.Blocks)) then Continue;
          for ElseIfTrue := 0 to High(FSF^.Blocks[I].Nodes) do
            if FSF^.Blocks[I].Nodes[ElseIfTrue]^.Kind in
               [SSA_RETURN, SSA_TAILCALL] then begin
              RetPC := FSF^.Blocks[I].Nodes[ElseIfTrue]^.PC;
              Break;
            end;
          if RetPC >= 0 then Break;
        end;
        if (RetPC >= 0) and (RetPC < Length(FProto^.LineInfo)) and
           (FProto^.LineInfo[BranchNode^.PC] = FProto^.LineInfo[RetPC]) then
          GuardSameLine := True;
      end;
      GuardIdx := FOutput.Count;
      if GuardSameLine and (GuardIdx >= 2) then begin
        GuardLine := Trim(FOutput.GetLine(GuardIdx - 1));
        GuardIfLine := Trim(FOutput.GetLine(GuardIdx - 2));
        if (Length(GuardLine) >= 6) and (Copy(GuardLine, 1, 6) = 'return') and
           (Length(GuardIfLine) >= 4) and
           (Copy(GuardIfLine, Length(GuardIfLine) - 3, 4) = 'then') and
           (FIndent * 2 + Length(GuardIfLine) + 1 + Length(GuardLine) + 4 < 80) then begin
          FOutput.DeleteLast;
          FOutput.SetLine(GuardIdx - 2,
            StringOfChar(' ', FIndent * 2) + GuardIfLine + ' ' + GuardLine + ' end');
        end else
          EmitLine('end');
      end else
        EmitLine('end');
      GuardClauseFlattened := True;
    end else begin
    ElseIfBranch := nil;
    for I := 0 to High(FSF^.Blocks[MergeBlk].Nodes) do
      if FSF^.Blocks[MergeBlk].Nodes[I]^.Kind = SSA_BRANCH then begin
        ElseIfBranch := FSF^.Blocks[MergeBlk].Nodes[I]; Break;
      end;
    if ElseIfBranch <> nil then begin
      FEmitted[MergeBlk] := True;
      CondExpr := BuildCondExpr(ElseIfBranch);
      if Length(FSF^.Blocks[MergeBlk].Succs) >= 2 then begin
        ElseIfTrue := FSF^.Blocks[MergeBlk].Succs[1];
        ElseIfFalse := FSF^.Blocks[MergeBlk].Succs[0];
      end else begin
        ElseIfTrue := -1; ElseIfFalse := -1;
      end;
      { Emit non-branch nodes from elseif block }
      for I := 0 to High(FSF^.Blocks[MergeBlk].Nodes) do begin
        N := FSF^.Blocks[MergeBlk].Nodes[I];
        if not (N^.Kind in [SSA_BRANCH, SSA_PHI, SSA_NOP, SSA_JUMP,
                            SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                            SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                            SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then
          EmitNode(N, MergeBlk);
      end;
      ActualTrueBlk := FollowJmpOnly(ElseIfTrue, -1);
      ActualFalseBlk := FollowJmpOnly(ElseIfFalse, -1);
      { Determine next merge for this elseif }
      NextMerge := FindMerge(MergeBlk, ElseIfTrue, ElseIfFalse);

      HasTrueBody := (ActualTrueBlk >= 0) and (ActualTrueBlk <> NextMerge) and
                     (ActualTrueBlk < Length(FSF^.Blocks)) and
                     (not FEmitted[ActualTrueBlk]);
      HasFalseBody := (ActualFalseBlk >= 0) and (ActualFalseBlk <> NextMerge) and
                      (ActualFalseBlk < Length(FSF^.Blocks)) and
                      (not FEmitted[ActualFalseBlk]);
      FalseBodyClone := False;

      { Guard-style elseif: the condition's true edge is just the
        continuation and the false edge is an early return.  Emitting this as
        "elseif cond then" creates an empty body that later gets deleted,
        losing the guard entirely.  Close the previous returning if and emit
        an inverted guard instead:
          if first_cond then return ... end
          if not elseif_cond then return ... end }
      if (ActualTrueBlk = NextMerge) then begin
        ExitBlk := ResolveEarlyExit(ActualFalseBlk);
        if ExitBlk >= 0 then begin
          EmitLine('end');
          NegCond := NegateCondExpr(CondExpr);
          if (ElseIfBranch <> nil) then FAnnotatePC := ElseIfBranch^.PC;
          EmitLine('if ' + NegCond + ' then');
          FAnnotatePC := -1;
          Indent;
          EmitReturnOnly(ExitBlk);
          PredCount := 0;
          for PredI := 0 to High(FSF^.Blocks) do
            for PredJ := 0 to High(FSF^.Blocks[PredI].Succs) do
              if FSF^.Blocks[PredI].Succs[PredJ] = ExitBlk then begin
                Inc(PredCount);
                Break;
              end;
          if PredCount <= 1 then
            FEmitted[ExitBlk] := True;
          Dedent;
          EmitLine('end');
          GuardClauseFlattened := True;
          Exit;
        end;
      end;

      LastElseIfLineIdx := FOutput.Count;
      EmitLine('elseif ' + CondExpr + ' then');
      Indent;
      TrueBodyStartCount := FOutput.Count;
      if HasTrueBody then begin
        EmitRegion(ActualTrueBlk, NextMerge);
        if FOutput.Count = TrueBodyStartCount then
          HasTrueBody := False;
      end;
      Dedent;
      LastElseIfHadBody := HasTrueBody;
      RefreshFalseBodyAfterNestedEmission(ActualFalseBlk, NextMerge,
                                          HasFalseBody, FalseBodyClone);

      { Continue elseif chain }
      while (not HasFalseBody) and HasTrueBody and
            (NextMerge >= 0) and (NextMerge < Length(FSF^.Blocks)) and
            (not FEmitted[NextMerge]) and
            IsElseIfBlock(NextMerge, -1) and
            TrueBodyEndsWithReturn(ActualTrueBlk, NextMerge) do begin
        ElseIfBranch := nil;
        for I := 0 to High(FSF^.Blocks[NextMerge].Nodes) do
          if FSF^.Blocks[NextMerge].Nodes[I]^.Kind = SSA_BRANCH then begin
            ElseIfBranch := FSF^.Blocks[NextMerge].Nodes[I]; Break;
          end;
        if ElseIfBranch = nil then Break;
        FEmitted[NextMerge] := True;
        CondExpr := BuildCondExpr(ElseIfBranch);
        if Length(FSF^.Blocks[NextMerge].Succs) >= 2 then begin
          ElseIfTrue := FSF^.Blocks[NextMerge].Succs[1];
          ElseIfFalse := FSF^.Blocks[NextMerge].Succs[0];
        end else Break;
        for I := 0 to High(FSF^.Blocks[NextMerge].Nodes) do begin
          N := FSF^.Blocks[NextMerge].Nodes[I];
          if not (N^.Kind in [SSA_BRANCH, SSA_PHI, SSA_NOP, SSA_JUMP,
                              SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL]) then
            EmitNode(N, NextMerge);
        end;
        ActualTrueBlk := FollowJmpOnly(ElseIfTrue, -1);
        ActualFalseBlk := FollowJmpOnly(ElseIfFalse, -1);
        MergeBlk := NextMerge;
        NextMerge := FindMerge(NextMerge, ElseIfTrue, ElseIfFalse);
        HasTrueBody := (ActualTrueBlk >= 0) and (ActualTrueBlk <> NextMerge) and
                       (ActualTrueBlk < Length(FSF^.Blocks)) and
                       (not FEmitted[ActualTrueBlk]);
        HasFalseBody := (ActualFalseBlk >= 0) and (ActualFalseBlk <> NextMerge) and
                        (ActualFalseBlk < Length(FSF^.Blocks)) and
                        (not FEmitted[ActualFalseBlk]);
        FalseBodyClone := False;
        LastElseIfLineIdx := FOutput.Count;
        EmitLine('elseif ' + CondExpr + ' then');
        Indent;
        TrueBodyStartCount := FOutput.Count;
        if HasTrueBody then begin
          EmitRegion(ActualTrueBlk, NextMerge);
          if FOutput.Count = TrueBodyStartCount then
            HasTrueBody := False;
        end;
        Dedent;
        LastElseIfHadBody := HasTrueBody;
        RefreshFalseBodyAfterNestedEmission(ActualFalseBlk, NextMerge,
                                            HasFalseBody, FalseBodyClone);
      end;
      { Final else if there's still a false body }
      if HasFalseBody then begin
        { Guard clause detection for elseif-via-return chain final else }
        TmpFlag := False;
        if TrueBodyEndsWithReturn(ActualTrueBlk, NextMerge) then begin
          TmpFlag := True;
          for I := ActualTrueBlk + 1 to ActualFalseBlk - 1 do begin
            if (I < 0) or (I >= Length(FSF^.Blocks)) then Continue;
            if Length(FSF^.Blocks[I].Preds) > 0 then Continue;
            for ElseIfTrue := 0 to High(FSF^.Blocks[I].Nodes) do
              if FSF^.Blocks[I].Nodes[ElseIfTrue]^.Kind = SSA_JUMP then begin
                TmpFlag := False; Break;
              end;
            if not TmpFlag then Break;
          end;
        end;
        if TmpFlag then begin
          EmitLine('end');
          EmitMaybeClonedRegion(ActualFalseBlk, NextMerge, FalseBodyClone);
          GuardClauseFlattened := True;
        end else begin
          ElseLineIdx := FOutput.Count;
          EmitLine('else');
          Indent;
          FalseBodyStartCount := FOutput.Count;
          EmitMaybeClonedRegion(ActualFalseBlk, NextMerge, FalseBodyClone);
          Dedent;
          if FOutput.Count = FalseBodyStartCount then begin
            if FOutput.Count = ElseLineIdx + 1 then
              FOutput.DeleteLast;
            HasFalseBody := False;
          end;
        end;
      end else if HasTrueBody and
                  (NextMerge >= 0) and (NextMerge < Length(FSF^.Blocks)) and
                  (not FEmitted[NextMerge]) and
                  (not IsElseIfBlock(NextMerge, -1)) and
                  TrueBodyEndsWithReturn(ActualTrueBlk, NextMerge) then begin
        { The last elseif body ends with return, and there's a non-branch
          block at NextMerge - this is the final "else" clause. }
        ElseLineIdx := FOutput.Count;
        EmitLine('else');
        Indent;
        FalseBodyStartCount := FOutput.Count;
        EmitRegion(NextMerge, -1);
        Dedent;
        if FOutput.Count = FalseBodyStartCount then
          if FOutput.Count = ElseLineIdx + 1 then
            FOutput.DeleteLast;
      end;
      if (not LastElseIfHadBody) and (not HasFalseBody) and
         (LastElseIfLineIdx >= 0) and
         (FOutput.Count = LastElseIfLineIdx + 1) then
        FOutput.DeleteLast;
    end;
    end; { close else begin for dead JMP check }
  end;

  if not GuardClauseFlattened then begin
    EmitLine('end');
    { Try to collapse single-line if blocks: "if cond then body end"
      or "if cond then body1 else body2 end"
      EndPC = last instruction before merge block }
    if (BranchNode <> nil) and (BranchNode^.PC >= 0) then begin
      IfEndPC := -1;
      if (MergeBlk >= 0) and (MergeBlk < Length(FSF^.Blocks)) then
        IfEndPC := FSF^.Blocks[MergeBlk].StartPC - 1
      else if (ActualFalseBlk >= 0) and (ActualFalseBlk < Length(FSF^.Blocks)) then
        IfEndPC := FSF^.Blocks[ActualFalseBlk].StartPC - 1;
      if not TryCollapseSingleLineBlock(IfOpenIdx, BranchNode^.PC, IfEndPC) then
        TryCollapseIfElseBlock(IfOpenIdx, BranchNode^.PC, IfEndPC);
    end;
  end;
end;

{ ======================================================================
  EmitWhileRegion
  ====================================================================== }

procedure TDecompiler.EmitWhileRegion(HeaderBlk: Integer);
var
  ExitBlk  : Integer;
  BodyBlk  : Integer;
  BranchNode, N: PSSANode;
  I, J, P  : Integer;
  MaxBackEdge: Integer;
  CondExpr, BreakCond : AnsiString;
  S0, S1   : Integer;
  S0JmpOnly, S1JmpOnly: Boolean;
  S0Target, S1Target: Integer;
  IsJmpOnly: Boolean;
  UseRepeatUntil: Boolean;
  WhileOpenIdx: Integer;

  function TryEmitHeaderTailUpdate(Node: PSSANode; NodePos: Integer): Boolean;
  var
    K, Idx: Integer;
    LHS, RHS: AnsiString;
  begin
    Result := False;
    if (Node = nil) or
       not (Node^.Kind in [SSA_BINOP, SSA_UNOP, SSA_CONCAT]) or
       (Node^.Dest.Reg < 0) or
       not ((Node^.OpA.Reg = Node^.Dest.Reg) or
            (Node^.OpB.Reg = Node^.Dest.Reg)) then
      Exit;

    for K := NodePos + 1 to High(FSF^.Blocks[HeaderBlk].Nodes) do
      if (FSF^.Blocks[HeaderBlk].Nodes[K]^.Kind = SSA_BRANCH) and
         (((FSF^.Blocks[HeaderBlk].Nodes[K]^.OpA.Reg = Node^.Dest.Reg) and
           (FSF^.Blocks[HeaderBlk].Nodes[K]^.OpA.Version = Node^.Dest.Version)) or
          ((FSF^.Blocks[HeaderBlk].Nodes[K]^.OpB.Reg = Node^.Dest.Reg) and
           (FSF^.Blocks[HeaderBlk].Nodes[K]^.OpB.Version = Node^.Dest.Version))) then begin
        Result := True;
        Break;
      end;

    if not Result then Exit;

    if IsUserLocal(Node^.Dest.Reg, Node^.PC) or
       IsUserLocal(Node^.Dest.Reg, Node^.PC + 1) or
       ShouldEmitAsLocal(Node^.Dest.Reg, Node^.PC) then
      LHS := LocalNameForEmit(Node^.Dest.Reg, Node^.PC)
    else
      LHS := TempName(Node^.Dest.Reg);

    Idx := NodeIdx(Node^.Dest.Reg, Node^.Dest.Version);
    if (Idx >= 0) and (Idx < Length(FExprStr)) then
      FExprStr[Idx] := LHS;

    RHS := NodeExpr(Node);
    if NeedsLocalDecl(Node^.Dest.Reg, Node^.PC) then
      EmitLine('local ' + LHS + ' = ' + RHS)
    else
      EmitLine(LHS + ' = ' + RHS);
  end;

  function BuildHeaderBreakCondition: AnsiString;
  begin
    Result := '';
    if BranchNode = nil then Exit;

    case BranchNode^.RelOp of
      ropEQ, ropLT, ropLE: begin
        if IsJmpOnly then
          Result := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                  BranchNode^.RelOp, not BranchNode^.Invert,
                                  BranchNode^.PC)
        else
          Result := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                  BranchNode^.RelOp, BranchNode^.Invert,
                                  BranchNode^.PC);
      end;
      ropTest, ropTestSet: begin
        if IsJmpOnly then begin
          if BranchNode^.Invert then
            Result := ExprOf(BranchNode^.OpA, BranchNode^.PC)
          else
            Result := 'not ' + ExprOf(BranchNode^.OpA, BranchNode^.PC);
        end else begin
          if BranchNode^.Invert then
            Result := 'not ' + ExprOf(BranchNode^.OpA, BranchNode^.PC)
          else
            Result := ExprOf(BranchNode^.OpA, BranchNode^.PC);
        end;
      end;
    end;
  end;
begin
  if FOpts.Debug then
    WriteLn(StdErr, 'EmitWhileRegion: HeaderBlk=BB', HeaderBlk);

  { Determine exit block by checking which successor leads outside the loop.
    For a while header with two successors:
    - One leads to the loop body (stays in the loop)
    - One leads to the exit (leaves the loop)
    Compute MaxBackEdge to know the loop boundary. }
  MaxBackEdge := -1;
  for I := 0 to High(FSF^.Blocks[HeaderBlk].Preds) do begin
    P := FSF^.Blocks[HeaderBlk].Preds[I];
    if (P >= HeaderBlk) and not FEmitted[P] then
      if P > MaxBackEdge then MaxBackEdge := P;
  end;

  ExitBlk := -1;
  if Length(FSF^.Blocks[HeaderBlk].Succs) >= 2 then begin
    S0 := FSF^.Blocks[HeaderBlk].Succs[0];
    S1 := FSF^.Blocks[HeaderBlk].Succs[1];

    { Check which successors are JMP-only trampolines and find their targets }
    S0JmpOnly := False;
    S0Target := S0;
    if (S0 >= 0) and (S0 < Length(FSF^.Blocks)) then begin
      S0JmpOnly := True;
      for I := 0 to High(FSF^.Blocks[S0].Nodes) do
        if not (FSF^.Blocks[S0].Nodes[I]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
          S0JmpOnly := False; Break;
        end;
      if S0JmpOnly and (Length(FSF^.Blocks[S0].Succs) = 1) and
         (FSF^.Blocks[S0].Succs[0] <> HeaderBlk) then
        S0Target := FSF^.Blocks[S0].Succs[0]
      else
        S0JmpOnly := False;
    end;

    S1JmpOnly := False;
    S1Target := S1;
    if (S1 >= 0) and (S1 < Length(FSF^.Blocks)) then begin
      S1JmpOnly := True;
      for I := 0 to High(FSF^.Blocks[S1].Nodes) do
        if not (FSF^.Blocks[S1].Nodes[I]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
          S1JmpOnly := False; Break;
        end;
      if S1JmpOnly and (Length(FSF^.Blocks[S1].Succs) = 1) and
         (FSF^.Blocks[S1].Succs[0] <> HeaderBlk) then
        S1Target := FSF^.Blocks[S1].Succs[0]
      else
        S1JmpOnly := False;
    end;

    { When both are JMP-only, the exit trampoline is the one whose target
      is OUTSIDE the loop (beyond MaxBackEdge); the other leads to the body.
      When both exit (same target or both outside), prefer S0 to preserve
      the original condition polarity. }
    if S0JmpOnly and S1JmpOnly then begin
      if (S1Target > MaxBackEdge) and (S0Target <= MaxBackEdge) then begin
        { Only S1 exits --> S1 is the exit trampoline }
        ExitBlk := S1Target;
        FEmitted[S1] := True;
      end else begin
        { S0 exits, or both exit --> prefer S0 }
        ExitBlk := S0Target;
        FEmitted[S0] := True;
      end;
    end else if S0JmpOnly then begin
      ExitBlk := S0Target;
      FEmitted[S0] := True;
    end else if S1JmpOnly then begin
      ExitBlk := S1Target;
      FEmitted[S1] := True;
    end;
  end;

  if ExitBlk = -1 then
    ExitBlk := FindLoopExit(HeaderBlk);

  if FOpts.Debug then
    WriteLn(StdErr, 'EmitWhileRegion: HeaderBlk=BB', HeaderBlk,
            ' ExitBlk=BB', ExitBlk);

  BranchNode := nil;
  for I := 0 to High(FSF^.Blocks[HeaderBlk].Nodes) do
    if FSF^.Blocks[HeaderBlk].Nodes[I]^.Kind = SSA_BRANCH then begin
      BranchNode := FSF^.Blocks[HeaderBlk].Nodes[I]; Break;
    end;

  if BranchNode <> nil then begin
    { For while loops, the condition is the "continue looping" condition.
      The loop exit is the successor with the highest index.
      Succs[0] = JMP block (= body), Succs[1] = skip target (= exit or body).
      For the while condition, we need the condition to be true when we STAY in the loop.
      The "stay in loop" path is NOT the exit path.
      Since the while body is reached via the non-exit path, and the exit
      is the higher-numbered successor, the condition should be:
      For EQ/LT/LE: condition causes skip --> skip goes to exit --> condition TRUE = exit
        So we need the INVERSE of the comparison for "stay in loop".
      For TEST: similar logic applies.
      Actually, the while condition semantics depend on which successor is the exit.
      ExitBlk = highest successor > HeaderIdx. The other successor is the body/continue. }
    case BranchNode^.RelOp of
      ropEQ, ropLT, ropLE: begin
        { For while loops:
          Succs[0] = JMP block (fall-through to JMP instruction)
          Succs[1] = skip target (where comparison-true lands)
          If Succs[0] leads to exit --> comparison-true = stay --> while(comparison)
          If Succs[1] leads to exit --> comparison-true = exit --> while(NOT comparison)
          Succs[0] "leads to exit" if it's a JMP-only that was resolved to ExitBlk,
          or if Succs[0] == ExitBlk directly. }
        S0 := -1;
        if Length(FSF^.Blocks[HeaderBlk].Succs) >= 2 then
          S0 := FSF^.Blocks[HeaderBlk].Succs[0];
        if (S0 >= 0) and ((S0 = ExitBlk) or FEmitted[S0]) then
          { Succs[0] = exit --> comparison-true (skip) = stay --> while(comparison) }
          CondExpr := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                    BranchNode^.RelOp, BranchNode^.Invert,
                                    BranchNode^.PC)
        else
          { Succs[1] = exit --> comparison-true (skip) = exit --> while(NOT comparison) }
          CondExpr := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                    BranchNode^.RelOp, not BranchNode^.Invert,
                                    BranchNode^.PC);
      end;
      ropTest, ropTestSet: begin
        S0 := -1;
        if Length(FSF^.Blocks[HeaderBlk].Succs) >= 2 then
          S0 := FSF^.Blocks[HeaderBlk].Succs[0];
        if (S0 >= 0) and ((S0 = ExitBlk) or FEmitted[S0]) then begin
          { Succs[0] = exit --> skip = stay }
          if BranchNode^.Invert then
            CondExpr := 'not ' + ExprOf(BranchNode^.OpA, BranchNode^.PC)
          else
            CondExpr := ExprOf(BranchNode^.OpA, BranchNode^.PC);
        end else begin
          { Succs[1] = exit --> skip = exit }
          if BranchNode^.Invert then
            CondExpr := ExprOf(BranchNode^.OpA, BranchNode^.PC)
          else
            CondExpr := 'not ' + ExprOf(BranchNode^.OpA, BranchNode^.PC);
        end;
      end;
    else
      CondExpr := 'true';
    end;
  end else
    CondExpr := 'true';

  { Determine if the header block has body statements before the branch.
    If it does, we have a "while true do ... if cond then break end ... end"
    pattern rather than a "while cond do body end" pattern.
    Pure expression nodes (GETGLOBAL, GETTABLE, LOADK, BINOP, UNOP, etc.)
    that only feed the branch condition are NOT body statements - they're just
    part of the condition computation. Only side-effecting operations (CALL,
    SETTABLE, SETGLOBAL, SETUPVAL) or assignments to user-locals indicate
    a body-in-header pattern. }
  BodyBlk := -1;
  if BranchNode <> nil then begin
    for I := 0 to High(FSF^.Blocks[HeaderBlk].Nodes) do begin
      N := FSF^.Blocks[HeaderBlk].Nodes[I];
      if N^.Kind in [SSA_PHI, SSA_NOP, SSA_JUMP] then Continue;
      if N^.Kind = SSA_BRANCH then Break;
      { Side-effecting operations are body statements }
      if N^.Kind in [SSA_CALL, SSA_SETTABLE, SSA_SETGLOBAL, SSA_SETUPVAL,
                     SSA_SETLIST, SSA_RETURN] then begin
        BodyBlk := HeaderBlk;
        Break;
      end;
      { Assignments to user-locals are body statements (e.g. "local x = expr" in the loop).
        Use strict IsUserLocal only - NOT ShouldEmitAsLocal, because the 16-PC
        look-ahead incorrectly flags condition-computing expressions as body
        statements when a loop body local happens to share the same register. }
      if IsUserLocal(N^.Dest.Reg, N^.PC) or IsUserLocal(N^.Dest.Reg, N^.PC + 1) then begin
        BodyBlk := HeaderBlk;
        Break;
      end;
      { Otherwise, it's a pure expression feeding the condition - not a body statement }
    end;
  end;

  if BodyBlk = HeaderBlk then begin
    { Body-in-header pattern: the header block has body statements BEFORE
      the terminating branch.  This is a "repeat ... until cond" pattern
      when the branch at the end of the header directly controls the loop
      exit (one successor is a JMP-only back-edge or already emitted,
      the other is the exit).  Otherwise fall back to
      "while true do ... if cond then break end end". }
    S0 := -1;
    if Length(FSF^.Blocks[HeaderBlk].Succs) >= 2 then
      S0 := FSF^.Blocks[HeaderBlk].Succs[0];
    { IsJmpOnly: true if Succs[0] was identified as an exit trampoline }
    IsJmpOnly := (S0 >= 0) and ((S0 = ExitBlk) or FEmitted[S0]);

    { Determine if we can use repeat...until syntax.
      Condition: no continuation body blocks with real code between header+1
      and MaxBackEdge (loop boundary).  I.e., the header is the only block
      with body statements, and the remaining blocks are JMP-only trampolines.
      Don't scan beyond MaxBackEdge - blocks between MaxBackEdge+1 and ExitBlk
      may be sibling branches (e.g. else bodies) outside this loop. }
    UseRepeatUntil := True;
    if (MaxBackEdge >= HeaderBlk) then
      S1 := MaxBackEdge + 1
    else
      S1 := ExitBlk;
    if (HeaderBlk + 1 < Length(FSF^.Blocks)) and (S1 > HeaderBlk + 1) then begin
      for I := HeaderBlk + 1 to S1 - 1 do begin
        if FEmitted[I] then Continue;
        { Check if this block has any real (non-structural) nodes }
        for J := 0 to High(FSF^.Blocks[I].Nodes) do begin
          if not (FSF^.Blocks[I].Nodes[J]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP, SSA_CLOSE]) then begin
            UseRepeatUntil := False;
            Break;
          end;
        end;
        if not UseRepeatUntil then Break;
      end;
    end;

    { Build break/until condition }
    BreakCond := BuildHeaderBreakCondition;

    if UseRepeatUntil and (BreakCond <> '') then begin
      { Emit as repeat...until - no closing 'end' needed }
      WhileOpenIdx := FOutput.Count;
      EmitLine('repeat');
      Indent;
      PushLoopExit(ExitBlk);

      FEmitted[HeaderBlk] := True;
      { Emit the non-branch, non-structural nodes from the header block }
      I := 0;
      while I <= High(FSF^.Blocks[HeaderBlk].Nodes) do begin
        N := FSF^.Blocks[HeaderBlk].Nodes[I];
        if N^.Kind = SSA_BRANCH then begin Inc(I); Continue; end;
        if TryEmitHeaderTailUpdate(N, I) then begin
          Inc(I);
          Continue;
        end;
        if (N^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                         SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                         SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then
          case TryEmitMultiAssign(HeaderBlk, I, S0) of
            maEmitted: begin Inc(I, S0); Continue; end;
            maNotMatched: ;
          end;
        if (N^.Kind = SSA_CALL) then
          case TryEmitMultiReturnAssign(HeaderBlk, I, S0) of
            maEmitted: begin Inc(I, S0); Continue; end;
            maNotMatched: ;
          end;
        if (N^.Kind = SSA_MOVE) then
          case TryEmitSwap(HeaderBlk, I, S0) of
            maEmitted: begin Inc(I, S0); Continue; end;
            maNotMatched: ;
          end;
        EmitNode(N, HeaderBlk);
        Inc(I);
      end;
      { Mark any JMP-only trampoline blocks in the loop body as emitted.
        Bound at MaxBackEdge+1 to avoid marking sibling branches outside the loop. }
      if (MaxBackEdge >= HeaderBlk) then
        S1 := MaxBackEdge + 1
      else
        S1 := ExitBlk;
      for I := HeaderBlk + 1 to S1 - 1 do
        if not FEmitted[I] then FEmitted[I] := True;

      PopLoopExit;
      Dedent;
      BreakCond := BuildHeaderBreakCondition;
      EmitLine('until ' + BreakCond);
      { Try single-line collapse: "repeat body until cond" }
      if (MaxBackEdge >= 0) and (MaxBackEdge < Length(FSF^.Blocks)) and
         (Length(FSF^.Blocks[MaxBackEdge].Nodes) > 0) then
        TryCollapseSingleLineBlock(WhileOpenIdx,
          FSF^.Blocks[HeaderBlk].StartPC,
          FSF^.Blocks[MaxBackEdge].Nodes[High(FSF^.Blocks[MaxBackEdge].Nodes)]^.PC);
      Exit;  { repeat...until has no 'end' - skip the common Dedent/end below }
    end else begin
      { Fall back to while true do ... if cond then break end end }
      WhileOpenIdx := FOutput.Count;
      EmitLine('while true do');
      Indent;
      PushLoopExit(ExitBlk);

      FEmitted[HeaderBlk] := True;
      { Emit the non-branch, non-structural nodes from the header block }
      I := 0;
      while I <= High(FSF^.Blocks[HeaderBlk].Nodes) do begin
        N := FSF^.Blocks[HeaderBlk].Nodes[I];
        if N^.Kind = SSA_BRANCH then begin Inc(I); Continue; end;
        if TryEmitHeaderTailUpdate(N, I) then begin
          Inc(I);
          Continue;
        end;
        if (N^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                         SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                         SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then
          case TryEmitMultiAssign(HeaderBlk, I, S0) of
            maEmitted: begin Inc(I, S0); Continue; end;
            maNotMatched: ;
          end;
        if (N^.Kind = SSA_CALL) then
          case TryEmitMultiReturnAssign(HeaderBlk, I, S0) of
            maEmitted: begin Inc(I, S0); Continue; end;
            maNotMatched: ;
          end;
        if (N^.Kind = SSA_MOVE) then
          case TryEmitSwap(HeaderBlk, I, S0) of
            maEmitted: begin Inc(I, S0); Continue; end;
            maNotMatched: ;
          end;
        EmitNode(N, HeaderBlk);
        Inc(I);
      end;
      { Emit the break condition from the header's branch BEFORE the
        continuation body, since the branch controls entry to the body. }
      BreakCond := BuildHeaderBreakCondition;
      if BreakCond <> '' then begin
        EmitLine('if ' + BreakCond + ' then break end');
      end;

      { Emit any continuation body blocks (between header+1 and back-edge).
        Limit body to MaxBackEdge+1 to avoid consuming sibling branches. }
      if (MaxBackEdge >= HeaderBlk) and (MaxBackEdge + 1 < ExitBlk) then
        S1 := MaxBackEdge + 1
      else
        S1 := ExitBlk;
      if (HeaderBlk + 1 < Length(FSF^.Blocks)) and (S1 > HeaderBlk + 1) then
        EmitRegion(HeaderBlk + 1, S1);

      PopLoopExit;
    end;
  end else begin
    { Standard while pattern }
    WhileOpenIdx := FOutput.Count;
    if (BranchNode <> nil) then FAnnotatePC := BranchNode^.PC;
    EmitLine('while ' + CondExpr + ' do');
    FAnnotatePC := -1;
    Indent;
    PushLoopExit(ExitBlk);

    FEmitted[HeaderBlk] := True;
    { Emit non-branch nodes from header block (for top-condition while loops
      that also have body statements like variable initializations) }
    I := 0;
    while I <= High(FSF^.Blocks[HeaderBlk].Nodes) do begin
      N := FSF^.Blocks[HeaderBlk].Nodes[I];
      if N^.Kind in [SSA_BRANCH, SSA_PHI, SSA_NOP, SSA_JUMP] then begin Inc(I); Continue; end;
      if (N^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                       SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                       SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then
        case TryEmitMultiAssign(HeaderBlk, I, S0) of
          maEmitted: begin Inc(I, S0); Continue; end;
          maNotMatched: ;
        end;
      if (N^.Kind = SSA_CALL) then
        case TryEmitMultiReturnAssign(HeaderBlk, I, S0) of
          maEmitted: begin Inc(I, S0); Continue; end;
          maNotMatched: ;
        end;
      if (N^.Kind = SSA_MOVE) then
        case TryEmitSwap(HeaderBlk, I, S0) of
          maEmitted: begin Inc(I, S0); Continue; end;
          maNotMatched: ;
        end;
      EmitNode(N, HeaderBlk);
      Inc(I);
    end;
    { Emit body (blocks after header, before exit).
      Limit body to MaxBackEdge+1 to avoid consuming sibling branches
      that happen to be between the header and exit blocks.
      When the exit block is backward (nested loop exiting to outer header),
      compute the body range from back-edge blocks: the body extends from
      HeaderBlk+1 to the maximum back-edge source block + 1. }
    if ExitBlk > HeaderBlk then begin
      { Limit body to loop range - don't consume sibling branches beyond back-edge }
      if (MaxBackEdge >= HeaderBlk) and (MaxBackEdge + 1 < ExitBlk) then
        S1 := MaxBackEdge + 1
      else
        S1 := ExitBlk;
      if (HeaderBlk + 1 < S1) then
        EmitRegion(HeaderBlk + 1, S1);
    end else begin
      { Backward exit: find the max block index that feeds back to HeaderBlk }
      S1 := HeaderBlk;
      for I := HeaderBlk + 1 to High(FSF^.Blocks) do begin
        for J := 0 to High(FSF^.Blocks[I].Succs) do
          if FSF^.Blocks[I].Succs[J] = HeaderBlk then begin
            if I > S1 then S1 := I;
          end;
      end;
      if S1 > HeaderBlk then
        EmitRegion(HeaderBlk + 1, S1 + 1);
    end;

    PopLoopExit;
  end;

  Dedent;
  EmitLine('end');
  { Try single-line collapse: "while cond do body end"
    PC range: from header's first instruction to last instruction in the
    MaxBackEdge block (which is the back-edge JMP). }
  if (MaxBackEdge >= 0) and (MaxBackEdge < Length(FSF^.Blocks)) and
     (Length(FSF^.Blocks[MaxBackEdge].Nodes) > 0) then begin
    I := FSF^.Blocks[HeaderBlk].StartPC;
    J := FSF^.Blocks[MaxBackEdge].Nodes[High(FSF^.Blocks[MaxBackEdge].Nodes)]^.PC;
    TryCollapseSingleLineBlock(WhileOpenIdx, I, J);
  end;
end;

{ ======================================================================
  EmitRepeatRegion
  ====================================================================== }

procedure TDecompiler.EmitRepeatRegion(HeaderBlk: Integer);
var
  ExitBlk: Integer;
  I, P, MaxBackEdge: Integer;
  CondNode, HdrBranchNode, N: PSSANode;
  CondExpr, HdrCondExpr: AnsiString;
  TailBlk: Integer;
  IsJmpOnly: Boolean;
  S0, HdrS0, HdrS1, HdrExitSucc: Integer;
  IsCompoundUntil: Boolean;
  HdrHasBranch, HdrHasBody: Boolean;
  RepeatOpenIdx: Integer;
  Idx: Integer;
  LHS, RHS: AnsiString;
begin
  { For repeat-until, find the exit via the tail block, not the header }
  ExitBlk := FindRepeatUntilExit(HeaderBlk);
  if ExitBlk < 0 then
    ExitBlk := FindLoopExit(HeaderBlk);

  { Find the back-edge JMP block and the tail condition block.
    Prefer reachable back-edges; fall back to unreachable if needed. }
  MaxBackEdge := -1;
  for I := 0 to High(FSF^.Blocks[HeaderBlk].Preds) do begin
    P := FSF^.Blocks[HeaderBlk].Preds[I];
    if (P >= HeaderBlk) and not FEmitted[P] and
       ((P = 0) or (Length(FSF^.Blocks[P].Preds) > 0)) then
      if P > MaxBackEdge then MaxBackEdge := P;
  end;
  if MaxBackEdge < 0 then begin
    for I := 0 to High(FSF^.Blocks[HeaderBlk].Preds) do begin
      P := FSF^.Blocks[HeaderBlk].Preds[I];
      if (P >= HeaderBlk) and not FEmitted[P] then
        if P > MaxBackEdge then MaxBackEdge := P;
    end;
  end;

  { Find the tail block that has the condition branch.
    The MaxBackEdge is typically a JMP-only back-edge block.
    Its predecessor (within the loop) is the tail with the BRANCH. }
  TailBlk := -1;
  if MaxBackEdge >= 0 then begin
    { Check if MaxBackEdge itself has a BRANCH }
    for I := 0 to High(FSF^.Blocks[MaxBackEdge].Nodes) do
      if FSF^.Blocks[MaxBackEdge].Nodes[I]^.Kind = SSA_BRANCH then begin
        TailBlk := MaxBackEdge; Break;
      end;
    if TailBlk < 0 then begin
      { MaxBackEdge is JMP-only; find its predecessor in the loop }
      for I := 0 to High(FSF^.Blocks[MaxBackEdge].Preds) do begin
        P := FSF^.Blocks[MaxBackEdge].Preds[I];
        if (P >= HeaderBlk) and (P < MaxBackEdge) then begin
          TailBlk := P; Break;
        end;
      end;
    end;
  end;

  { ---- Detect compound until condition ----
    When the header has both body statements (CALL, SETTABLE, etc.) AND a
    BRANCH, and one of the branch successors leads to the exit block (directly
    or via a JMP-only trampoline), the header's branch is part of a compound
    until condition (e.g., "until result == true or attempts >= 3"), NOT an
    inner if-then. }
  IsCompoundUntil := False;
  HdrBranchNode := nil;
  HdrExitSucc := -1;
  if (TailBlk >= 0) and (TailBlk <> HeaderBlk) then begin
    HdrHasBranch := False;
    HdrHasBody := False;
    for I := 0 to High(FSF^.Blocks[HeaderBlk].Nodes) do begin
      if FSF^.Blocks[HeaderBlk].Nodes[I]^.Kind = SSA_BRANCH then begin
        HdrHasBranch := True;
        HdrBranchNode := FSF^.Blocks[HeaderBlk].Nodes[I];
      end;
      if FSF^.Blocks[HeaderBlk].Nodes[I]^.Kind in
         [SSA_BINOP, SSA_CALL, SSA_TAILCALL, SSA_SETTABLE, SSA_SETGLOBAL,
          SSA_SETUPVAL, SSA_SETLIST, SSA_GETGLOBAL, SSA_LOADK] then
        HdrHasBody := True;
    end;
    if HdrHasBranch and HdrHasBody and (Length(FSF^.Blocks[HeaderBlk].Succs) >= 2) then begin
      HdrS0 := FSF^.Blocks[HeaderBlk].Succs[0]; { JMP block }
      HdrS1 := FSF^.Blocks[HeaderBlk].Succs[1]; { skip target }
      { Check if either successor leads to the exit block }
      if (HdrS0 = ExitBlk) then
        HdrExitSucc := HdrS0
      else if (HdrS1 = ExitBlk) then
        HdrExitSucc := HdrS1
      else begin
        { Check via JMP-only trampoline }
        if (HdrS0 >= 0) and (HdrS0 < Length(FSF^.Blocks)) and
           (Length(FSF^.Blocks[HdrS0].Succs) = 1) then begin
          IsJmpOnly := True;
          for I := 0 to High(FSF^.Blocks[HdrS0].Nodes) do
            if not (FSF^.Blocks[HdrS0].Nodes[I]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
              IsJmpOnly := False; Break;
            end;
          if IsJmpOnly and (FSF^.Blocks[HdrS0].Succs[0] = ExitBlk) then
            HdrExitSucc := HdrS0;
        end;
        if (HdrExitSucc < 0) and (HdrS1 >= 0) and (HdrS1 < Length(FSF^.Blocks)) and
           (Length(FSF^.Blocks[HdrS1].Succs) = 1) then begin
          IsJmpOnly := True;
          for I := 0 to High(FSF^.Blocks[HdrS1].Nodes) do
            if not (FSF^.Blocks[HdrS1].Nodes[I]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
              IsJmpOnly := False; Break;
            end;
          if IsJmpOnly and (FSF^.Blocks[HdrS1].Succs[0] = ExitBlk) then
            HdrExitSucc := HdrS1;
        end;
      end;
      if HdrExitSucc >= 0 then
        IsCompoundUntil := True;
    end;
  end;

  RepeatOpenIdx := FOutput.Count;
  EmitLine('repeat');
  Indent;
  PushLoopExit(ExitBlk);

  FEmitted[HeaderBlk] := True;
  { Mark back-edge JMP block as emitted so it won't be re-processed }
  if (MaxBackEdge >= 0) and (MaxBackEdge < Length(FSF^.Blocks)) then
    FEmitted[MaxBackEdge] := True;

  if IsCompoundUntil then begin
    { --- Compound until condition: header has body + first condition check ---
      Emit only the body statements from the header, skip the branch.
      Mark the exit-path JMP trampoline as emitted. }
    if (HdrExitSucc >= 0) and (HdrExitSucc <> ExitBlk) then
      FEmitted[HdrExitSucc] := True;
    FEmitted[TailBlk] := True;
    { Mark JMP-only blocks between tail and back-edge as emitted }
    for I := TailBlk + 1 to MaxBackEdge do
      if not FEmitted[I] then begin
        IsJmpOnly := True;
        for P := 0 to High(FSF^.Blocks[I].Nodes) do
          if not (FSF^.Blocks[I].Nodes[P]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
            IsJmpOnly := False; Break;
          end;
        if IsJmpOnly then FEmitted[I] := True;
      end;
    { Emit body statements from header (skip PHI, NOP, BRANCH) }
    for I := 0 to High(FSF^.Blocks[HeaderBlk].Nodes) do begin
      if FSF^.Blocks[HeaderBlk].Nodes[I]^.Kind in
         [SSA_PHI, SSA_NOP, SSA_BRANCH] then Continue;
      EmitNode(FSF^.Blocks[HeaderBlk].Nodes[I], HeaderBlk);
    end;
    { Emit any body statements in blocks between header+1 and tail (if any) }
    for I := HeaderBlk + 1 to TailBlk - 1 do begin
      if FEmitted[I] then Continue;
      FEmitted[I] := True;
      for P := 0 to High(FSF^.Blocks[I].Nodes) do begin
        if FSF^.Blocks[I].Nodes[P]^.Kind in [SSA_PHI, SSA_NOP, SSA_JUMP, SSA_BRANCH] then Continue;
        EmitNode(FSF^.Blocks[I].Nodes[P], I);
      end;
    end;
    { Emit any non-branch body statements from the tail block }
    for I := 0 to High(FSF^.Blocks[TailBlk].Nodes) do begin
      if FSF^.Blocks[TailBlk].Nodes[I]^.Kind in
         [SSA_BRANCH, SSA_PHI, SSA_NOP, SSA_JUMP] then Continue;
      if FSF^.Blocks[TailBlk].Nodes[I]^.Kind in
         [SSA_CALL, SSA_TAILCALL, SSA_SETTABLE, SSA_SETGLOBAL,
          SSA_SETUPVAL, SSA_SETLIST] then
        EmitNode(FSF^.Blocks[TailBlk].Nodes[I], TailBlk);
    end;
  end else begin

  { Emit the header block's nodes (for repeat-until where header has body code) }
  for I := 0 to High(FSF^.Blocks[HeaderBlk].Nodes) do begin
    if FSF^.Blocks[HeaderBlk].Nodes[I]^.Kind in [SSA_PHI, SSA_NOP] then Continue;
    { If the header has a branch, it's an inner if, not the loop condition -
      let EmitRegion handle it by NOT emitting it here. The header block
      will be processed as an if/then/else by EmitRegion. }
    Break;
  end;

  { Emit body. For simple repeat-until (no branch in header), emit from header+1.
    For repeat-until with branch in header, we need to include the header's
    branch as part of the body by un-marking and re-processing. }
  if (TailBlk >= 0) and (TailBlk <> HeaderBlk) then begin
    { Mark the tail block as emitted BEFORE EmitRegion so that the tail's
      BRANCH is NOT emitted as an if-then - it's the until condition. }
    FEmitted[TailBlk] := True;
    { Also mark JMP-only blocks between tail and back-edge as emitted }
    for I := TailBlk + 1 to MaxBackEdge do
      if not FEmitted[I] then begin
        IsJmpOnly := True;
        for P := 0 to High(FSF^.Blocks[I].Nodes) do
          if not (FSF^.Blocks[I].Nodes[P]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
            IsJmpOnly := False; Break;
          end;
        if IsJmpOnly then FEmitted[I] := True;
      end;
    { The header may have body statements (including branches for inner ifs).
      Re-process it as a body block by un-marking and emitting. }
    FEmitted[HeaderBlk] := False;
    EmitRegion(HeaderBlk, ExitBlk);
    { Emit any non-branch body statements from the tail block (e.g. CALL, SETTABLE) }
    for I := 0 to High(FSF^.Blocks[TailBlk].Nodes) do begin
      if FSF^.Blocks[TailBlk].Nodes[I]^.Kind in
         [SSA_BRANCH, SSA_PHI, SSA_NOP, SSA_JUMP] then Continue;
      { Only emit side-effecting statements plus loop-tail self-updates that
        feed both the until condition and the next-iteration PHI. }
      if FSF^.Blocks[TailBlk].Nodes[I]^.Kind in
         [SSA_CALL, SSA_TAILCALL, SSA_SETTABLE, SSA_SETGLOBAL,
          SSA_SETUPVAL, SSA_SETLIST] then
        EmitNode(FSF^.Blocks[TailBlk].Nodes[I], TailBlk)
      else if (FSF^.Blocks[TailBlk].Nodes[I]^.Kind in
               [SSA_BINOP, SSA_UNOP, SSA_CONCAT]) and
              (FSF^.Blocks[TailBlk].Nodes[I]^.Dest.Reg >= 0) and
              (CountPhiUses(FSF^.Blocks[TailBlk].Nodes[I]^.Dest.Reg,
                            FSF^.Blocks[TailBlk].Nodes[I]^.Dest.Version) > 0) and
              ((FSF^.Blocks[TailBlk].Nodes[I]^.OpA.Reg =
                FSF^.Blocks[TailBlk].Nodes[I]^.Dest.Reg) or
               (FSF^.Blocks[TailBlk].Nodes[I]^.OpB.Reg =
                FSF^.Blocks[TailBlk].Nodes[I]^.Dest.Reg)) then
        EmitNode(FSF^.Blocks[TailBlk].Nodes[I], TailBlk);
    end;
  end else begin
    { Simple case: header is itself the tail (body + condition in same block).
      Emit body statements from the header, then remaining blocks. }
    I := 0;
    while I <= High(FSF^.Blocks[HeaderBlk].Nodes) do begin
      N := FSF^.Blocks[HeaderBlk].Nodes[I];
      if N^.Kind = SSA_BRANCH then begin Inc(I); Continue; end;
      if (N^.Kind in [SSA_BINOP, SSA_UNOP, SSA_CONCAT]) and
         (N^.Dest.Reg >= 0) and
         ((N^.OpA.Reg = N^.Dest.Reg) or (N^.OpB.Reg = N^.Dest.Reg)) then begin
        HdrHasBody := False;
        for P := I + 1 to High(FSF^.Blocks[HeaderBlk].Nodes) do
          if (FSF^.Blocks[HeaderBlk].Nodes[P]^.Kind = SSA_BRANCH) and
             (((FSF^.Blocks[HeaderBlk].Nodes[P]^.OpA.Reg = N^.Dest.Reg) and
               (FSF^.Blocks[HeaderBlk].Nodes[P]^.OpA.Version = N^.Dest.Version)) or
              ((FSF^.Blocks[HeaderBlk].Nodes[P]^.OpB.Reg = N^.Dest.Reg) and
               (FSF^.Blocks[HeaderBlk].Nodes[P]^.OpB.Version = N^.Dest.Version))) then begin
            HdrHasBody := True;
            Break;
          end;
        if HdrHasBody then begin
          if IsUserLocal(N^.Dest.Reg, N^.PC) or
             IsUserLocal(N^.Dest.Reg, N^.PC + 1) or
             ShouldEmitAsLocal(N^.Dest.Reg, N^.PC) then
            LHS := LocalNameForEmit(N^.Dest.Reg, N^.PC)
          else
            LHS := TempName(N^.Dest.Reg);
          Idx := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
          if (Idx >= 0) and (Idx < Length(FExprStr)) then
            FExprStr[Idx] := LHS;
          RHS := NodeExpr(N);
          if NeedsLocalDecl(N^.Dest.Reg, N^.PC) then
            EmitLine('local ' + LHS + ' = ' + RHS)
          else
            EmitLine(LHS + ' = ' + RHS);
          Inc(I);
          Continue;
        end;
      end;
      if (N^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                       SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                       SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then
        case TryEmitMultiAssign(HeaderBlk, I, S0) of
          maEmitted: begin Inc(I, S0); Continue; end;
          maNotMatched: ;
        end;
      if (N^.Kind = SSA_CALL) then
        case TryEmitMultiReturnAssign(HeaderBlk, I, S0) of
          maEmitted: begin Inc(I, S0); Continue; end;
          maNotMatched: ;
        end;
      if (N^.Kind = SSA_MOVE) then
        case TryEmitSwap(HeaderBlk, I, S0) of
          maEmitted: begin Inc(I, S0); Continue; end;
          maNotMatched: ;
        end;
      EmitNode(N, HeaderBlk);
      Inc(I);
    end;
    EmitRegion(HeaderBlk + 1, ExitBlk);
  end;

  end; { end of non-compound else branch }

  PopLoopExit;
  Dedent;

  { Find condition from the tail block }
  CondNode := nil;
  if TailBlk >= 0 then begin
    for I := High(FSF^.Blocks[TailBlk].Nodes) downto 0 do
      if FSF^.Blocks[TailBlk].Nodes[I]^.Kind = SSA_BRANCH then begin
        CondNode := FSF^.Blocks[TailBlk].Nodes[I]; Break;
      end;
  end;

  if IsCompoundUntil and (HdrBranchNode <> nil) and (CondNode <> nil) then begin
    { Build compound until condition from header branch + tail branch.
      For "until A or B": header checks A (exit if true), tail checks B (exit if true).
      The header's exit-path is the JMP block (Succs[0]) or skip target (Succs[1]).
      If the exit path is Succs[0] (the JMP block), the header's condition is:
        "skip if comparison fails" --> comparison is the exit condition.
      If the exit path is Succs[1] (the skip target), the condition is inverted. }
    HdrS0 := FSF^.Blocks[HeaderBlk].Succs[0]; { JMP block }
    HdrS1 := FSF^.Blocks[HeaderBlk].Succs[1]; { skip target }

    { Build header condition as an "exit when true" expression }
    case HdrBranchNode^.RelOp of
      ropEQ, ropLT, ropLE: begin
        { If exit path goes through JMP block (Succs[0]), the comparison is the
          condition that triggers the JMP --> exit. The JMP is taken when comparison FAILS
          (skip not taken), so exit = NOT the skip condition = inverted comparison.
          Actually: EQ/LT/LE with Invert flag: if (compare) ~= Invert then skip.
          Succs[0] = fall-through (comparison failed --> JMP), Succs[1] = skip (comparison matched).
          If HdrExitSucc is Succs[0] (JMP block): exit when comparison FAILS = NOT comparison.
          If HdrExitSucc is Succs[1] (skip target): exit when comparison SUCCEEDS = comparison. }
        if (HdrExitSucc = HdrS0) or
           ((HdrExitSucc <> HdrS1) and (HdrExitSucc >= 0) and
            (HdrS0 >= 0) and (HdrS0 < Length(FSF^.Blocks)) and
            (Length(FSF^.Blocks[HdrS0].Succs) = 1) and
            (FSF^.Blocks[HdrS0].Succs[0] = ExitBlk)) then
          { Exit via Succs[0] (JMP block) --> exit when comparison fails --> NOT comparison }
          HdrCondExpr := BuildCompare(HdrBranchNode^.OpA, HdrBranchNode^.OpB,
                                       HdrBranchNode^.RelOp, not HdrBranchNode^.Invert,
                                       HdrBranchNode^.PC)
        else
          { Exit via Succs[1] (skip target) --> exit when comparison succeeds --> comparison }
          HdrCondExpr := BuildCompare(HdrBranchNode^.OpA, HdrBranchNode^.OpB,
                                       HdrBranchNode^.RelOp, HdrBranchNode^.Invert,
                                       HdrBranchNode^.PC);
      end;
      ropTest, ropTestSet: begin
        { TEST C: if bool(R) ~= C then skip.
          Succs[0] = fall-through (not skipped), Succs[1] = skip target.
          If exit via Succs[0]: exit when NOT skipped --> condition failed --> NOT expr.
          If exit via Succs[1]: exit when skipped --> condition succeeded --> expr. }
        if (HdrExitSucc = HdrS0) or
           ((HdrExitSucc <> HdrS1) and (HdrExitSucc >= 0) and
            (HdrS0 >= 0) and (HdrS0 < Length(FSF^.Blocks)) and
            (Length(FSF^.Blocks[HdrS0].Succs) = 1) and
            (FSF^.Blocks[HdrS0].Succs[0] = ExitBlk)) then begin
          if HdrBranchNode^.Invert then
            HdrCondExpr := ExprOf(HdrBranchNode^.OpA, HdrBranchNode^.PC)
          else
            HdrCondExpr := 'not ' + ExprOf(HdrBranchNode^.OpA, HdrBranchNode^.PC);
        end else begin
          if HdrBranchNode^.Invert then
            HdrCondExpr := 'not ' + ExprOf(HdrBranchNode^.OpA, HdrBranchNode^.PC)
          else
            HdrCondExpr := ExprOf(HdrBranchNode^.OpA, HdrBranchNode^.PC);
        end;
      end;
    else
      HdrCondExpr := '';
    end;

    { Build tail condition }
    S0 := -1;
    IsJmpOnly := False;
    if Length(FSF^.Blocks[TailBlk].Succs) >= 2 then begin
      S0 := FSF^.Blocks[TailBlk].Succs[0];
      IsJmpOnly := (S0 = MaxBackEdge) or (S0 = HeaderBlk) or
                   ((S0 >= 0) and (S0 < Length(FSF^.Blocks)) and FEmitted[S0]);
    end;
    CondExpr := '';
    case CondNode^.RelOp of
      ropEQ, ropLT, ropLE: begin
        if IsJmpOnly then
          CondExpr := BuildCompare(CondNode^.OpA, CondNode^.OpB,
                                    CondNode^.RelOp, CondNode^.Invert,
                                    CondNode^.PC)
        else
          CondExpr := BuildCompare(CondNode^.OpA, CondNode^.OpB,
                                    CondNode^.RelOp, not CondNode^.Invert,
                                    CondNode^.PC);
      end;
      ropTest, ropTestSet: begin
        if IsJmpOnly then begin
          if CondNode^.Invert then
            CondExpr := 'not ' + ExprOf(CondNode^.OpA, CondNode^.PC)
          else
            CondExpr := ExprOf(CondNode^.OpA, CondNode^.PC);
        end else begin
          if CondNode^.Invert then
            CondExpr := ExprOf(CondNode^.OpA, CondNode^.PC)
          else
            CondExpr := 'not ' + ExprOf(CondNode^.OpA, CondNode^.PC);
        end;
      end;
    end;
    { Combine: "until A or B" }
    if (HdrCondExpr <> '') and (CondExpr <> '') then
      EmitLine('until ' + HdrCondExpr + ' or ' + CondExpr)
    else if HdrCondExpr <> '' then
      EmitLine('until ' + HdrCondExpr)
    else if CondExpr <> '' then
      EmitLine('until ' + CondExpr)
    else
      EmitLine('until true');
    { Try single-line collapse: "repeat body until cond" (compound) }
    if (MaxBackEdge >= 0) and (MaxBackEdge < Length(FSF^.Blocks)) and
       (Length(FSF^.Blocks[MaxBackEdge].Nodes) > 0) then
      TryCollapseSingleLineBlock(RepeatOpenIdx,
        FSF^.Blocks[HeaderBlk].StartPC,
        FSF^.Blocks[MaxBackEdge].Nodes[High(FSF^.Blocks[MaxBackEdge].Nodes)]^.PC);
  end else begin

  if CondNode <> nil then begin
    { Determine condition polarity. In repeat-until, the condition is the
      EXIT condition (loop terminates when condition is TRUE).
      The tail branch has two successors: one goes back (continue), one exits.
      We need to figure out which successor is the back-edge. }
    S0 := -1;
    IsJmpOnly := False;
    if Length(FSF^.Blocks[TailBlk].Succs) >= 2 then begin
      S0 := FSF^.Blocks[TailBlk].Succs[0];
      { Check if Succs[0] is the back-edge path (= MaxBackEdge or HeaderBlk) }
      IsJmpOnly := (S0 = MaxBackEdge) or (S0 = HeaderBlk) or
                   ((S0 >= 0) and (S0 < Length(FSF^.Blocks)) and FEmitted[S0]);
    end;

    case CondNode^.RelOp of
      ropEQ, ropLT, ropLE: begin
        if IsJmpOnly then
          { Succs[0] = back-edge --> skip = exit --> until(comparison) }
          CondExpr := BuildCompare(CondNode^.OpA, CondNode^.OpB,
                                    CondNode^.RelOp, CondNode^.Invert,
                                    CondNode^.PC)
        else
          { Succs[0] = exit --> skip = back-edge --> until(NOT comparison) }
          CondExpr := BuildCompare(CondNode^.OpA, CondNode^.OpB,
                                    CondNode^.RelOp, not CondNode^.Invert,
                                    CondNode^.PC);
      end;
      ropTest, ropTestSet: begin
        if IsJmpOnly then begin
          { Succs[0] = back-edge (continue loop).
            TEST C=0 (Invert=false): truthy --> skip --> exit --> until <expr>
            TEST C=1 (Invert=true): falsy --> skip --> exit --> until not <expr> }
          if CondNode^.Invert then
            CondExpr := 'not ' + ExprOf(CondNode^.OpA, CondNode^.PC)
          else
            CondExpr := ExprOf(CondNode^.OpA, CondNode^.PC);
        end else begin
          { Succs[0] = exit (exit loop).
            TEST C=0 (Invert=false): truthy --> skip --> back --> until not <expr>
            TEST C=1 (Invert=true): falsy --> skip --> back --> until <expr> }
          if CondNode^.Invert then
            CondExpr := ExprOf(CondNode^.OpA, CondNode^.PC)
          else
            CondExpr := 'not ' + ExprOf(CondNode^.OpA, CondNode^.PC);
        end;
      end;
    else
      CondExpr := 'true';
    end;
  end else
    CondExpr := 'true';

  EmitLine('until ' + CondExpr);
  { Try single-line collapse: "repeat body until cond" }
  if (MaxBackEdge >= 0) and (MaxBackEdge < Length(FSF^.Blocks)) and
     (Length(FSF^.Blocks[MaxBackEdge].Nodes) > 0) then
    TryCollapseSingleLineBlock(RepeatOpenIdx,
      FSF^.Blocks[HeaderBlk].StartPC,
      FSF^.Blocks[MaxBackEdge].Nodes[High(FSF^.Blocks[MaxBackEdge].Nodes)]^.PC);

  end; { end of non-compound condition }
end;

{ ======================================================================
  TryEmitBreakIf - detect "if cond then ... break end" inside loops
  ====================================================================== }

function TDecompiler.TryEmitBreakIf(BranchBlk, TrueBlk, FalseBlk: Integer;
                                     out NextBlk: Integer): Boolean;
{ Detects when one branch of an inner if jumps to the current loop exit,
  and emits: "if cond then <body> break end" + continuation.
  Returns True if the pattern was handled. NextBlk is set to the
  continuation block after the if. }

  function ChainLeadsToExit(Blk: Integer): Boolean;
  { Check whether ALL paths from Blk ultimately reach the current loop
    exit block (no path goes back to the loop header).  Follows single-
    successor chains and, for 2-successor branches, recursively checks
    both successors. }

    function AllPathsExit(Cur: Integer; Depth: Integer): Boolean;
    var S0, S1: Integer;
    begin
      Result := False;
      if Depth > 12 then Exit;  { safety bound }
      if (Cur < 0) or (Cur >= Length(FSF^.Blocks)) then Exit;
      if IsBreakTarget(Cur) then begin Result := True; Exit; end;
      if Length(FSF^.Blocks[Cur].Succs) = 0 then begin
        { RETURN block - also exits the loop }
        Result := True; Exit;
      end;
      if Length(FSF^.Blocks[Cur].Succs) = 1 then begin
        Result := AllPathsExit(FSF^.Blocks[Cur].Succs[0], Depth + 1);
        Exit;
      end;
      if Length(FSF^.Blocks[Cur].Succs) = 2 then begin
        S0 := FSF^.Blocks[Cur].Succs[0];
        S1 := FSF^.Blocks[Cur].Succs[1];
        { Both successors must lead to exit }
        Result := AllPathsExit(S0, Depth + 1) and
                  AllPathsExit(S1, Depth + 1);
      end;
    end;

  begin
    Result := AllPathsExit(Blk, 0);
  end;

  function FollowContinuationBlk(Blk: Integer): Integer;
  { Follow JMP-only trampoline blocks from the continuation branch
    to find the first real-body block. If Blk is JMP-only, return its target. }
  var
    J: Integer;
    IsJmp: Boolean;
  begin
    Result := Blk;
    if (Blk < 0) or (Blk >= Length(FSF^.Blocks)) then Exit;
    if Length(FSF^.Blocks[Blk].Succs) <> 1 then Exit;
    IsJmp := True;
    for J := 0 to High(FSF^.Blocks[Blk].Nodes) do
      if not (FSF^.Blocks[Blk].Nodes[J]^.Kind in [SSA_JUMP, SSA_PHI, SSA_NOP]) then begin
        IsJmp := False; Break;
      end;
    if IsJmp then begin
      FEmitted[Blk] := True;
      Result := FSF^.Blocks[Blk].Succs[0];
    end;
  end;

var
  BranchNode, N: PSSANode;
  I, J, IfPatchIdx: Integer;
  CondExpr, LineStr: AnsiString;
  TrueBreak, FalseBreak, TmpFlag, PatchedElseIf: Boolean;
  BreakBlk, ContBlk: Integer;
  ExitBlk, MergeBlk: Integer;
begin
  Result := False;
  NextBlk := BranchBlk + 1;

  { Only applies inside a loop }
  ExitBlk := CurrentLoopExit;
  if ExitBlk < 0 then Exit;

  { Check which branch leads to the loop exit }
  TrueBreak := ChainLeadsToExit(TrueBlk);
  FalseBreak := ChainLeadsToExit(FalseBlk);

  { Neither leads to exit - not a break pattern }
  if (not TrueBreak) and (not FalseBreak) then Exit;

  { BOTH branches lead to exit: emit a normal if-region + unconditional break.
    This handles patterns like: if b then print(b) end  break
    where both arms of the inner if exit the loop. }
  if TrueBreak and FalseBreak then begin
    { Use the standard EmitIfRegion path, but add break after.
      Skip the break if the body already emitted one (nested case). }
    MergeBlk := ExitBlk;
    EmitIfRegion(BranchBlk, TrueBlk, FalseBlk, MergeBlk);
    if not FLastBreak then
      EmitLine('break');
    NextBlk := ExitBlk;
    Result := True;
    Exit;
  end;

  { Find branch node }
  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 Exit;

  { Determine break and continuation branches }
  if TrueBreak then begin
    BreakBlk := TrueBlk;
    ContBlk := FalseBlk;
  end else begin
    BreakBlk := FalseBlk;
    ContBlk := TrueBlk;
  end;

  { Build condition expression.
    For TrueBreak: "if <cond> then <body> break end"
    For FalseBreak: we need to invert the condition since the false branch breaks }
  case BranchNode^.RelOp of
    ropEQ, ropLT, ropLE: begin
      if TrueBreak then
        CondExpr := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                  BranchNode^.RelOp, BranchNode^.Invert,
                                  BranchNode^.PC)
      else
        CondExpr := BuildCompare(BranchNode^.OpA, BranchNode^.OpB,
                                  BranchNode^.RelOp, not BranchNode^.Invert,
                                  BranchNode^.PC);
    end;
    ropTest, ropTestSet: begin
      if TrueBreak then begin
        if BranchNode^.Invert then
          CondExpr := 'not ' + ExprOf(BranchNode^.OpA, BranchNode^.PC)
        else
          CondExpr := ExprOf(BranchNode^.OpA, BranchNode^.PC);
      end else begin
        if BranchNode^.Invert then
          CondExpr := ExprOf(BranchNode^.OpA, BranchNode^.PC)
        else
          CondExpr := 'not ' + ExprOf(BranchNode^.OpA, BranchNode^.PC);
      end;
    end;
  else
    Exit; { unknown relop, bail out }
  end;

  { Mark branch block as emitted }
  FEmitted[BranchBlk] := True;

  { Emit non-branch nodes from the branch block }
  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 "if <cond> then" }
  EmitLine('if ' + CondExpr + ' then');
  Indent;

  { Emit break branch body (excluding JMP-only trampolines to exit) }
  if IsBreakTarget(BreakBlk) then begin
    { The break branch is just a JMP-only trampoline to the loop exit.
      Mark the trampoline consumed so the enclosing bounded region does not
      later walk into it and emit a second synthetic "do break end".  Do not
      mark the actual exit block: it belongs to the code after the loop. }
    if BreakBlk <> ExitBlk then
      FEmitted[BreakBlk] := True;
  end else begin
    { The break branch has real body nodes to emit }
    EmitRegion(BreakBlk, ExitBlk);
  end;

  { Emit the break statement (skip if body already emitted a break) }
  if not FLastBreak then
    EmitLine('break');

  Dedent;

  { Check if continuation forms an elseif chain.
    Follow JMP-only trampolines to find the real continuation. }
  ContBlk := FollowContinuationBlk(ContBlk);

  { Check if continuation is an elseif-compatible block: has a BRANCH,
    exactly 2 successors, and only condition-setup nodes (no side effects).
    This is a lightweight inline version of IsElseIfBlock for use outside
    EmitIfRegion. }
  TmpFlag := False;
  if (ContBlk >= 0) and (ContBlk < Length(FSF^.Blocks)) and
     (not FEmitted[ContBlk]) and (ContBlk > BranchBlk) and
     (Length(FSF^.Blocks[ContBlk].Succs) = 2) then begin
    TmpFlag := True;
    for I := 0 to High(FSF^.Blocks[ContBlk].Nodes) do begin
      N := FSF^.Blocks[ContBlk].Nodes[I];
      if N^.Kind = SSA_BRANCH then
        { OK - the branch itself }
      else if N^.Kind in [SSA_PHI, SSA_NOP, SSA_JUMP, SSA_LOADK,
                          SSA_LOADBOOL, SSA_LOADNIL, SSA_GETGLOBAL,
                          SSA_GETTABLE, SSA_GETUPVAL, SSA_MOVE,
                          SSA_BINOP, SSA_UNOP, SSA_CONCAT] then
        { OK - condition setup }
      else begin
        TmpFlag := False; Break;
      end;
    end;
  end;

  if TmpFlag then begin
    { Chain as elseif: call EmitIfRegion and patch "if " to "elseif ".
      Some continuation blocks have real setup emitted before their branch
      (for example a local table element used by both arms). In that case the
      first emitted line is not patchable, so close the break guard before the
      already-emitted continuation instead of leaving an unterminated if. }
    MergeBlk := FindMerge(ContBlk,
                           FSF^.Blocks[ContBlk].Succs[1],
                           FSF^.Blocks[ContBlk].Succs[0]);
    if MergeBlk < 0 then
      MergeBlk := ExitBlk;
    IfPatchIdx := FOutput.Count;
    FLastBreak := False;
    EmitIfRegion(ContBlk,
                 FSF^.Blocks[ContBlk].Succs[1],
                 FSF^.Blocks[ContBlk].Succs[0],
                 MergeBlk);
    { Patch the opening "if " to "elseif " in the emitted output }
    PatchedElseIf := False;
    if IfPatchIdx < FOutput.Count then begin
      LineStr := FOutput.GetLine(IfPatchIdx);
      J := 1;
      while (J <= Length(LineStr)) and (LineStr[J] = ' ') do Inc(J);
      if (J + 2 <= Length(LineStr)) and (LineStr[J] = 'i') and
         (LineStr[J + 1] = 'f') and (LineStr[J + 2] = ' ') then begin
        FOutput.SetLine(IfPatchIdx, Copy(LineStr, 1, J - 1) + 'elseif' +
                                    Copy(LineStr, J + 2, Length(LineStr) - J - 1));
        PatchedElseIf := True;
      end;
    end;
    if not PatchedElseIf then begin
      FOutput.Insert(IfPatchIdx, StringOfChar(' ', FIndent * 2) + 'end');
      FLastBreak := False;
    end;
    NextBlk := MergeBlk;
  end else begin
    EmitLine('end');

    { The continuation blocks should be emitted by the enclosing EmitRegion,
      so just set NextBlk to the continuation. If ContBlk leads back to the
      loop header (back-edge), we don't need to emit anything more. }
    if (ContBlk >= 0) and (ContBlk < Length(FSF^.Blocks)) and
       (ContBlk <= BranchBlk) then
      { Continuation goes back to loop header: nothing more to emit }
      NextBlk := ExitBlk
    else
      NextBlk := ContBlk;
  end;

  Result := True;
end;