LuaDecompMulti.inc

{ ======================================================================
  LuaDecompMulti.inc - Multi-assignment pattern detection and emission.

  DESIGN INVARIANT (SSA-first):
  - All local/scope/naming decisions use node-based functions ONLY:
    NodeIsEmittableLocal, NodeIsLocal, NodeNeedsDecl, NodeLocalName,
    NodeMarkDeclared, DefNodeFor(Operand), TempName(Reg).
  - NodeIsEmittableLocal filters out internal names ((for index),
    implicit arg, etc.) - replaces the old IsUserLocal filtering
    without any PC scanning.
  - ZERO calls to PC-based heuristics:
    NO IsUserLocal, NO ShouldEmitAsLocal, NO NeedsLocalDecl,
    NO LocalNameForEmit, NO LocalName.
  - Each LHS slot tracks an "authority node" (the SSA node defining
    that LHS register) for naming and declaration decisions.
  - Declaration guard: NodeNeedsDecl only when NodeIsEmittableLocal
    is True. Never emit 'local' for non-emittable names.
  - SSA_NOP nodes are skipped (Continue) in all scan loops.
  - Four detectors return TMultiAssignResult (maNotMatched/maEmitted).
    EmitTempLoweredMultiAssign provides a fallback for alias-unsafe groups.
  - MultiAssignNeedsTemps detects LHS-RHS aliasing, side effects, and
    metamethod risk to decide direct vs temp-lowered emission.
  ====================================================================== }

function TDecompiler.TryEmitMultiLocal(BIdx, StartIdx: Integer; out ConsumedCount: Integer): Boolean;
{ Detect patterns like:
    LOADK R5 (=0)   --> v
    LOADNIL R6      --> w
  where both define user-locals, and the last N instructions are LOADNIL.
  Emits: local v, w = 0   (trailing nil stripped) }
var
  Blk: TBasicBlock;
  N, First, Next: PSSANode;
  I, Count, BaseReg: Integer;
  Names, Values: AnsiString;
  TrailingNils: Integer;
begin
  Result := False;
  ConsumedCount := 0;
  Blk := FSF^.Blocks[BIdx];
  if StartIdx + 1 >= Length(Blk.Nodes) then Exit;

  First := Blk.Nodes[StartIdx];
  { Skip SSA_NOP (Lua 5.4+ metamethod hints) }
  if First^.Kind = SSA_NOP then Exit;
  { First node must be a non-nil value-defining instruction for a user-local }
  if not (First^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_MOVE, SSA_GETGLOBAL,
                           SSA_GETTABLE, SSA_GETUPVAL, SSA_BINOP, SSA_UNOP,
                           SSA_CONCAT]) then Exit;
  BaseReg := First^.Dest.Reg;
  if not NodeIsEmittableLocal(First) then Exit;

  { The next node must be LOADNIL to the next register, also a user-local.
    This ensures we only fire when there's a trailing nil to strip. }
  Next := Blk.Nodes[StartIdx + 1];
  if Next^.Kind <> SSA_LOADNIL then Exit;
  if Next^.Dest.Reg <> BaseReg + 1 then Exit;
  if not NodeIsEmittableLocal(Next) then Exit;

  { Scan forward to collect all consecutive locals }
  Count := 2;
  I := StartIdx + 2;
  while I <= High(Blk.Nodes) do begin
    N := Blk.Nodes[I];
    if N^.Kind = SSA_NOP then begin Inc(I); Continue; end; { skip metamethod hints }
    if N^.Dest.Reg <> BaseReg + Count then Break;
    if not (N^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL, SSA_MOVE,
                         SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                         SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then Break;
    if not NodeIsEmittableLocal(N) then Break;
    Inc(Count);
    Inc(I);
  end;

  { Count trailing LOADNILs }
  TrailingNils := 0;
  for I := StartIdx + Count - 1 downto StartIdx do begin
    if Blk.Nodes[I]^.Kind = SSA_LOADNIL then
      Inc(TrailingNils)
    else
      Break;
  end;
  if TrailingNils = 0 then Exit;

  { Build the declaration }
  Names := '';
  Values := '';
  for I := 0 to Count - 1 do begin
    N := Blk.Nodes[StartIdx + I];
    if Names <> '' then Names := Names + ', ';
    Names := Names + NodeLocalName(N);
    NodeMarkDeclared(N); { mark as declared }
    { Only add value if not a trailing nil }
    if I < Count - TrailingNils then begin
      if Values <> '' then Values := Values + ', ';
      Values := Values + NodeExpr(N);
    end;
  end;

  if Values <> '' then
    EmitLine('local ' + Names + ' = ' + Values)
  else
    EmitLine('local ' + Names);

  ConsumedCount := Count;
  Result := True;
end;

{ ======================================================================
  TryEmitMultiAssign - detect multiple assignment patterns like:
    local a, b, c = 1, 2, 3
  Compiled as consecutive LOADKs to consecutive registers R, R+1, R+2
  where all the corresponding LocVars share the same StartPC.
  ====================================================================== }

function TDecompiler.TryEmitMultiAssign(BIdx, StartIdx: Integer; out ConsumedCount: Integer): TMultiAssignResult;
var
  Blk: PBasicBlock;
  FirstNode, CurNode: PSSANode;
  BaseReg: Integer;
  Count, I, J, TotalNodes: Integer;
  SharedStartPC: Integer;
  AuthNode: PSSANode;
  AllNeedDecl: Boolean;
  { FinalNodeIdx[i] = index into Blk^.Nodes of the final definition for BaseReg+i }
  FinalNodeIdx: array of Integer;
  Names: array of AnsiString;
  Values: array of AnsiString;
  LHS, RHS, Line: AnsiString;
  ExpectedReg: Integer;
  LastFinalReg: Integer;
begin
  Result := maNotMatched;
  ConsumedCount := 0;
  Blk := @FSF^.Blocks[BIdx];
  FirstNode := Blk^.Nodes[StartIdx];
  { Skip SSA_NOP (Lua 5.4+ metamethod hints) }
  if FirstNode^.Kind = SSA_NOP then Exit;
  { Skip range LOADNIL - these define multiple registers and are handled
    by EmitNode's LOADNIL range handler which properly groups all registers
    in the range into a single "local a, b, c" declaration. }
  if (FirstNode^.Kind = SSA_LOADNIL) and (FirstNode^.ImmA < FirstNode^.ImmB) then Exit;
  BaseReg := FirstNode^.Dest.Reg;
  if BaseReg < 0 then Exit;

  { The first node must be a value-defining instruction that is NOT
    already recognized as a user local at its own PC or PC+1 }
  if (FirstNode^.Kind = SSA_CALL) then begin
    if FirstNode^.ImmC < 2 then Exit; { void call not a value definition }
  end
  else if not (FirstNode^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                               SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                               SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then Exit;
  { Count consecutive value-defining nodes to consecutive registers.
    Allow intermediate writes to the same register: e.g., GETGLOBAL R1 + GETTABLE R1
    forms a pair where GETTABLE is the "final" definition for R1.
    Pattern: nodes must target registers in range [BaseReg .. BaseReg+N-1],
    each new register must appear in order (no gaps or backward jumps except
    re-writes to the current register). }
  SetLength(FinalNodeIdx, 64); { pre-allocate generously }
  FinalNodeIdx[0] := StartIdx;
  Count := 1; { number of distinct consecutive registers found }
  TotalNodes := 1; { total SSA nodes consumed }
  ExpectedReg := BaseReg; { last register assigned = current group end }
  LastFinalReg := BaseReg;

  while (StartIdx + TotalNodes) <= High(Blk^.Nodes) do begin
    CurNode := Blk^.Nodes[StartIdx + TotalNodes];
    { Lua 5.4+: MMBIN/MMBINI/MMBINK hint instructions appear as SSA_NOP
      nodes interspersed after arithmetic BINOPs. Skip them transparently. }
    if CurNode^.Kind = SSA_NOP then begin
      Inc(TotalNodes);
      Continue;
    end;
    if CurNode^.Kind = SSA_CALL then begin
      { Allow value-producing CALLs (ImmC >= 2) as part of multi-assign.
        E.g., local d, e, f = multi(), 10, 20 has CALL(C=2) for d. }
      if CurNode^.ImmC < 2 then Break;
    end
    else if not (CurNode^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                               SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                               SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT]) then Break;
    if CurNode^.Dest.Reg = LastFinalReg then begin
      { Re-write to the same register (e.g., GETGLOBAL R1 then GETTABLE R1).
        Update the final node for this register. }
      FinalNodeIdx[Count - 1] := StartIdx + TotalNodes;
      Inc(TotalNodes);
    end
    else if CurNode^.Dest.Reg = LastFinalReg + 1 then begin
      { Next consecutive register - new entry in the group }
      LastFinalReg := CurNode^.Dest.Reg;
      if Count >= Length(FinalNodeIdx) then
        SetLength(FinalNodeIdx, Count * 2);
      FinalNodeIdx[Count] := StartIdx + TotalNodes;
      Inc(Count);
      Inc(TotalNodes);
    end
    else
      Break; { gap or non-consecutive - stop }
  end;

  { Need at least 2 for a multi-assignment }
  if Count < 2 then Exit;

  { Get SharedStartPC from the first authority node's LocVar.
    All authority nodes must be emittable locals with the same StartPC. }
  AuthNode := Blk^.Nodes[FinalNodeIdx[0]];
  if not NodeIsEmittableLocal(AuthNode) then Exit;
  SharedStartPC := FProto^.LocVars[AuthNode^.LocVarIdx].StartPC;

  { SharedStartPC must be >= first instruction PC.
    If StartPC < FirstNode^.PC, this LocVar was declared earlier
    and this is a reassignment, not a fresh multi-local declaration. }
  if SharedStartPC < FirstNode^.PC then Exit;

  { The LocVar must start very close to the last instruction in the group.
    For "local a, b, c = 1, 2, 3" the LocVars start at the PC of the last
    value-defining instruction (or one after). Allow +2 for Lua 5.4+ where
    a trailing MMBIN NOP pushes the LocVar StartPC one further.
    For Lua 5.1-5.3, use strict +1 to avoid false positives (e.g.,
    complexassign03 where CALL arg GETGLOBALs would be incorrectly
    matched as a multi-assign group). }
  CurNode := Blk^.Nodes[FinalNodeIdx[Count - 1]];
  if FSF^.LuaVersion >= $54 then begin
    if SharedStartPC > CurNode^.PC + 2 then Exit;
  end else begin
    if SharedStartPC > CurNode^.PC + 1 then Exit;
  end;

  { Verify ALL registers in the group have emittable locals sharing the same StartPC }
  for I := 1 to Count - 1 do begin
    AuthNode := Blk^.Nodes[FinalNodeIdx[I]];
    if not NodeIsEmittableLocal(AuthNode) then begin
      Count := I;
      Break;
    end;
    if FProto^.LocVars[AuthNode^.LocVarIdx].StartPC <> SharedStartPC then begin
      Count := I;
      Break;
    end;
  end;

  if Count < 2 then Exit;

  { Guard against CALL argument setup being mistaken for a multi-local.
    After the verify step may have shrunk Count, there could be remaining
    value-defining nodes (e.g. more GETGLOBALs) between the group and a CALL.
    Scan past any remaining value nodes and NOPs; if we find a CALL whose
    register range overlaps with [BaseReg .. BaseReg+Count-1], these nodes
    are argument setup, not a multi-local declaration.
    CALL ImmB: 0=vararg (uses all regs from Dest), >=2 means ImmB-1 args,
    so call occupies [Dest .. Dest+ImmB-1]. }
  I := FinalNodeIdx[Count - 1] + 1;
  while (I <= High(Blk^.Nodes)) and
        (Blk^.Nodes[I]^.Kind in [SSA_NOP, SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                                   SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                                   SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT]) do
    Inc(I);
  if (I <= High(Blk^.Nodes)) and
     (Blk^.Nodes[I]^.Kind in [SSA_CALL, SSA_TAILCALL]) then begin
    J := Blk^.Nodes[I]^.Dest.Reg;
    { If the CALL's function register falls within the multi-assign group,
      the group node for that register is CALL setup (loading the function
      reference), not a genuine assignment. Reject the group.
      Example: LOADK R0 1, GETTABUP R1 "f", CALL R1 - R1 is CALL setup. }
    if (J >= BaseReg) and (J <= BaseReg + Count - 1) then Exit;
    if Blk^.Nodes[I]^.ImmB = 0 then begin
      { Vararg call: uses all registers from Dest upward }
      if BaseReg >= J then Exit;
    end else if Blk^.Nodes[I]^.ImmB >= 2 then begin
      { Fixed arg call: uses [Dest .. Dest+ImmB-1] }
      if (BaseReg >= J) and (BaseReg <= J + Blk^.Nodes[I]^.ImmB - 1) then Exit;
    end;
  end;

  { Recalculate TotalNodes based on final Count (in case we shrank).
    Include any trailing SSA_NOP nodes after the last value-defining node
    (MMBIN hints in Lua 5.4+). }
  TotalNodes := (FinalNodeIdx[Count - 1] - StartIdx) + 1;
  while ((StartIdx + TotalNodes) <= High(Blk^.Nodes)) and
        (Blk^.Nodes[StartIdx + TotalNodes]^.Kind = SSA_NOP) do
    Inc(TotalNodes);

  { Build the names and values }
  SetLength(Names, Count);
  SetLength(Values, Count);
  for I := 0 to Count - 1 do begin
    Names[I] := NodeLocalName(Blk^.Nodes[FinalNodeIdx[I]]);
    Values[I] := NodeExpr(Blk^.Nodes[FinalNodeIdx[I]]);
    { Cache expression for ALL versions of this register in the group so
      ExprOf resolution works correctly }
    J := NodeIdx(Blk^.Nodes[FinalNodeIdx[I]]^.Dest.Reg,
                 Blk^.Nodes[FinalNodeIdx[I]]^.Dest.Version);
    if (J >= 0) and (J < Length(FExprStr)) then
      FExprStr[J] := Names[I];
  end;

  { Strip trailing nil values from the RHS.
    "local v, w = 0, nil" --> "local v, w = 0"
    "local a, b = nil, nil" --> "local a, b" }
  J := Count;
  while (J > 0) and (Values[J - 1] = 'nil') do
    Dec(J);
  { J = number of non-trailing-nil values }

  { Build: local a, b, c = 1, 2, 3 }
  LHS := '';
  RHS := '';
  for I := 0 to Count - 1 do begin
    if LHS <> '' then LHS := LHS + ', ';
    LHS := LHS + Names[I];
    if I < J then begin
      if RHS <> '' then RHS := RHS + ', ';
      RHS := RHS + Values[I];
    end;
  end;

  { Check if this needs 'local' declaration - all authority nodes must need it }
  Line := '';
  AllNeedDecl := True;
  for I := 0 to Count - 1 do begin
    if not NodeNeedsDecl(Blk^.Nodes[FinalNodeIdx[I]]) then begin
      AllNeedDecl := False;
      Break;
    end;
  end;
  if AllNeedDecl then
    Line := 'local ';
  if RHS <> '' then
    Line := Line + LHS + ' = ' + RHS
  else
    Line := Line + LHS;
  EmitLine(Line);

  { Mark all the local declarations as done }
  for I := 0 to Count - 1 do
    NodeMarkDeclared(Blk^.Nodes[FinalNodeIdx[I]]);

  ConsumedCount := TotalNodes;
  Result := maEmitted;
end;

{ ======================================================================
  TryEmitMultiReturnAssign - detect CALL with multiple returns followed
  by MOVE assignments to user locals.
  Pattern: CALL R(base) ImmC=N+1 returns N values into R(base)..R(base+N-1)
  followed by N MOVEs that move R(base+N-1), ..., R(base) to user locals
  (in reverse order, as Lua assigns right-to-left).
  Emits: local? p, a, s = func(args)
  ====================================================================== }

function TDecompiler.TryEmitMultiReturnAssign(BIdx, StartIdx: Integer; out ConsumedCount: Integer): TMultiAssignResult;
var
  Blk: PBasicBlock;
  CallNode, MoveNode: PSSANode;
  NumReturns, I, ArgI, BaseReg: Integer;
  FuncName, Args, LHS, RHS, Key, CallExpr: AnsiString;
  PC: Integer;
  DestRegs: array of Integer;    { register targets of each MOVE }
  DestNames: array of AnsiString; { name of each target }
  MoveCount: Integer;
  AllUserLocals: Boolean;
begin
  Result := maNotMatched;
  ConsumedCount := 0;
  Blk := @FSF^.Blocks[BIdx];
  CallNode := Blk^.Nodes[StartIdx];

  { Must be a CALL with multiple returns (ImmC >= 3 means 2+ return values)
    or a VARARG with multiple results (ImmB >= 3 means 2+ varargs). }
  if CallNode^.Kind = SSA_CALL then begin
    if CallNode^.ImmC < 3 then Exit;
    NumReturns := CallNode^.ImmC - 1;
    BaseReg := CallNode^.ImmA;
  end
  else if CallNode^.Kind = SSA_VARARG then begin
    if CallNode^.ImmB < 3 then Exit;
    NumReturns := CallNode^.ImmB - 1;
    BaseReg := CallNode^.ImmA;
  end
  else
    Exit;
  PC := CallNode^.PC;

  { Must have enough MOVEs after the CALL }
  if (StartIdx + NumReturns) > High(Blk^.Nodes) then Exit;

  { Check that the following N nodes are MOVEs or SETGLOBALs from the CALL
    result registers to named targets. MOVEs go to user locals, SETGLOBALs
    go to globals. All must reference CALL return registers. }
  SetLength(DestRegs, NumReturns);
  SetLength(DestNames, NumReturns);
  MoveCount := 0;
  AllUserLocals := True;

  for I := 1 to NumReturns do begin
    MoveNode := Blk^.Nodes[StartIdx + I];
    if MoveNode^.Kind = SSA_MOVE then begin
      { Source must be one of the CALL return registers }
      if (MoveNode^.OpA.Reg < BaseReg) or
         (MoveNode^.OpA.Reg >= BaseReg + NumReturns) then begin
        AllUserLocals := False;
        Break;
      end;
      { Destination must be a user local }
      if not NodeIsEmittableLocal(MoveNode) then begin
        AllUserLocals := False;
        Break;
      end;
      DestRegs[I - 1] := MoveNode^.OpA.Reg;
      DestNames[I - 1] := NodeLocalName(MoveNode);
    end
    else if MoveNode^.Kind = SSA_SETGLOBAL then begin
      { Source register in OpA must be a CALL return register }
      if (MoveNode^.OpA.Reg < BaseReg) or
         (MoveNode^.OpA.Reg >= BaseReg + NumReturns) then begin
        AllUserLocals := False;
        Break;
      end;
      DestRegs[I - 1] := MoveNode^.OpA.Reg;
      { Get the global name from constants }
      if (MoveNode^.ConstIdx >= 0) and (MoveNode^.ConstIdx < Length(FProto^.K)) then
        DestNames[I - 1] := FProto^.K[MoveNode^.ConstIdx].SValue
      else
        DestNames[I - 1] := 'g' + IntToStr(MoveNode^.ConstIdx);
    end
    else begin
      AllUserLocals := False;
      Break;
    end;
    Inc(MoveCount);
  end;

  if (not AllUserLocals) or (MoveCount <> NumReturns) then Exit;

  { Build the CALL/VARARG expression }
  if CallNode^.Kind = SSA_VARARG then begin
    { VARARG: expression is simply "..." }
    CallExpr := '...';
  end else begin
    FuncName := ExprOf(CallNode^.OpA, PC);
    if Copy(FuncName, 1, 8) = 'function' then
      FuncName := '(' + FuncName + ')';

    ArgI := 0;
    { Detect SELF method call - skip implicit self argument }
    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;
    Args := '';
    while ArgI <= High(CallNode^.ArgRefs) do begin
      if Args <> '' then Args := Args + ', ';
      Args := Args + ExprOf(CallNode^.ArgRefs[ArgI], PC);
      Inc(ArgI);
    end;
    CallExpr := FuncName + '(' + Args + ')';
  end;

  { Build LHS: the target names in the order of the return registers.
    MOVEs/SETGLOBALs may be in reverse order, so map by source register.
    DestRegs[J] holds the source register and DestNames[J] holds the target name. }
  LHS := '';
  Key := '';
  for I := 0 to NumReturns - 1 do begin
    { Find which assignment node reads from BaseReg + I }
    RHS := '';
    for ArgI := 0 to MoveCount - 1 do begin
      if DestRegs[ArgI] = BaseReg + I then begin
        RHS := DestNames[ArgI];
        { Check if the target needs 'local' declaration (only for MOVEs to locals) }
        MoveNode := Blk^.Nodes[StartIdx + ArgI + 1];
        if (MoveNode^.Kind = SSA_MOVE) and
           NodeNeedsDecl(MoveNode) then
          Key := 'local ';
        Break;
      end;
    end;
    if RHS = '' then Exit; { shouldn't happen }
    if LHS <> '' then LHS := LHS + ', ';
    LHS := LHS + RHS;
  end;

  { Cache expression in the CALL's dest so ExprOf doesn't inline it }
  I := NodeIdx(CallNode^.Dest.Reg, CallNode^.Dest.Version);
  if (I >= 0) and (I < Length(FExprStr)) then
    FExprStr[I] := '__multiret__';

  EmitLine(Key + LHS + ' = ' + CallExpr);

  { Mark all MOVE target declarations as done }
  for I := 1 to NumReturns do begin
    MoveNode := Blk^.Nodes[StartIdx + I];
    if MoveNode^.Kind = SSA_MOVE then
      NodeMarkDeclared(MoveNode);
  end;

  ConsumedCount := 1 + NumReturns; { CALL/VARARG + N MOVEs }
  Result := maEmitted;
end;

{ ======================================================================
  TryEmitReverseMultiAssign - detect value-compute + reverse-MOVE patterns.
  Handles: a, b = ...      (VARARG + reverse MOVEs)
           a, b = ..., 2   (VARARG + LOADK + reverse MOVEs)
           a, b, c = 1, f(1,2,3)  (LOADK + CALL(multi) + reverse MOVEs)
           a, b, c = f(), 1, 2    (CALL(1-ret) + LOADKs + reverse MOVEs)
  ====================================================================== }

function TDecompiler.TryEmitReverseMultiAssign(BIdx, StartIdx: Integer; out ConsumedCount: Integer): TMultiAssignResult;
var
  Blk: PBasicBlock;
  I, J, K, MoveStart, MoveEnd, NumMoves: Integer;
  SrcDef: PSSANode;
  TargetReg, LowestTarget, HighestTarget: Integer;
  Node, MoveNode: PSSANode;
  { Track the assignment: target register --> (source expression, node index) }
  Targets: array of Integer;  { target register for each MOVE }
  Sources: array of Integer;  { source register for each MOVE }
  { Value definitions for temp registers }
  ValExprs: array of AnsiString;  { expressions for each target position }
  LHS, RHS, Line, ExprStr: AnsiString;
  BaseReg, SrcReg, TempBaseReg: Integer;
  NumTargets: Integer;
  AllNamed, HasMultiRet, FoundDef, NeedsDeclAll: Boolean;
  TargetAuthNodes: array of PSSANode;
  MultiRetNode: PSSANode;
  MultiRetIdx, MultiRetBase, MultiRetCount: Integer;
  FuncName, Args: AnsiString;
  ArgI, L: Integer;
  IsSelf: Boolean;
begin
  Result := maNotMatched;
  ConsumedCount := 0;
  Blk := @FSF^.Blocks[BIdx];

  { Scan forward from StartIdx to find a sequence of reverse MOVEs.
    The first node must be a value definition (LOADK, VARARG, CALL, etc.)
    that writes to a temp register (not a user local). }
  Node := Blk^.Nodes[StartIdx];
  { Skip SSA_NOP (Lua 5.4+ metamethod hints) }
  if Node^.Kind = SSA_NOP then Exit;
  if not (Node^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                          SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                          SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT,
                          SSA_VARARG, SSA_CALL, SSA_NEWTABLE]) then Exit;

  { Reject CALL with no return values (ImmC=0 or ImmC=1) - these are
    side-effect statements (e.g., f()), not value-producing expressions. }
  if (Node^.Kind = SSA_CALL) and (Node^.ImmC <= 1) then Exit;

  BaseReg := Node^.Dest.Reg;
  { The starting node must write to a temp register (above user locals).
    For the pattern to work, the first node's register must be above
    the eventual target registers. Skip if it's already a user local. }
  if NodeIsEmittableLocal(Node) then Exit;

  { Find where the reverse MOVEs start.
    Scan forward: value-defining nodes write to temp registers,
    then MOVEs copy from temp registers to user locals.
    Track if value phase contains VARARG or CALL - this detector only
    handles patterns with multi-return sources (VARARG/CALL). Regular
    single-value assignments are handled by TryEmitMultiAssign/TryEmitSwap. }
  MoveStart := -1;
  HasMultiRet := (Node^.Kind in [SSA_VARARG, SSA_CALL]);
  for I := StartIdx + 1 to High(Blk^.Nodes) do begin
    MoveNode := Blk^.Nodes[I];
    { Resolve source definer; if implicit-def parent (Dest ≠ OpA), clear it
      so NodeIsLocal checks the right register, not the parent's primary def. }
    SrcDef := DefNodeFor(MoveNode^.OpA);
    if (SrcDef <> nil) and (not RefEqual(SrcDef^.Dest, MoveNode^.OpA)) then
      SrcDef := nil;
    if (MoveNode^.Kind = SSA_MOVE) and
       NodeIsEmittableLocal(MoveNode) and
       (not NodeIsLocal(SrcDef)) and
       (MoveNode^.OpA.Reg >= BaseReg) then begin
      MoveStart := I;
      Break;
    end;
    { Skip SSA_NOP (Lua 5.4+ metamethod hints) }
    if MoveNode^.Kind = SSA_NOP then Continue;
    { Track VARARG/CALL presence }
    if MoveNode^.Kind in [SSA_VARARG, SSA_CALL] then
      HasMultiRet := True;
    { Allow value-defining nodes and direct-to-local LOADKs between start and MOVEs }
    if MoveNode^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                           SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                           SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT,
                           SSA_VARARG, SSA_CALL, SSA_NEWTABLE] then
      Continue
    else
      Exit; { unexpected node kind }
  end;

  if MoveStart < 0 then Exit;

  { Reject false matches where the start node is actually a CALL argument.
    If the start node is NOT a CALL/VARARG, and there's a CALL between
    StartIdx and MoveStart with ImmA < BaseReg, the start node is
    likely a CALL argument setup (e.g., LOADK R4 before CALL R3). }
  if not (Blk^.Nodes[StartIdx]^.Kind in [SSA_CALL, SSA_VARARG]) then begin
    for I := StartIdx + 1 to MoveStart - 1 do begin
      if (Blk^.Nodes[I]^.Kind = SSA_CALL) and (Blk^.Nodes[I]^.ImmA < BaseReg) then
        Exit;
    end;
  end;

  { Count reverse MOVEs: they must write to consecutive user locals,
    with each MOVE reading from a temp register >= BaseReg.
    The targets should decrease (reverse order): e.g., R2, R1, R0. }
  NumMoves := 0;
  HighestTarget := -1;
  LowestTarget := MaxInt;
  MoveEnd := MoveStart;

  SetLength(Targets, 16);
  SetLength(Sources, 16);

  I := MoveStart;
  while I <= High(Blk^.Nodes) do begin
    MoveNode := Blk^.Nodes[I];
    if (MoveNode^.Kind <> SSA_MOVE) then Break;
    if not NodeIsEmittableLocal(MoveNode) then Break;
    { Source must be a temp register from the value phase }
    if MoveNode^.OpA.Reg < BaseReg then Break;

    if NumMoves >= Length(Targets) then begin
      SetLength(Targets, NumMoves * 2);
      SetLength(Sources, NumMoves * 2);
    end;
    Targets[NumMoves] := MoveNode^.Dest.Reg;
    Sources[NumMoves] := MoveNode^.OpA.Reg;
    if MoveNode^.Dest.Reg > HighestTarget then
      HighestTarget := MoveNode^.Dest.Reg;
    if MoveNode^.Dest.Reg < LowestTarget then
      LowestTarget := MoveNode^.Dest.Reg;
    Inc(NumMoves);
    MoveEnd := I;
    Inc(I);
  end;

  if NumMoves < 1 then Exit;
  NumTargets := HighestTarget - LowestTarget + 1;

  { Also check for direct writes to user locals between StartIdx and MoveStart.
    E.g., "a, b = ..., 2" may have LOADK directly to R1 (user local b).
    "a, b, c = f(), 1, 2" may have LOADK directly to R2 (user local c).
    Also handles MOVE to user local where source < BaseReg (direct copy,
    e.g., "d = duration" where duration is a parameter and no temp needed). }
  { Collect all direct-to-local writes }
  for I := StartIdx to MoveStart - 1 do begin
    Node := Blk^.Nodes[I];
    if Node^.Kind = SSA_NOP then Continue; { skip metamethod hints }
    if (Node^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                        SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                        SSA_BINOP, SSA_UNOP, SSA_CONCAT]) and
       NodeIsEmittableLocal(Node) and
       ((Node^.Dest.Reg >= LowestTarget) and (Node^.Dest.Reg <= HighestTarget + 1)) then begin
      { This is a direct write - add it as a "virtual MOVE" }
      if NumMoves >= Length(Targets) then begin
        SetLength(Targets, NumMoves * 2);
        SetLength(Sources, NumMoves * 2);
      end;
      Targets[NumMoves] := Node^.Dest.Reg;
      Sources[NumMoves] := -1;  { -1 = direct value, not a MOVE source }
      Inc(NumMoves);
      if Node^.Dest.Reg > HighestTarget then
        HighestTarget := Node^.Dest.Reg;
      if Node^.Dest.Reg < LowestTarget then
        LowestTarget := Node^.Dest.Reg;
    end
    { MOVE to user local where source < BaseReg: direct param/local copy
      that doesn't use the temp range (e.g., d = duration). }
    else if (Node^.Kind = SSA_MOVE) and
       (Node^.OpA.Reg < BaseReg) and
       NodeIsEmittableLocal(Node) and
       ((Node^.Dest.Reg >= LowestTarget) and (Node^.Dest.Reg <= HighestTarget + 1)) then begin
      if NumMoves >= Length(Targets) then begin
        SetLength(Targets, NumMoves * 2);
        SetLength(Sources, NumMoves * 2);
      end;
      Targets[NumMoves] := Node^.Dest.Reg;
      Sources[NumMoves] := -1;  { -1 = direct value, use NodeExpr }
      Inc(NumMoves);
      if Node^.Dest.Reg > HighestTarget then
        HighestTarget := Node^.Dest.Reg;
      if Node^.Dest.Reg < LowestTarget then
        LowestTarget := Node^.Dest.Reg;
    end;
  end;

  NumTargets := HighestTarget - LowestTarget + 1;
  if NumTargets < 2 then Exit;
  if NumTargets > 16 then Exit; { sanity }

  { Build TargetAuthNodes: find authority node for each LHS position }
  SetLength(TargetAuthNodes, NumTargets);
  for I := 0 to NumTargets - 1 do begin
    TargetReg := LowestTarget + I;
    TargetAuthNodes[I] := nil;
    { Check write-back MOVEs first }
    for K := MoveStart to MoveEnd do begin
      if (Blk^.Nodes[K]^.Kind = SSA_MOVE) and
         (Blk^.Nodes[K]^.Dest.Reg = TargetReg) then begin
        TargetAuthNodes[I] := Blk^.Nodes[K];
        Break;
      end;
    end;
    { If not found in MOVEs, check direct writes in value phase }
    if TargetAuthNodes[I] = nil then begin
      for K := MoveStart - 1 downto StartIdx do begin
        if Blk^.Nodes[K]^.Dest.Reg = TargetReg then begin
          TargetAuthNodes[I] := Blk^.Nodes[K];
          Break;
        end;
      end;
    end;
  end;

  { Build value expressions for each target position }
  SetLength(ValExprs, NumTargets);
  for I := 0 to NumTargets - 1 do
    ValExprs[I] := '';

  { Build value expressions for each target position.
    For each target register (LowestTarget..HighestTarget), find its value:
    - If it's a MOVE target with source SrcReg, find the definition of SrcReg
    - If it's a direct write, use the node's expression
    For multi-return VARARG/CALL, the expression expands to fill remaining slots
    (only valid at the last position in the RHS). }
  for J := 0 to NumTargets - 1 do begin
    TargetReg := LowestTarget + J;
    ValExprs[J] := '';
    { Find which MOVE/direct writes to this target }
    SrcReg := -2; { -2 = not found }
    for I := 0 to NumMoves - 1 do begin
      if Targets[I] = TargetReg then begin
        SrcReg := Sources[I]; Break;
      end;
    end;
    if SrcReg = -2 then Exit; { target not covered }
    if SrcReg = -1 then begin
      { Direct write - find the node that writes directly to this target.
        Handles LOADK, LOADBOOL, LOADNIL, GETGLOBAL, GETTABLE, etc.
        Also handles MOVE where source < BaseReg (direct param/local copy). }
      for K := MoveStart - 1 downto StartIdx do begin
        Node := Blk^.Nodes[K];
        if (Node^.Dest.Reg = TargetReg) then begin
          if Node^.Kind = SSA_MOVE then
            ValExprs[J] := ExprOf(Node^.OpA, Node^.PC)
          else
            ValExprs[J] := NodeExpr(Node);
          Break;
        end;
      end;
      if ValExprs[J] = '' then Exit;
    end else begin
      { MOVE from SrcReg - find LAST definition by scanning backwards.
        This is important because CALL arguments (LOADK/GETGLOBAL) may
        initially define a register, then the CALL overwrites it with
        return values.  Scanning backwards finds the CALL first. }
      FoundDef := False;
      for K := MoveStart - 1 downto StartIdx do begin
        Node := Blk^.Nodes[K];
        { Check implicit multi-return FIRST: VARARG/CALL that implicitly
          defines SrcReg as an extra return register.
          ImmB=0 means variable number of results (fills from ImmA upward).
          ImmB>1 means fixed count: ImmB-1 results from ImmA to ImmA+ImmB-2. }
        if (Node^.Kind = SSA_VARARG) and
           ((Node^.ImmB = 0) or (Node^.ImmB > 1)) and
           (SrcReg >= Node^.ImmA) then begin
          { For fixed count, check upper bound }
          if (Node^.ImmB > 1) and (SrcReg > Node^.ImmA + Node^.ImmB - 2) then
            { SrcReg outside fixed range - not from this VARARG }
          else begin
            if SrcReg = Node^.ImmA then
              ValExprs[J] := '...'
            else begin
              { Extra return register - covered by VARARG expansion }
            end;
            FoundDef := True; Break;
          end;
        end;
        if (Node^.Kind = SSA_CALL) and (Node^.ImmC > 1) and
           (SrcReg >= Node^.ImmA) and (SrcReg <= Node^.ImmA + Node^.ImmC - 2) then begin
          if SrcReg = Node^.ImmA then begin
            { First return register - build the call expression }
            FuncName := ExprOf(Node^.OpA, Node^.PC);
            if Copy(FuncName, 1, 8) = 'function' then
              FuncName := '(' + FuncName + ')';
            ArgI := 0; IsSelf := False;
            if (Node^.OpA.Reg >= 0) and (Node^.OpA.Reg <> SSA_CONST_REG) then
              for L := 0 to High(FSF^.AllNodes) do
                if RefEqual(FSF^.AllNodes[L]^.Dest, Node^.OpA) and
                   (FSF^.AllNodes[L]^.Kind = SSA_SELF) then begin
                  ArgI := 1; IsSelf := True; Break;
                end;
            Args := '';
            while ArgI <= High(Node^.ArgRefs) do begin
              if Args <> '' then Args := Args + ', ';
              Args := Args + ExprOf(Node^.ArgRefs[ArgI], Node^.PC);
              Inc(ArgI);
            end;
            ValExprs[J] := FuncName + '(' + Args + ')';
          end;
          { Else: extra return register - covered by CALL expansion }
          FoundDef := True; Break;
        end;
        { Exact match on Dest.Reg }
        if Node^.Dest.Reg = SrcReg then begin
          if Node^.Kind = SSA_VARARG then begin
            ValExprs[J] := '...'; FoundDef := True;
          end
          else if Node^.Kind = SSA_CALL then begin
            FuncName := ExprOf(Node^.OpA, Node^.PC);
            if Copy(FuncName, 1, 8) = 'function' then
              FuncName := '(' + FuncName + ')';
            ArgI := 0; IsSelf := False;
            if (Node^.OpA.Reg >= 0) and (Node^.OpA.Reg <> SSA_CONST_REG) then
              for L := 0 to High(FSF^.AllNodes) do
                if RefEqual(FSF^.AllNodes[L]^.Dest, Node^.OpA) and
                   (FSF^.AllNodes[L]^.Kind = SSA_SELF) then begin
                  ArgI := 1; IsSelf := True; Break;
                end;
            Args := '';
            while ArgI <= High(Node^.ArgRefs) do begin
              if Args <> '' then Args := Args + ', ';
              Args := Args + ExprOf(Node^.ArgRefs[ArgI], Node^.PC);
              Inc(ArgI);
            end;
            ValExprs[J] := FuncName + '(' + Args + ')'; FoundDef := True;
          end
          else begin
            ValExprs[J] := NodeExpr(Node); FoundDef := True;
          end;
          Break;
        end;
      end;
      if not FoundDef then Exit;
    end;
  end;

  { Build RHS: collect non-empty expressions in order.
    Skip empty positions (covered by multi-return expansion). }
  RHS := '';
  if FOpts.Debug then
    for J := 0 to NumTargets - 1 do
      WriteLn(StdErr, 'TryEmitReverseMulti: ValExprs[', J, '] = "', ValExprs[J], '"');
  for J := 0 to NumTargets - 1 do begin
    if ValExprs[J] <> '' then begin
      if RHS <> '' then RHS := RHS + ', ';
      RHS := RHS + ValExprs[J];
    end;
  end;
  if RHS = '' then Exit;

  { Build LHS names using authority nodes }
  LHS := '';
  for I := 0 to NumTargets - 1 do begin
    if LHS <> '' then LHS := LHS + ', ';
    if (TargetAuthNodes[I] <> nil) and NodeIsEmittableLocal(TargetAuthNodes[I]) then
      LHS := LHS + NodeLocalName(TargetAuthNodes[I])
    else
      LHS := LHS + 't' + IntToStr(LowestTarget + I);
  end;

  { Check if this needs 'local' declaration - all authority nodes must need it }
  Line := '';
  NeedsDeclAll := True;
  for I := 0 to NumTargets - 1 do begin
    if (TargetAuthNodes[I] = nil) or not NodeNeedsDecl(TargetAuthNodes[I]) then begin
      NeedsDeclAll := False;
      Break;
    end;
  end;
  if NeedsDeclAll then
    Line := 'local ';
  Line := Line + LHS + ' = ' + RHS;
  EmitLine(Line);

  { Mark local declarations as done }
  for I := 0 to NumTargets - 1 do
    if TargetAuthNodes[I] <> nil then
      NodeMarkDeclared(TargetAuthNodes[I]);

  { Mark all value-phase and MOVE nodes as consumed to prevent re-emission }
  for I := StartIdx to MoveEnd do begin
    Node := Blk^.Nodes[I];
    K := NodeIdx(Node^.Dest.Reg, Node^.Dest.Version);
    if (K >= 0) and (K < Length(FInlined)) then
      FInlined[K] := True;
    if Node^.Kind in [SSA_CALL, SSA_VARARG] then begin
      if (K >= 0) and (K < Length(FExprStr)) then
        FExprStr[K] := '__multiret__';
    end;
  end;

  ConsumedCount := (MoveEnd - StartIdx) + 1;
  Result := maEmitted;
end;

{ ======================================================================
  TryEmitSwap - detect variable swap patterns in MOVE sequences
  ====================================================================== }

function TDecompiler.TryEmitSwap(BIdx, StartIdx: Integer; out ConsumedCount: Integer): TMultiAssignResult;
{ Detect multi-assignment patterns compiled from:
    a, b, c, d = expr1, expr2, expr3, expr4
  The compiler generates:
    Phase 1 (save):  MOVE temp := old_local  (save values that will be overwritten)
    Phase 2 (compute): BINOP temp/local := ... (compute new values)
    Phase 3 (write): MOVE local := temp  (write saved/computed values to locals)

  The write-back MOVEs appear in reverse order of the original LHS.
  BINOPs that write directly to user-locals are interleaved with the pattern.

  In Lua 5.4+, MMBIN/MMBINI/MMBINK metamethod hints (SSA_NOP) are
  interspersed after each BINOP.  We skip NOPs transparently and track
  actual node indices via SaveIdx/MidIdx/WriteIdx arrays. }
var
  Blk: TBasicBlock;
  N, WB: PSSANode;
  I, J, K, SaveCount, MidCount, WriteCount, NopCount, Total: Integer;
  SaveIdx, MidIdx, WriteIdx: array of Integer;
  LHS, RHS: AnsiString;
  IsLocal, UsedByWriteBack: Boolean;
begin
  Result := maNotMatched;
  ConsumedCount := 0;
  Blk := FSF^.Blocks[BIdx];
  if StartIdx >= Length(Blk.Nodes) then Exit;

  SetLength(SaveIdx, 16);
  SetLength(MidIdx, 16);
  SetLength(WriteIdx, 16);

  { Phase 1: Count consecutive temp-save MOVEs (dest = non-local temp).
    A MOVE is a save if its dest register is later used as an OpA source by
    another MOVE within the pattern. We check this by doing a forward scan. }
  SaveCount := 0;
  NopCount := 0;
  I := StartIdx;
  while I <= High(Blk.Nodes) do begin
    N := Blk.Nodes[I];
    if N^.Kind <> SSA_MOVE then Break;
    if NodeIsLocal(N) then Break;
    { Check if this MOVE's dest is used as a source by a later MOVE,
      or as a key/value in a SETTABLE write-back within this block.
      We scan past BINOPs, NOPs, LOADKs, GETTABLEs, SETTABLEs because
      Phase 2 and Phase 3 may include these instruction types. }
    IsLocal := False;
    for J := I + 1 to High(Blk.Nodes) do begin
      if not (Blk.Nodes[J]^.Kind in [SSA_MOVE, SSA_BINOP, SSA_NOP,
              SSA_LOADK, SSA_LOADBOOL, SSA_GETTABLE, SSA_SETTABLE]) then Break;
      { Write-back MOVE uses the saved temp as source }
      if (Blk.Nodes[J]^.Kind = SSA_MOVE) and
         (Blk.Nodes[J]^.OpA.Reg = N^.Dest.Reg) and
         (Blk.Nodes[J]^.OpA.Version = N^.Dest.Version) then begin
        IsLocal := True; Break;
      end;
      { SETTABLE uses the saved temp as key or value }
      if (Blk.Nodes[J]^.Kind = SSA_SETTABLE) then begin
        if ((Blk.Nodes[J]^.OpB.Reg = N^.Dest.Reg) and
            (Blk.Nodes[J]^.OpB.Version = N^.Dest.Version)) or
           ((Blk.Nodes[J]^.OpC.Reg = N^.Dest.Reg) and
            (Blk.Nodes[J]^.OpC.Version = N^.Dest.Version)) then begin
          IsLocal := True; Break;
        end;
      end;
    end;
    if not IsLocal then Break;
    if SaveCount >= Length(SaveIdx) then SetLength(SaveIdx, SaveCount * 2);
    SaveIdx[SaveCount] := I;
    Inc(SaveCount);
    Inc(I);
  end;
  if SaveCount < 1 then Exit;

  { Phase 2: Count value-computing instructions (BINOPs, LOADKs, etc).
    These may write to either temps or directly to user-locals.
    In Lua 5.4+, skip SSA_NOP nodes (MMBIN/MMBINI/MMBINK hints). }
  MidCount := 0;
  while I <= High(Blk.Nodes) do begin
    N := Blk.Nodes[I];
    if N^.Kind = SSA_NOP then begin Inc(NopCount); Inc(I); Continue; end;
    if not (N^.Kind in [SSA_BINOP, SSA_LOADK, SSA_LOADBOOL]) then Break;
    if MidCount >= Length(MidIdx) then SetLength(MidIdx, MidCount * 2 + 4);
    MidIdx[MidCount] := I;
    Inc(MidCount);
    Inc(I);
  end;

  { Phase 3: Count write-back nodes:
    - MOVEs (dest = local via SSA binding, or PHI use)
    - GETTABLE (dest = local) - reads from table into a local
    - SETTABLE - writes to table (uses saved temps from Phase 1) }
  WriteCount := 0;
  while I <= High(Blk.Nodes) do begin
    N := Blk.Nodes[I];
    if N^.Kind = SSA_MOVE then begin
      IsLocal := NodeIsLocal(N) or
                 (CountPhiUses(N^.Dest.Reg, N^.Dest.Version) > 0);
      if not IsLocal then Break;
    end
    else if N^.Kind = SSA_GETTABLE then begin
      { GETTABLE write-back: dest is a user local }
      if not NodeIsLocal(N) then Break;
    end
    else if N^.Kind = SSA_SETTABLE then begin
      { SETTABLE write-back: always accepted (writes to table) }
    end
    else
      Break;
    if WriteCount >= Length(WriteIdx) then SetLength(WriteIdx, WriteCount * 2 + 4);
    WriteIdx[WriteCount] := I;
    Inc(WriteCount);
    Inc(I);
  end;

  Total := SaveCount + MidCount + WriteCount + NopCount;
  if (WriteCount < 1) or (SaveCount + MidCount + WriteCount < 3) then Exit;

  { Build LHS: write-back nodes in reverse + direct-to-local Phase 2 nodes.
    Build RHS: for each write-back (in reverse), extract the source expression.
    Write-back types:
      MOVE: LHS = dest local, RHS = ExprOf(source)
      GETTABLE: LHS = dest local, RHS = table[key] expression
      SETTABLE: LHS = table[key] expression, RHS = ExprOf(value) }
  LHS := '';
  { Write-back targets in reverse order (= original assignment order) }
  for J := WriteCount - 1 downto 0 do begin
    if LHS <> '' then LHS := LHS + ', ';
    N := Blk.Nodes[WriteIdx[J]];
    if N^.Kind = SSA_SETTABLE then begin
      { SETTABLE: LHS = table[key] }
      LHS := LHS + ExprOf(N^.OpA, N^.PC) + '[' + ExprOf(N^.OpB, N^.PC) + ']';
    end
    else begin
      { MOVE or GETTABLE: LHS = dest local name }
      if NodeIsEmittableLocal(N) then
        LHS := LHS + NodeLocalName(N)
      else
        LHS := LHS + TempName(N^.Dest.Reg);
    end;
  end;
  { Direct-to-local Phase 2 nodes appended at end - only those whose result goes
    directly to PHI (not consumed by a write-back in Phase 3). }
  for J := 0 to MidCount - 1 do begin
    N := Blk.Nodes[MidIdx[J]];
    { Check if any Phase 3 write-back uses this node's result as source }
    UsedByWriteBack := False;
    for K := 0 to WriteCount - 1 do begin
      WB := Blk.Nodes[WriteIdx[K]];
      if (WB^.Kind = SSA_MOVE) and
         (WB^.OpA.Reg = N^.Dest.Reg) and
         (WB^.OpA.Version = N^.Dest.Version) then begin
        UsedByWriteBack := True; Break;
      end;
      { Also check SETTABLE value operand }
      if (WB^.Kind = SSA_SETTABLE) and
         (WB^.OpC.Reg = N^.Dest.Reg) and
         (WB^.OpC.Version = N^.Dest.Version) then begin
        UsedByWriteBack := True; Break;
      end;
    end;
    if UsedByWriteBack then Continue; { temp - will be inlined in RHS }
    IsLocal := NodeIsLocal(N) or
               (CountPhiUses(N^.Dest.Reg, N^.Dest.Version) > 0);
    if IsLocal then begin
      if LHS <> '' then LHS := LHS + ', ';
      if NodeIsEmittableLocal(N) then
        LHS := LHS + NodeLocalName(N)
      else
        LHS := LHS + TempName(N^.Dest.Reg);
    end;
  end;

  { Build RHS: write-back sources (in reverse = original order) +
    direct-to-local Phase 2 expressions }
  RHS := '';
  for J := WriteCount - 1 downto 0 do begin
    if RHS <> '' then RHS := RHS + ', ';
    N := Blk.Nodes[WriteIdx[J]];
    if N^.Kind = SSA_SETTABLE then
      { SETTABLE: RHS = the value being stored }
      RHS := RHS + ExprOf(N^.OpC, N^.PC)
    else if N^.Kind = SSA_GETTABLE then
      { GETTABLE: RHS = table[key] }
      RHS := RHS + ExprOf(N^.OpA, N^.PC) + '[' + ExprOf(N^.OpB, N^.PC) + ']'
    else
      { MOVE: RHS = source expression }
      RHS := RHS + ExprOf(N^.OpA, N^.PC);
  end;
  for J := 0 to MidCount - 1 do begin
    N := Blk.Nodes[MidIdx[J]];
    { Skip temp nodes consumed by write-back nodes }
    UsedByWriteBack := False;
    for K := 0 to WriteCount - 1 do begin
      WB := Blk.Nodes[WriteIdx[K]];
      if (WB^.Kind = SSA_MOVE) and
         (WB^.OpA.Reg = N^.Dest.Reg) and
         (WB^.OpA.Version = N^.Dest.Version) then begin
        UsedByWriteBack := True; Break;
      end;
      if (WB^.Kind = SSA_SETTABLE) and
         (WB^.OpC.Reg = N^.Dest.Reg) and
         (WB^.OpC.Version = N^.Dest.Version) then begin
        UsedByWriteBack := True; Break;
      end;
    end;
    if UsedByWriteBack then Continue;
    IsLocal := NodeIsLocal(N) or
               (CountPhiUses(N^.Dest.Reg, N^.Dest.Version) > 0);
    if IsLocal then begin
      if RHS <> '' then RHS := RHS + ', ';
      RHS := RHS + NodeExpr(N);
    end;
  end;

  { Cache write-back names in FExprStr so ExprOf resolves them correctly.
    For SETTABLE write-backs, there's no Dest register to cache.
    For GETTABLE, cache the dest local name. }
  for J := 0 to WriteCount - 1 do begin
    N := Blk.Nodes[WriteIdx[J]];
    if N^.Kind = SSA_SETTABLE then Continue; { no dest register }
    I := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
    if (I >= 0) and (I < Length(FExprStr)) then begin
      if NodeIsEmittableLocal(N) then
        FExprStr[I] := NodeLocalName(N)
      else
        FExprStr[I] := TempName(N^.Dest.Reg);
    end;
  end;
  { Also cache save MOVEs to prevent them from being emitted separately }
  for J := 0 to SaveCount - 1 do begin
    N := Blk.Nodes[SaveIdx[J]];
    I := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
    if (I >= 0) and (I < Length(FExprStr)) then
      FExprStr[I] := '__swap_temp__';
  end;

  EmitLine(LHS + ' = ' + RHS);
  ConsumedCount := Total;
  Result := maEmitted;
end;

{ ======================================================================
  TryEmitTableSwap - detect table element swap patterns
  ====================================================================== }

function TDecompiler.TryEmitTableSwap(BIdx, StartIdx: Integer;
  out ConsumedCount: Integer): Boolean;
{ Detect table element swap:
    GETTABLE temp1 := table[key1]
    GETTABLE temp2 := table[key2]
    SETTABLE table[key1] = temp2
    SETTABLE table[key2] = temp1
  Emit as: table[key1], table[key2] = table[key2], table[key1] }
var
  Blk: TBasicBlock;
  G1, G2, S1, S2: PSSANode;
  TableExpr, Key1Expr, Key2Expr: AnsiString;
  LHS1, LHS2, RHS1, RHS2: AnsiString;
  KName: AnsiString;
begin
  Result := False;
  ConsumedCount := 0;
  Blk := FSF^.Blocks[BIdx];
  if StartIdx + 3 > High(Blk.Nodes) then Exit;

  G1 := Blk.Nodes[StartIdx];
  G2 := Blk.Nodes[StartIdx + 1];
  S1 := Blk.Nodes[StartIdx + 2];
  S2 := Blk.Nodes[StartIdx + 3];

  { All four must be the right kind }
  if G1^.Kind <> SSA_GETTABLE then Exit;
  if G2^.Kind <> SSA_GETTABLE then Exit;
  if S1^.Kind <> SSA_SETTABLE then Exit;
  if S2^.Kind <> SSA_SETTABLE then Exit;

  { All must reference the same table register }
  if G1^.OpA.Reg <> G2^.OpA.Reg then Exit;
  if G1^.OpA.Reg <> S1^.OpA.Reg then Exit;
  if G1^.OpA.Reg <> S2^.OpA.Reg then Exit;

  { Check cross pattern:
    S1 writes to key1 (= G1's key) with G2's value
    S2 writes to key2 (= G2's key) with G1's value }
  { S1's key should match G1's key (OpB) }
  if (S1^.OpB.Reg <> G1^.OpB.Reg) or (S1^.OpB.Version <> G1^.OpB.Version) then Exit;
  { S2's key should match G2's key (OpB) }
  if (S2^.OpB.Reg <> G2^.OpB.Reg) or (S2^.OpB.Version <> G2^.OpB.Version) then Exit;
  { S1's value should be G2's dest (temp2) }
  if (S1^.OpC.Reg <> G2^.Dest.Reg) or (S1^.OpC.Version <> G2^.Dest.Version) then Exit;
  { S2's value should be G1's dest (temp1) }
  if (S2^.OpC.Reg <> G1^.Dest.Reg) or (S2^.OpC.Version <> G1^.Dest.Version) then Exit;

  { Build expressions }
  TableExpr := ExprOf(G1^.OpA, G1^.PC);
  Key1Expr := ExprOf(G1^.OpB, G1^.PC);
  Key2Expr := ExprOf(G2^.OpB, G2^.PC);

  { Build LHS and RHS with dot notation for string keys }
  { LHS1 = table[key1] or table.key1 }
  if (Length(Key1Expr) >= 2) and (Key1Expr[1] = '"') then begin
    KName := Copy(Key1Expr, 2, Length(Key1Expr) - 2);
    if IsValidLuaIdent(KName) then
      LHS1 := TableExpr + '.' + KName
    else
      LHS1 := TableExpr + '[' + Key1Expr + ']';
  end else
    LHS1 := TableExpr + '[' + Key1Expr + ']';

  if (Length(Key2Expr) >= 2) and (Key2Expr[1] = '"') then begin
    KName := Copy(Key2Expr, 2, Length(Key2Expr) - 2);
    if IsValidLuaIdent(KName) then
      LHS2 := TableExpr + '.' + KName
    else
      LHS2 := TableExpr + '[' + Key2Expr + ']';
  end else
    LHS2 := TableExpr + '[' + Key2Expr + ']';

  { RHS is swapped: RHS1 = table[key2], RHS2 = table[key1] }
  RHS1 := LHS2;
  RHS2 := LHS1;

  EmitLine(LHS1 + ', ' + LHS2 + ' = ' + RHS1 + ', ' + RHS2);
  ConsumedCount := 4;
  Result := True;
end;

{ ======================================================================
  TryEmitTableConstructor - detect and emit inline table constructors
  ====================================================================== }

function TDecompiler.TryEmitTableConstructor(BIdx, StartIdx: Integer;
  out ConsumedCount: Integer): Boolean;
{ Detect NEWTABLE + constructor element sequences and emit them as inline
  table constructors:
    VARNAME = { val1, val2, ..., key1=v1, key2=v2 }

  Handles three patterns:
    A) NEWTABLE + LOADKs + SETTABLEs + SETLIST  (mixed or array-only)
    B) NEWTABLE + SETTABLEs only (hash-only, no SETLIST)
    C) NEWTABLE + inner NEWTABLEs (nested table constructors)
}
var
  Blk: TBasicBlock;
  N, NewTblNode, AssignNode: PSSANode;
  TableReg, TableVersion: Integer;
  I, J, ArrayCount, HashCount, SetListIdx, AssignIdx, EndIdx, LastSettableIdx, LastSettablePC: Integer;
  Ctor, Key, Val, LHS, KName, InnerCtor: AnsiString;
  Idx: Integer;
  FoundSetList, HasVararg, HasSelfRef, IsGlobalAssign, LHSFromMove, LHSFromLocVar, HasLaterWrite, Found: Boolean;
  InnerConsumed: Integer;
  FirstElem: Boolean;
  SubProto: PProto;
  LHSMoveReg, LHSMovePC: Integer;
  PseudoPC, CtorEndPC: Integer;
  ElemList: array of AnsiString;
  ElemCount: Integer;
  Pad: AnsiString;
  PrefixLen: Integer;
  BatchStarts: array of Integer;  { node indices of SETLIST instructions for this table }
  BatchCount, B, BatchElems, BatchLo, BatchHi, SlotOfs: Integer;
  InnerRegs: set of Byte;
  Changed: Boolean;
  CtorSrcLine: Integer;
  AllSameLine: Boolean;
  AuthNode: PSSANode;
begin
  Result := False;
  ConsumedCount := 0;
  Blk := FSF^.Blocks[BIdx];
  if StartIdx >= Length(Blk.Nodes) then Exit;

  NewTblNode := Blk.Nodes[StartIdx];
  if NewTblNode^.Kind <> SSA_NEWTABLE then Exit;

  TableReg := NewTblNode^.Dest.Reg;
  TableVersion := NewTblNode^.Dest.Version;

  { Scan forward for SETLIST(s) that reference this table register.
    When a table has >50 elements, the compiler emits multiple SETLIST
    instructions with increasing batch numbers (C=1, C=2, ...).
    We need the LAST SETLIST for this table to capture all elements.
    Allow inner NEWTABLEs (nested constructors) - skip over them. }
  FoundSetList := False;
  SetListIdx := -1;
  I := StartIdx + 1;
  while I <= High(Blk.Nodes) do begin
    N := Blk.Nodes[I];
    if (N^.Kind = SSA_SETLIST) and (N^.ImmA = TableReg) then begin
      FoundSetList := True;
      SetListIdx := I;
      { Don't break - continue scanning for additional SETLIST batches }
      Inc(I); Continue;
    end;
    { If we hit another NEWTABLE for the SAME register, the register is being
      redefined - any subsequent SETLIST belongs to that new NEWTABLE, not ours.
      Stop scanning. }
    if (N^.Kind = SSA_NEWTABLE) and (N^.Dest.Reg = TableReg) then Break;
    { If we hit a NEWTABLE for a DIFFERENT register that's an inner constructor:
      skip past its entire construction sequence (NEWTABLE+LOADKs+SETTABLEs+SETLIST).
      An inner NEWTABLE occupies registers above TableReg (array values). }
    if (N^.Kind = SSA_NEWTABLE) and (N^.Dest.Reg > TableReg) then begin
      { Skip inner constructor: find its matching SETLIST or end of SETTABLEs }
      Inc(I);
      while I <= High(Blk.Nodes) do begin
        if (Blk.Nodes[I]^.Kind = SSA_SETLIST) and
           (Blk.Nodes[I]^.ImmA = N^.Dest.Reg) then begin
          Inc(I); Break;
        end;
        { If we hit a SETTABLE on the OUTER table register, we've left the inner constructor }
        if (Blk.Nodes[I]^.Kind = SSA_SETTABLE) and
           (Blk.Nodes[I]^.OpA.Reg = TableReg) then Break;
        { If we hit a SETLIST for the OUTER table, done }
        if (Blk.Nodes[I]^.Kind = SSA_SETLIST) and
           (Blk.Nodes[I]^.ImmA = TableReg) then Break;
        Inc(I);
      end;
      Continue; { re-check current I }
    end;
    { If we hit any control flow or non-constructor node, stop.
      Exception: a CALL whose dest register is above the table register
      is part of the constructor (e.g. {f()} where CALL result fills the table). }
    if N^.Kind = SSA_CALL then begin
      if N^.Dest.Reg <= TableReg then Break;
      { CALL above table register - part of constructor, allow through }
      Inc(I);
      Continue;
    end;
    if N^.Kind in [SSA_BRANCH, SSA_JUMP, SSA_RETURN,
                   SSA_FORPREP, SSA_FORLOOP, SSA_TFORLOOP] then Break;
    Inc(I);
  end;

  { Determine the end of the constructor and count elements }
  if FoundSetList then
    EndIdx := SetListIdx
  else begin
    { No SETLIST: check for hash-only constructor (NEWTABLE + SETTABLEs).
      Self-references (value = table register) end the constructor.
      Skip NOP nodes (EXTRAARG in Lua 5.4+) between NEWTABLE and SETTABLEs.
      Only skip inner constructor nodes for registers that are actually used
      as VALUES in SETTABLEs for this table (InnerRegs). This prevents
      skipping sibling NEWTABLEs (CALL args) and consumer SETTABLEs. }

    { Pre-collect inner registers with transitive closure for nested constructors.
      An inner register is one that appears as a VALUE (OpC) in a SETTABLE for
      our table or for another inner register. }
    InnerRegs := [];
    Changed := True;
    while Changed do begin
      Changed := False;
      for J := StartIdx + 1 to High(Blk.Nodes) do begin
        N := Blk.Nodes[J];
        if (N^.Kind = SSA_SETTABLE) and
           (((N^.OpA.Reg = TableReg) and (N^.OpA.Version = TableVersion)) or
            (N^.OpA.Reg in InnerRegs)) and
           (N^.OpC.Reg >= 0) and (N^.OpC.Reg <> SSA_CONST_REG) and
           (N^.OpC.Reg <> TableReg) and
           (not (N^.OpC.Reg in InnerRegs)) then begin
          Include(InnerRegs, N^.OpC.Reg);
          Changed := True;
        end;
      end;
    end;

    HashCount := 0;
    LastSettableIdx := -1;
    LastSettablePC := NewTblNode^.PC;
    I := StartIdx + 1;
    while I <= High(Blk.Nodes) do begin
      N := Blk.Nodes[I];
      { Stop if too many instructions since last SETTABLE for this table.
        A constructor's value computations are within a few instructions of
        each SETTABLE.  A gap > 32 means the next SETTABLE is a separate
        assignment, not part of the constructor literal. }
      if (HashCount > 0) and (N^.PC > LastSettablePC + 32) then
        Break;
      if N^.Kind = SSA_NOP then begin
        Inc(I); Continue; { skip EXTRAARG / NOP padding }
      end;
      if (N^.Kind = SSA_SETTABLE) and (N^.OpA.Reg = TableReg) and
         (N^.OpA.Version = TableVersion) and (N^.OpC.Reg <> TableReg) then begin
        Inc(HashCount);
        LastSettableIdx := I;
        LastSettablePC := N^.PC;
      end
      else if (N^.Kind = SSA_NEWTABLE) and (N^.Dest.Reg in InnerRegs) then begin
        Inc(I); Continue; { skip inner NEWTABLE - nested constructor }
      end
      else if (N^.Kind = SSA_SETTABLE) and (N^.OpA.Reg in InnerRegs) then begin
        Inc(I); Continue; { skip SETTABLE for inner table - nested constructor }
      end
      else if (N^.Kind = SSA_SETLIST) and (N^.ImmA in InnerRegs) then begin
        Inc(I); Continue; { skip SETLIST for inner table - nested constructor }
      end
      else if (N^.Kind = SSA_LOADK) and (InnerRegs <> []) and (N^.Dest.Reg > TableReg) then begin
        Inc(I); Continue; { skip LOADKs for inner constructor array values }
      end
      { Allow value-loading nodes that compute SETTABLE operands.
        e.g., GETGLOBAL R1 before SETTABLE R0 K("print") R1.
        Only skip nodes that write to a register other than the table. }
      else if (N^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                           SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                           SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT,
                           SSA_CLOSURE, SSA_SELF]) and
              (N^.Dest.Reg <> TableReg) then begin
        if IsUpvalCaptured(N^.Dest.Reg, N^.PC) then Break;
        Inc(I); Continue;
      end
      { Allow value-producing CALLs (e.g. type(v) for a SETTABLE value) }
      else if (N^.Kind = SSA_CALL) and (N^.ImmC >= 2) and
              (N^.Dest.Reg <> TableReg) then begin
        if IsUpvalCaptured(N^.Dest.Reg, N^.PC) then Break;
        Inc(I); Continue;
      end
      else
        Break;
      Inc(I);
    end;
    if HashCount = 0 then Exit; { No elements - not a constructor pattern }
    { Set EndIdx to one past the last SETTABLE, not the scan position.
      This avoids consuming value-loading nodes after the last SETTABLE
      that belong to subsequent statements (e.g., a CALL argument setup). }
    if LastSettableIdx >= 0 then
      EndIdx := LastSettableIdx + 1
    else
      EndIdx := I;
    { Check if there are more SETTABLEs to this register NEARBY in the block
      (within a few instructions, suggesting an interleaved build pattern).
      If so, this is a table-building pattern, not a pure inline constructor.
      SETTABLEs far away are likely separate modifications, not part of the constructor. }
    J := EndIdx;
    while (J <= High(Blk.Nodes)) and (J - EndIdx < 8) do begin
      N := Blk.Nodes[J];
      if (N^.Kind = SSA_SETTABLE) and (N^.OpA.Reg = TableReg) and
         (N^.OpA.Version = TableVersion) then begin
        Exit; { More SETTABLEs follow - not a pure constructor }
      end;
      Inc(J);
    end;
  end;

  { Count array values and detect trailing VARARG. }
  ArrayCount := 0;
  HasVararg := False;
  I := StartIdx + 1;

  if FoundSetList then begin
    { Use SETLIST.ImmB to determine array element count.
      When multiple SETLIST batches exist (>50 elements), sum ImmB across
      all SETLIST instructions for this table register.
      This is robust even when elements involve multi-instruction computations
      (e.g. GETGLOBAL R6; GETGLOBAL R7; BINOP R6 := R6*R7; LOADK R7)
      where intermediate instructions reuse array-slot registers. }
    ArrayCount := 0;
    for J := StartIdx + 1 to SetListIdx do begin
      N := Blk.Nodes[J];
      if (N^.Kind = SSA_SETLIST) and (N^.ImmA = TableReg) then begin
        if N^.ImmB > 0 then
          ArrayCount := ArrayCount + N^.ImmB
        else begin
          { ImmB=0 means "up to top of stack" - count by scanning registers
            in this batch range. Find the previous SETLIST or start for range. }
          BatchLo := StartIdx + 1;
          for I := J - 1 downto StartIdx + 1 do begin
            if (Blk.Nodes[I]^.Kind = SSA_SETLIST) and (Blk.Nodes[I]^.ImmA = TableReg) then begin
              BatchLo := I + 1; Break;
            end;
          end;
          { Scan for max register offset in this batch + 1 for the CALL result }
          SlotOfs := 0;
          for I := BatchLo to J - 1 do begin
            if (Blk.Nodes[I]^.Dest.Reg > TableReg) and
               (Blk.Nodes[I]^.Dest.Reg - TableReg > SlotOfs) then
              SlotOfs := Blk.Nodes[I]^.Dest.Reg - TableReg;
          end;
          ArrayCount := ArrayCount + SlotOfs;
        end;
      end;
    end;
    if ArrayCount = 0 then begin
      { Fallback: all SETLISTs had ImmB=0. Count by scanning registers. }
      for J := StartIdx + 1 to SetListIdx - 1 do begin
        if (Blk.Nodes[J]^.Dest.Reg > TableReg) and
           (Blk.Nodes[J]^.Dest.Reg - TableReg > ArrayCount) then
          ArrayCount := Blk.Nodes[J]^.Dest.Reg - TableReg;
      end;
    end;
    { Check for trailing VARARG }
    for J := StartIdx + 1 to SetListIdx - 1 do begin
      if Blk.Nodes[J]^.Kind = SSA_VARARG then begin
        HasVararg := True; Break;
      end;
    end;
    { Advance I past all instructions up to SETLIST (consumed by constructor) }
    I := SetListIdx;
  end;

  { Count hash entries: SETTABLEs on the table register.
    Self-references (value = the table itself) end the constructor. }
  HashCount := 0;
  if FoundSetList then begin
    { Hash SETTABLEs appear between array value setup and SETLIST }
    for J := StartIdx + 1 to SetListIdx - 1 do begin
      N := Blk.Nodes[J];
      if (N^.Kind = SSA_SETTABLE) and (N^.OpA.Reg = TableReg) and
         (N^.OpC.Reg <> TableReg) then
        Inc(HashCount);
    end;
  end else begin
    { Hash-only: count SETTABLEs within the boundary already determined above.
      EndIdx was set by the boundary scan (with PC gap check), so we use it
      as the upper limit here to avoid re-absorbing nodes beyond the constructor. }
    for J := StartIdx + 1 to EndIdx - 1 do begin
      N := Blk.Nodes[J];
      if (N^.Kind = SSA_SETTABLE) and (N^.OpA.Reg = TableReg) and
         (N^.OpA.Version = TableVersion) and (N^.OpC.Reg <> TableReg) then
        Inc(HashCount);
    end;
  end;

  if (ArrayCount = 0) and (HashCount = 0) then Exit;

  { If closures inside the constructor capture the table being built, seed a
    stable name before decompiling those closure bodies.  Otherwise child
    upvalue resolution may fall back to an older literal loaded into the same
    register and later emit invalid field access such as "pkg.mod".field. }
  HasSelfRef := False;
  if FoundSetList then
    CtorEndPC := Blk.Nodes[SetListIdx]^.PC
  else if (EndIdx - 1 >= 0) and (EndIdx - 1 <= High(Blk.Nodes)) then
    CtorEndPC := Blk.Nodes[EndIdx - 1]^.PC
  else
    CtorEndPC := NewTblNode^.PC;
  for I := 0 to High(FSF^.AllNodes) do begin
    if (FSF^.AllNodes[I]^.Kind = SSA_CLOSURE) and
       (FSF^.AllNodes[I]^.PC > NewTblNode^.PC) and
       (FSF^.AllNodes[I]^.PC < CtorEndPC) then begin
      SubProto := nil;
      if (FSF^.AllNodes[I]^.ConstIdx >= 0) and
         (FSF^.AllNodes[I]^.ConstIdx < Length(FProto^.P)) then
        SubProto := FProto^.P[FSF^.AllNodes[I]^.ConstIdx];
      if SubProto <> nil then begin
        if FProto^.LuaVersion >= $52 then begin
          for J := 0 to SubProto^.NUps - 1 do begin
            if (J < Length(SubProto^.UpvalDescs)) and
               SubProto^.UpvalDescs[J].InStack and
               (SubProto^.UpvalDescs[J].Idx = TableReg) then begin
              HasSelfRef := True;
              Break;
            end;
          end;
        end else begin
          for J := 0 to SubProto^.NUps - 1 do begin
            PseudoPC := FSF^.AllNodes[I]^.PC + 1 + J;
            if (PseudoPC < Length(FProto^.Code)) and
               (GET_OPCODE(FProto^.Code[PseudoPC]) = OP_MOVE) and
               (GETARG_B(FProto^.Code[PseudoPC]) = TableReg) then begin
              HasSelfRef := True;
              Break;
            end;
          end;
        end;
      end;
      if HasSelfRef then Break;
    end;
  end;
  if HasSelfRef then begin
    Idx := NodeIdx(NewTblNode^.Dest.Reg, NewTblNode^.Dest.Version);
    if (Idx >= 0) and (Idx < Length(FExprStr)) then begin
      if NodeIsEmittableLocal(NewTblNode) then
        FExprStr[Idx] := NodeLocalName(NewTblNode)
      else
        FExprStr[Idx] := 'module_' + IntToStr(TableReg);
    end;
  end;

  { Collect constructor elements into ElemList }
  SetLength(ElemList, ArrayCount + HashCount);
  ElemCount := 0;

  { Array values - for SETLIST-based constructors, process each batch separately.
    When a table has >50 elements (LFIELDS_PER_FLUSH=50), the compiler emits
    multiple SETLIST instructions with increasing batch numbers (C=1,2,...).
    Registers TableReg+1..TableReg+B are REUSED across batches, so we must
    extract elements only from the range belonging to each batch. }
  if FoundSetList and (ArrayCount > 0) then begin
    { Collect all SETLIST indices for this table in order }
    SetLength(BatchStarts, 0);
    for I := StartIdx + 1 to SetListIdx do begin
      if (Blk.Nodes[I]^.Kind = SSA_SETLIST) and (Blk.Nodes[I]^.ImmA = TableReg) then begin
        SetLength(BatchStarts, Length(BatchStarts) + 1);
        BatchStarts[High(BatchStarts)] := I;
      end;
    end;
    BatchCount := Length(BatchStarts);

    { Process each batch }
    for B := 0 to BatchCount - 1 do begin
      { Determine the node range for this batch }
      if B = 0 then
        BatchLo := StartIdx + 1
      else
        BatchLo := BatchStarts[B - 1] + 1;
      BatchHi := BatchStarts[B] - 1;

      { Number of elements in this batch }
      BatchElems := Blk.Nodes[BatchStarts[B]]^.ImmB;
      if BatchElems = 0 then begin
        { ImmB=0 means "up to top of stack" - count by scanning registers }
        BatchElems := 0;
        for J := BatchLo to BatchHi do begin
          SlotOfs := Blk.Nodes[J]^.Dest.Reg - TableReg;
          if SlotOfs > BatchElems then
            BatchElems := SlotOfs;
        end;
      end;

      { Extract each element in this batch from registers TableReg+1..TableReg+BatchElems }
      for J := 1 to BatchElems do begin
        { Find the LAST node writing to TableReg + J within this batch's range }
        N := nil;
        for I := BatchHi downto BatchLo do begin
          if Blk.Nodes[I]^.Dest.Reg = TableReg + J then begin
            N := Blk.Nodes[I]; Break;
          end;
        end;
        if N = nil then begin
          ElemList[ElemCount] := 'nil';
        end
        else if N^.Kind = SSA_VARARG then
          ElemList[ElemCount] := '...'
        else if N^.Kind = SSA_NEWTABLE then begin
          { Nested table constructor }
          InnerCtor := '';
          for I := BatchLo to BatchHi do begin
            if Blk.Nodes[I] = N then begin
              if TryBuildInnerTableCtor(BIdx, I, InnerConsumed, InnerCtor) then
                ElemList[ElemCount] := InnerCtor
              else begin
                Idx := NodeIdx(N^.Dest.Reg, N^.Dest.Version);
                if (Idx >= 0) and (Idx < Length(FExprStr)) and (FExprStr[Idx] <> '') then
                  ElemList[ElemCount] := FExprStr[Idx]
                else
                  ElemList[ElemCount] := '{}';
              end;
              Break;
            end;
          end;
        end
        else
          ElemList[ElemCount] := NodeExpr(N);
        Inc(ElemCount);
      end;
    end;
    I := SetListIdx;
  end else if (not FoundSetList) and (ArrayCount > 0) then begin
    I := StartIdx + 1;
  end else begin
    I := StartIdx + 1;
  end;

  { Hash key-value pairs.
    When FoundSetList is true, hash SETTABLEs are INTERLEAVED with array
    value setup between StartIdx+1 and SetListIdx-1 (not after SETLIST).
    When FoundSetList is false, SETTABLEs follow directly after NEWTABLE. }
  if FoundSetList then begin
    { Scan the range [StartIdx+1 .. SetListIdx-1] for SETTABLEs on TableReg }
    for I := StartIdx + 1 to SetListIdx - 1 do begin
      N := Blk.Nodes[I];
      if (N^.Kind = SSA_SETTABLE) and (N^.OpA.Reg = TableReg) and
         (N^.OpC.Reg <> TableReg) then begin
        { Get key }
        if N^.OpB.Reg = SSA_CONST_REG then
          Key := ConstStr(N^.OpB.ConstIdx)
        else
          Key := ExprOf(N^.OpB, N^.PC);
        { Get value - check for inner NEWTABLE (nested constructor) }
        if N^.OpC.Reg = SSA_CONST_REG then
          Val := ConstStr(N^.OpC.ConstIdx)
        else begin
          Val := ExprOf(N^.OpC, N^.PC);
          { If value is a NEWTABLE register, build recursive inner constructor }
          if (N^.OpC.Reg >= 0) and (N^.OpC.Reg <> SSA_CONST_REG) then begin
            for Idx := StartIdx + 1 to SetListIdx - 1 do begin
              if (Blk.Nodes[Idx]^.Kind = SSA_NEWTABLE) and
                 (Blk.Nodes[Idx]^.Dest.Reg = N^.OpC.Reg) and
                 (Blk.Nodes[Idx]^.Dest.Version = N^.OpC.Version) then begin
                InnerCtor := '';
                if TryBuildInnerTableCtor(BIdx, Idx, InnerConsumed, InnerCtor) then
                  Val := InnerCtor;
                Break;
              end;
            end;
          end;
        end;
        { Format: for string keys use key=val, otherwise [key]=val }
        if (Length(Key) >= 2) and (Key[1] = '"') then begin
          KName := Copy(Key, 2, Length(Key) - 2);
          if IsValidLuaIdent(KName) then
            ElemList[ElemCount] := KName + ' = ' + Val
          else
            ElemList[ElemCount] := '[' + Key + '] = ' + Val;
        end else
          ElemList[ElemCount] := '[' + Key + '] = ' + Val;
        Inc(ElemCount);
      end;
    end;
  end else begin
    { Hash-only: SETTABLEs follow directly after NEWTABLE.
      Skip inner constructor nodes and value-loading nodes. }
    I := StartIdx + 1;
    for J := 0 to HashCount - 1 do begin
      { Skip NOP/EXTRAARG, inner constructor nodes, and value-loading nodes
        that compute SETTABLE operands (GETGLOBAL, LOADK, MOVE, etc.) }
      while (I <= High(Blk.Nodes)) and
            ((Blk.Nodes[I]^.Kind = SSA_NOP) or
             ((Blk.Nodes[I]^.Kind = SSA_NEWTABLE) and (Blk.Nodes[I]^.Dest.Reg in InnerRegs)) or
             ((Blk.Nodes[I]^.Kind = SSA_SETTABLE) and (Blk.Nodes[I]^.OpA.Reg in InnerRegs)) or
             ((Blk.Nodes[I]^.Kind = SSA_SETLIST) and (Blk.Nodes[I]^.ImmA in InnerRegs)) or
             ((Blk.Nodes[I]^.Kind = SSA_LOADK) and (InnerRegs <> []) and (Blk.Nodes[I]^.Dest.Reg > TableReg)) or
             ((Blk.Nodes[I]^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                                       SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                                       SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT,
                                       SSA_CLOSURE, SSA_SELF]) and
              (Blk.Nodes[I]^.Dest.Reg <> TableReg) and
              (not IsUpvalCaptured(Blk.Nodes[I]^.Dest.Reg, Blk.Nodes[I]^.PC))) or
             ((Blk.Nodes[I]^.Kind = SSA_CALL) and (Blk.Nodes[I]^.ImmC >= 2) and
              (Blk.Nodes[I]^.Dest.Reg <> TableReg) and
              (not IsUpvalCaptured(Blk.Nodes[I]^.Dest.Reg, Blk.Nodes[I]^.PC)))) do
        Inc(I);
      if I > High(Blk.Nodes) then Break;
      N := Blk.Nodes[I];
      { Get key }
      if N^.OpB.Reg = SSA_CONST_REG then
        Key := ConstStr(N^.OpB.ConstIdx)
      else
        Key := ExprOf(N^.OpB, N^.PC);
      { Get value - check for inner NEWTABLE (nested constructor) }
      if N^.OpC.Reg = SSA_CONST_REG then
        Val := ConstStr(N^.OpC.ConstIdx)
      else begin
        Val := ExprOf(N^.OpC, N^.PC);
        { If value is a NEWTABLE register, build recursive inner constructor }
        if (N^.OpC.Reg >= 0) and (N^.OpC.Reg <> SSA_CONST_REG) then begin
          for Idx := StartIdx + 1 to High(Blk.Nodes) do begin
            if (Blk.Nodes[Idx]^.Kind = SSA_NEWTABLE) and
               (Blk.Nodes[Idx]^.Dest.Reg = N^.OpC.Reg) and
               (Blk.Nodes[Idx]^.Dest.Version = N^.OpC.Version) then begin
              InnerCtor := '';
              if TryBuildInnerTableCtor(BIdx, Idx, InnerConsumed, InnerCtor) then
                Val := InnerCtor;
              Break;
            end;
          end;
        end;
      end;
      { Format: for string keys use key=val, otherwise [key]=val }
      if (Length(Key) >= 2) and (Key[1] = '"') then begin
        KName := Copy(Key, 2, Length(Key) - 2);
        if IsValidLuaIdent(KName) then
          ElemList[ElemCount] := KName + ' = ' + Val
        else
          ElemList[ElemCount] := '[' + Key + '] = ' + Val;
      end else
        ElemList[ElemCount] := '[' + Key + '] = ' + Val;
      Inc(ElemCount);
      Inc(I);
    end;
  end;

  { Build Ctor string - always single-line first (for inline optimization).
    After inline check, convert to multi-line for 2+ element emission.
    Multi-line format matches unluac: one element per line, aligned below
    the opening brace. }
  Ctor := '{';
  for J := 0 to ElemCount - 1 do begin
    if J > 0 then Ctor := Ctor + ', ';
    Ctor := Ctor + ElemList[J];
  end;
  Ctor := Ctor + '}';

  { Check if another node in the same block writes to this register later.
    If so, this NEWTABLE is a temp and we should not look ahead for LocVars -
    the later write owns the LocVar name. }
  HasLaterWrite := False;
  for I := StartIdx + 1 to High(Blk.Nodes) do begin
    if (Blk.Nodes[I]^.PC > NewTblNode^.PC) and
       (Blk.Nodes[I]^.Dest.Reg = TableReg) and
       (Blk.Nodes[I]^.Kind <> SSA_PHI) and
       (Blk.Nodes[I]^.Kind <> SSA_NOP) then begin
      HasLaterWrite := True; Break;
    end;
  end;

  { Determine consumed count and LHS assignment }
  IsGlobalAssign := False;
  LHSFromMove := False;
  LHSFromLocVar := False;
  LHSMoveReg := -1;
  LHSMovePC := -1;
  if FoundSetList then begin
    { Check for assignment after SETLIST }
    AssignIdx := SetListIdx + 1;
    AssignNode := nil;
    if AssignIdx <= High(Blk.Nodes) then
      AssignNode := Blk.Nodes[AssignIdx];

    LHS := '';
    if (AssignNode <> nil) and (AssignNode^.Kind = SSA_SETGLOBAL) and
       (AssignNode^.OpA.Reg = TableReg) then begin
      LHS := ConstStr(AssignNode^.ConstIdx);
      if (Length(LHS) >= 2) and (LHS[1] = '"') then
        LHS := Copy(LHS, 2, Length(LHS) - 2);
      ConsumedCount := (AssignIdx - StartIdx) + 1;
      IsGlobalAssign := True;
    end
    { Check for MOVE after SETLIST that copies table to a local
      (e.g. "a = {f()}" where NEWTABLE is on temp R1, then MOVE R0 := R1) }
    else if (AssignNode <> nil) and (AssignNode^.Kind = SSA_MOVE) and
            (AssignNode^.OpA.Reg = TableReg) and
            NodeIsLocal(AssignNode) then begin
      LHS := NodeLocalName(AssignNode);
      ConsumedCount := (AssignIdx - StartIdx) + 1;
      LHSFromMove := True;
      LHSMoveReg := AssignNode^.Dest.Reg;
      LHSMovePC := AssignNode^.PC;
    end else begin
      { SSA-based: check if NEWTABLE node has a LocVar binding }
      if NodeIsEmittableLocal(NewTblNode) then begin
        LHS := NodeLocalName(NewTblNode);
        LHSFromLocVar := True;
      end else
        LHS := 't' + IntToStr(TableReg);
      ConsumedCount := (SetListIdx - StartIdx) + 1;
    end;
  end else begin
    { Hash-only: consumed = all nodes from NEWTABLE through last SETTABLE
      (includes NOP/EXTRAARG padding in Lua 5.4+) }
    ConsumedCount := EndIdx - StartIdx;

    { Check for assignment after last SETTABLE }
    AssignIdx := StartIdx + ConsumedCount;
    AssignNode := nil;
    if AssignIdx <= High(Blk.Nodes) then
      AssignNode := Blk.Nodes[AssignIdx];

    LHS := '';
    if (AssignNode <> nil) and (AssignNode^.Kind = SSA_SETGLOBAL) and
       (AssignNode^.OpA.Reg = TableReg) then begin
      LHS := ConstStr(AssignNode^.ConstIdx);
      if (Length(LHS) >= 2) and (LHS[1] = '"') then
        LHS := Copy(LHS, 2, Length(LHS) - 2);
      Inc(ConsumedCount);
      IsGlobalAssign := True;
    end
    { Check for SETTABLE where the VALUE is our table register:
      e.g. parent["field"] = R50  ->  parent.field = { ... } }
    else if (AssignNode <> nil) and (AssignNode^.Kind = SSA_SETTABLE) and
            (AssignNode^.OpC.Reg = TableReg) and
            (AssignNode^.OpA.Reg <> TableReg) then begin
      LHS := ExprOf(AssignNode^.OpA, AssignNode^.PC) + '[' +
             ExprOf(AssignNode^.OpB, AssignNode^.PC) + ']';
      { Use dot notation for simple string keys }
      Key := ExprOf(AssignNode^.OpB, AssignNode^.PC);
      if (Length(Key) >= 2) and (Key[1] = '"') and (Key[Length(Key)] = '"') then begin
        KName := Copy(Key, 2, Length(Key) - 2);
        if IsValidLuaIdent(KName) then
          LHS := ExprOf(AssignNode^.OpA, AssignNode^.PC) + '.' + KName;
      end;
      Inc(ConsumedCount);
      IsGlobalAssign := True; { treat as non-local (no "local" prefix) }
    end
    { Check for SETUPVAL where the VALUE is our table register }
    else if (AssignNode <> nil) and (AssignNode^.Kind = SSA_SETUPVAL) and
            (AssignNode^.OpA.Reg = TableReg) then begin
      LHS := UpvalName(AssignNode^.UpvalIdx);
      Inc(ConsumedCount);
      IsGlobalAssign := True;
    end else begin
      { SSA-based: check if NEWTABLE node has a LocVar binding }
      if NodeIsEmittableLocal(NewTblNode) then begin
        LHS := NodeLocalName(NewTblNode);
        LHSFromLocVar := True;
      end else
        LHS := 't' + IntToStr(TableReg);
    end;
  end;

  { Cache the LHS variable name so ExprOf returns the variable name, not the
    constructor expression.  This is critical for cases where only a partial
    constructor is emitted (e.g., NEWTABLE + 1 SETTABLE folded, but more
    SETTABLEs follow after interleaved CALL nodes).  Without this, ExprOf
    would return "{ rank = t11 }" as the LHS for subsequent field assignments
    instead of the variable name "t15". }
  Idx := NodeIdx(NewTblNode^.Dest.Reg, NewTblNode^.Dest.Version);
  if (Idx >= 0) and (Idx < Length(FExprStr)) then
    FExprStr[Idx] := LHS;
  if HasSelfRef and (not IsGlobalAssign) and
     (not LHSFromMove) and (not LHSFromLocVar) and
     (not NodeIsEmittableLocal(NewTblNode)) then begin
    LHS := 'module_' + IntToStr(TableReg);
    if (Idx >= 0) and (Idx < Length(FExprStr)) then
      FExprStr[Idx] := LHS;
  end;

  { Inline optimization: if the table register is used exactly once OUTSIDE the
    constructor range, defer emission and store the constructor expression in
    FExprStr so the consuming instruction (CALL arg, RETURN, etc.) inlines it.
    SETTABLEs and SETLISTs inside the constructor are consumed by the builder
    and don't count. We count external uses of the register (same SSA version). }
  if (not HasSelfRef) and
     (not IsGlobalAssign) and (not LHSFromMove) and (not LHSFromLocVar) and
     (Length(LHS) >= 2) and (LHS[1] = 't') and
     (LHS[2] in ['0'..'9']) and
     (Pos(#1, Ctor) = 0) then begin
    { Count uses of R_ver outside the constructor range [StartIdx..StartIdx+ConsumedCount-1].
      Must check OpA/OpB/OpC, ArgRefs (CALL arguments), and Operands (PHI). }
    SlotOfs := 0;  { reuse as external use counter }
    for I := 0 to High(FSF^.AllNodes) do begin
      N := FSF^.AllNodes[I];
      { Skip the defining NEWTABLE itself }
      if N = NewTblNode then Continue;
      { Check if this node references our register version as an operand }
      Found := False;
      if ((N^.OpA.Reg = TableReg) and (N^.OpA.Version = TableVersion)) or
         ((N^.OpB.Reg = TableReg) and (N^.OpB.Version = TableVersion)) or
         ((N^.OpC.Reg = TableReg) and (N^.OpC.Version = TableVersion)) then
        Found := True;
      { Check CALL/TAILCALL ArgRefs }
      if (not Found) and (Length(N^.ArgRefs) > 0) then
        for J := 0 to High(N^.ArgRefs) do
          if (N^.ArgRefs[J].Reg = TableReg) and (N^.ArgRefs[J].Version = TableVersion) then begin
            Found := True; Break;
          end;
      { Check PHI Operands }
      if (not Found) and (Length(N^.Operands) > 0) then
        for J := 0 to High(N^.Operands) do
          if (N^.Operands[J].Reg = TableReg) and (N^.Operands[J].Version = TableVersion) then begin
            Found := True; Break;
          end;
      if Found then begin
        { Check if this node is inside the constructor range }
        J := -1;
        for B := 0 to High(Blk.Nodes) do begin
          if Blk.Nodes[B] = N then begin J := B; Break; end;
        end;
        if (J >= StartIdx) and (J < StartIdx + ConsumedCount) then
          Continue;  { inside constructor - doesn't count }
        Inc(SlotOfs);
      end;
    end;
    if SlotOfs = 1 then begin
      { Exactly one external use - inline the constructor }
      if (Idx >= 0) and (Idx < Length(FExprStr)) then
        FExprStr[Idx] := Ctor;
      Result := True;
      Exit;
    end;
  end;

  { Convert to multi-line for 2+ elements, UNLESS the source code had the
    entire constructor on one line (detected via LineInfo).
    #1 is a placeholder for aligned newline resolved at emission time. }
  AllSameLine := False;
  if (ElemCount >= 2) and (NewTblNode^.PC >= 0) and
     (NewTblNode^.PC < Length(FProto^.LineInfo)) then begin
    CtorSrcLine := FProto^.LineInfo[NewTblNode^.PC];
    AllSameLine := (CtorSrcLine > 0);
    { Check all consumed nodes are on the same source line }
    if AllSameLine then
      for J := StartIdx + 1 to StartIdx + ConsumedCount - 1 do begin
        if (J >= 0) and (J < Length(Blk.Nodes)) and
           (Blk.Nodes[J]^.PC >= 0) and
           (Blk.Nodes[J]^.PC < Length(FProto^.LineInfo)) then begin
          if FProto^.LineInfo[Blk.Nodes[J]^.PC] <> CtorSrcLine then begin
            AllSameLine := False;
            Break;
          end;
        end;
      end;
  end;
  if (ElemCount >= 2) and (not AllSameLine) then begin
    Ctor := '{';
    for J := 0 to ElemCount - 1 do begin
      if J > 0 then
        Ctor := Ctor + ',' + #1;
      Ctor := Ctor + ElemList[J];
    end;
    Ctor := Ctor + '}';
  end;

  { Emit the assignment.
    Special case: if closures inside the table constructor capture the table
    register as an upvalue (e.g., inBounce references t50.outBounce), we must
    split the declaration into "local LHS" + "LHS = {..}" so that 'LHS' is
    in scope (as a local, not a global) when those closures eventually run.
    In "local t50 = { ... closures ... }", t50 is NOT in scope during the
    table construction, so closures would reference a nil global. }
  { Determine the authority node for declaration decisions }
  if LHSFromMove then
    AuthNode := AssignNode    { the MOVE that copies table to local }
  else
    AuthNode := NewTblNode;   { the NEWTABLE itself }
  if (not IsGlobalAssign) and NodeIsEmittableLocal(AuthNode) and
     NodeNeedsDecl(AuthNode) then begin
    { Check if any CLOSURE INSIDE the constructor range captures this table register.
      Only CLOSUREs between NEWTABLE and the constructor end (SETLIST or last SETTABLE)
      are actual self-references. CLOSUREs after the constructor that capture the table
      are just normal upvalue bindings and don't need a forward-declare split. }
    HasSelfRef := False;
    if FoundSetList then
      CtorEndPC := Blk.Nodes[SetListIdx]^.PC
    else if (StartIdx + ConsumedCount - 1 >= 0) and
            (StartIdx + ConsumedCount - 1 <= High(Blk.Nodes)) then
      CtorEndPC := Blk.Nodes[StartIdx + ConsumedCount - 1]^.PC
    else
      CtorEndPC := NewTblNode^.PC;
    for I := 0 to High(FSF^.AllNodes) do begin
      if (FSF^.AllNodes[I]^.Kind = SSA_CLOSURE) and
         (FSF^.AllNodes[I]^.PC > NewTblNode^.PC) and
         (FSF^.AllNodes[I]^.PC < CtorEndPC) then begin
        { Check if any of its upvalue bindings reference TableReg }
        SubProto := nil;
        if (FSF^.AllNodes[I]^.ConstIdx >= 0) and
           (FSF^.AllNodes[I]^.ConstIdx < Length(FProto^.P)) then
          SubProto := FProto^.P[FSF^.AllNodes[I]^.ConstIdx];
        if SubProto <> nil then begin
          for J := 0 to SubProto^.NUps - 1 do begin
            PseudoPC := FSF^.AllNodes[I]^.PC + 1 + J;
            if (PseudoPC < Length(FProto^.Code)) and
               (GET_OPCODE(FProto^.Code[PseudoPC]) = OP_MOVE) and
               (GETARG_B(FProto^.Code[PseudoPC]) = TableReg) then begin
              HasSelfRef := True;
              Break;
            end;
          end;
        end;
        if HasSelfRef then Break;
      end;
    end;
    NodeMarkDeclared(AuthNode);
    if HasSelfRef then begin
      { Forward-declare: "local t50" then "t50 = ..." }
      { Resolve multi-line padding for "LHS = ..." prefix }
      PrefixLen := Length(LHS) + 4; { name + " = " + opening brace }
      Pad := StringOfChar(' ', FIndent * 2 + PrefixLen);
      Ctor := StringReplace(Ctor, #1, #10 + Pad, [rfReplaceAll]);
      EmitLine('local ' + LHS);
      EmitLine(LHS + ' = ' + Ctor);
    end else begin
      { Resolve multi-line padding for "local LHS = ..." prefix }
      PrefixLen := 6 + Length(LHS) + 4; { "local " + LHS + " = " + opening brace }
      Pad := StringOfChar(' ', FIndent * 2 + PrefixLen);
      Ctor := StringReplace(Ctor, #1, #10 + Pad, [rfReplaceAll]);
      EmitLine('local ' + LHS + ' = ' + Ctor);
    end;
  end else if (not IsGlobalAssign) and HasSelfRef and
              (not LHSFromMove) and (not LHSFromLocVar) then begin
    { Stripped bytecode may not have a source local for a returned module table,
      but closures in the constructor still need a lexical table name. }
    PrefixLen := Length(LHS) + 4; { name + " = " + opening brace }
    Pad := StringOfChar(' ', FIndent * 2 + PrefixLen);
    Ctor := StringReplace(Ctor, #1, #10 + Pad, [rfReplaceAll]);
    EmitLine('local ' + LHS);
    EmitLine(LHS + ' = ' + Ctor);
  end else begin
    { Resolve multi-line padding for "LHS = ..." prefix }
    PrefixLen := Length(LHS) + 4; { name + " = " + opening brace }
    Pad := StringOfChar(' ', FIndent * 2 + PrefixLen);
    Ctor := StringReplace(Ctor, #1, #10 + Pad, [rfReplaceAll]);
    EmitLine(LHS + ' = ' + Ctor);
  end;

  Result := True;
end;

{ ======================================================================
  TryBuildInnerTableCtor - build a nested table constructor string
  (does NOT emit; returns the constructor string in CtorStr)
  ====================================================================== }

function TDecompiler.TryBuildInnerTableCtor(BIdx, StartIdx: Integer;
  out ConsumedCount: Integer; out CtorStr: AnsiString): Boolean;
{ Builds a constructor expression for an inner (nested) table.
  Pattern: NEWTABLE Ra + LOADKs for array values + optional SETTABLEs + SETLIST }
var
  Blk: TBasicBlock;
  N, NewTblNode: PSSANode;
  InnerReg: Integer;
  I, J, ArrayCount, HashCount, SetListIdx, LastSettableIdx: Integer;
  Key, Val, KName, InnerCtor: AnsiString;
  FoundSetList: Boolean;
  Idx, InnerConsumed: Integer;
begin
  Result := False;
  ConsumedCount := 1;
  CtorStr := '{}';
  Blk := FSF^.Blocks[BIdx];
  if StartIdx >= Length(Blk.Nodes) then Exit;

  NewTblNode := Blk.Nodes[StartIdx];
  if NewTblNode^.Kind <> SSA_NEWTABLE then Exit;
  InnerReg := NewTblNode^.Dest.Reg;
  LastSettableIdx := -1;

  { Find SETLIST for this inner table }
  FoundSetList := False;
  SetListIdx := -1;
  for I := StartIdx + 1 to High(Blk.Nodes) do begin
    N := Blk.Nodes[I];
    if (N^.Kind = SSA_SETLIST) and (N^.ImmA = InnerReg) then begin
      FoundSetList := True;
      SetListIdx := I;
      Break;
    end;
    { Stop at control flow or other constructors for higher registers }
    if N^.Kind in [SSA_BRANCH, SSA_JUMP, SSA_RETURN, SSA_CALL] then Break;
  end;

  { Count array values - skip NOP/EXTRAARG nodes (Lua 5.4+ inserts
    EXTRAARG after NEWTABLE). Use SETLIST.ImmB for element count when
    available (robust against multi-instruction element patterns). }
  ArrayCount := 0;
  I := StartIdx + 1;
  if FoundSetList then begin
    { Use SETLIST.ImmB for reliable array count }
    N := Blk.Nodes[SetListIdx];
    if N^.ImmB > 0 then
      ArrayCount := N^.ImmB
    else begin
      { ImmB=0: count by scanning registers }
      for J := StartIdx + 1 to SetListIdx - 1 do begin
        if (Blk.Nodes[J]^.Dest.Reg > InnerReg) and
           (Blk.Nodes[J]^.Dest.Reg - InnerReg > ArrayCount) then
          ArrayCount := Blk.Nodes[J]^.Dest.Reg - InnerReg;
      end;
    end;
    I := SetListIdx; { advance past array values }
  end;

  { Count hash entries }
  HashCount := 0;
  if FoundSetList then begin
    { Hash SETTABLEs interleaved between StartIdx+1 and SetListIdx-1 }
    for J := StartIdx + 1 to SetListIdx - 1 do begin
      N := Blk.Nodes[J];
      if (N^.Kind = SSA_SETTABLE) and (N^.OpA.Reg = InnerReg) then
        Inc(HashCount);
    end;
  end else begin
    { Hash-only inner table - skip NOP nodes, inner constructor sequences, and
      value-producing nodes that feed SETTABLE operands. }
    I := StartIdx + 1;
    LastSettableIdx := -1;
    while I <= High(Blk.Nodes) do begin
      N := Blk.Nodes[I];
      if N^.Kind = SSA_NOP then begin Inc(I); Continue; end;
      if (N^.Kind = SSA_SETTABLE) and (N^.OpA.Reg = InnerReg) then begin
        Inc(HashCount);
        LastSettableIdx := I;
      end
      else if (N^.Kind = SSA_NEWTABLE) and (N^.Dest.Reg <> InnerReg) then begin
        Inc(I); Continue; { skip inner NEWTABLE - nested constructor }
      end
      else if (N^.Kind = SSA_SETTABLE) and (N^.OpA.Reg <> InnerReg) then begin
        Inc(I); Continue; { skip SETTABLE for deeper inner table }
      end
      else if (N^.Kind = SSA_SETLIST) and (N^.ImmA <> InnerReg) then begin
        Inc(I); Continue; { skip SETLIST for deeper inner table }
      end
      else if (N^.Kind = SSA_LOADK) and (N^.Dest.Reg > InnerReg) then begin
        Inc(I); Continue; { skip LOADKs for inner constructor array values }
      end
      else if (N^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                            SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                            SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT,
                            SSA_CLOSURE, SSA_SELF]) and
              (N^.Dest.Reg <> InnerReg) then begin
        Inc(I); Continue; { skip SETTABLE value/key setup }
      end
      else if (N^.Kind = SSA_CALL) and (N^.ImmC >= 2) and
              (N^.Dest.Reg <> InnerReg) then begin
        Inc(I); Continue; { skip single-return value CALL }
      end
      else
        Break;
      Inc(I);
    end;
  end;

  if (ArrayCount = 0) and (HashCount = 0) then Exit;

  { Build constructor string }
  CtorStr := '{';

  { Array values - find the LAST node writing to each array register
    (InnerReg+1 .. InnerReg+ArrayCount) before SETLIST.
    This handles NOP/EXTRAARG nodes and multi-instruction patterns. }
  if FoundSetList then begin
    for J := 1 to ArrayCount do begin
      if J > 1 then CtorStr := CtorStr + ', ';
      N := nil;
      for I := SetListIdx - 1 downto StartIdx + 1 do begin
        if Blk.Nodes[I]^.Dest.Reg = InnerReg + J then begin
          N := Blk.Nodes[I]; Break;
        end;
      end;
      if N = nil then
        CtorStr := CtorStr + 'nil'
      else if N^.Kind = SSA_LOADK then
        CtorStr := CtorStr + ConstStr(N^.ConstIdx)
      else if N^.Kind = SSA_LOADBOOL then begin
        if N^.ImmA <> 0 then CtorStr := CtorStr + 'true'
        else CtorStr := CtorStr + 'false';
      end
      else
        CtorStr := CtorStr + NodeExpr(N);
    end;
  end else begin
    { No SETLIST - array values from StartIdx+1, skip NOPs }
    I := StartIdx + 1;
    for J := 0 to ArrayCount - 1 do begin
      while (I <= High(Blk.Nodes)) and (Blk.Nodes[I]^.Kind = SSA_NOP) do
        Inc(I);
      if J > 0 then CtorStr := CtorStr + ', ';
      N := Blk.Nodes[I];
      if N^.Kind = SSA_LOADK then
        CtorStr := CtorStr + ConstStr(N^.ConstIdx)
      else if N^.Kind = SSA_LOADBOOL then begin
        if N^.ImmA <> 0 then CtorStr := CtorStr + 'true'
        else CtorStr := CtorStr + 'false';
      end
      else
        CtorStr := CtorStr + 'nil';
      Inc(I);
    end;
  end;

  { Hash key-value pairs }
  if FoundSetList then begin
    { Scan [StartIdx+1 .. SetListIdx-1] for SETTABLEs on InnerReg }
    for I := StartIdx + 1 to SetListIdx - 1 do begin
      N := Blk.Nodes[I];
      if (N^.Kind = SSA_SETTABLE) and (N^.OpA.Reg = InnerReg) then begin
        if Length(CtorStr) > 1 then
          CtorStr := CtorStr + ', ';
        if N^.OpB.Reg = SSA_CONST_REG then
          Key := ConstStr(N^.OpB.ConstIdx)
        else
          Key := ExprOf(N^.OpB, N^.PC);
        { Get value - check for inner NEWTABLE (nested constructor) }
        if N^.OpC.Reg = SSA_CONST_REG then
          Val := ConstStr(N^.OpC.ConstIdx)
        else begin
          Val := ExprOf(N^.OpC, N^.PC);
          if (N^.OpC.Reg >= 0) and (N^.OpC.Reg <> SSA_CONST_REG) then begin
            for Idx := StartIdx + 1 to SetListIdx - 1 do begin
              if (Blk.Nodes[Idx]^.Kind = SSA_NEWTABLE) and
                 (Blk.Nodes[Idx]^.Dest.Reg = N^.OpC.Reg) and
                 (Blk.Nodes[Idx]^.Dest.Version = N^.OpC.Version) then begin
                InnerCtor := '';
                if TryBuildInnerTableCtor(BIdx, Idx, InnerConsumed, InnerCtor) then
                  Val := InnerCtor;
                Break;
              end;
            end;
          end;
        end;
        if (Length(Key) >= 2) and (Key[1] = '"') then begin
          KName := Copy(Key, 2, Length(Key) - 2);
          if IsValidLuaIdent(KName) then
            CtorStr := CtorStr + KName + ' = ' + Val
          else
            CtorStr := CtorStr + '[' + Key + '] = ' + Val;
        end else
          CtorStr := CtorStr + '[' + Key + '] = ' + Val;
      end;
    end;
  end else begin
    { Hash-only: SETTABLEs follow directly after NEWTABLE.
      Skip inner constructor nodes (NEWTABLE/SETTABLE/SETLIST for other regs, LOADKs above InnerReg). }
    I := StartIdx + 1;
    for J := 0 to HashCount - 1 do begin
      { Skip NOP/EXTRAARG, inner NEWTABLEs, SETTABLEs for other regs, inner
        SETLISTs, inner LOADKs, and value-producing nodes for SETTABLEs. }
      while (I <= High(Blk.Nodes)) and
            ((Blk.Nodes[I]^.Kind = SSA_NOP) or
             ((Blk.Nodes[I]^.Kind = SSA_NEWTABLE) and (Blk.Nodes[I]^.Dest.Reg <> InnerReg)) or
             ((Blk.Nodes[I]^.Kind = SSA_SETTABLE) and (Blk.Nodes[I]^.OpA.Reg <> InnerReg)) or
             ((Blk.Nodes[I]^.Kind = SSA_SETLIST) and (Blk.Nodes[I]^.ImmA <> InnerReg)) or
             ((Blk.Nodes[I]^.Kind = SSA_LOADK) and (Blk.Nodes[I]^.Dest.Reg > InnerReg)) or
             ((Blk.Nodes[I]^.Kind in [SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
                                       SSA_GETGLOBAL, SSA_GETTABLE, SSA_GETUPVAL,
                                       SSA_MOVE, SSA_BINOP, SSA_UNOP, SSA_CONCAT,
                                       SSA_CLOSURE, SSA_SELF]) and
              (Blk.Nodes[I]^.Dest.Reg <> InnerReg)) or
             ((Blk.Nodes[I]^.Kind = SSA_CALL) and (Blk.Nodes[I]^.ImmC >= 2) and
              (Blk.Nodes[I]^.Dest.Reg <> InnerReg))) do
        Inc(I);
      if I > High(Blk.Nodes) then Break;
      if (J > 0) or (ArrayCount > 0) then CtorStr := CtorStr + ', ';
      N := Blk.Nodes[I];
      if N^.OpB.Reg = SSA_CONST_REG then
        Key := ConstStr(N^.OpB.ConstIdx)
      else
        Key := ExprOf(N^.OpB, N^.PC);
      { Get value - check for inner NEWTABLE (nested constructor) }
      if N^.OpC.Reg = SSA_CONST_REG then
        Val := ConstStr(N^.OpC.ConstIdx)
      else begin
        Val := ExprOf(N^.OpC, N^.PC);
        if (N^.OpC.Reg >= 0) and (N^.OpC.Reg <> SSA_CONST_REG) then begin
          for Idx := StartIdx + 1 to High(Blk.Nodes) do begin
            if (Blk.Nodes[Idx]^.Kind = SSA_NEWTABLE) and
               (Blk.Nodes[Idx]^.Dest.Reg = N^.OpC.Reg) and
               (Blk.Nodes[Idx]^.Dest.Version = N^.OpC.Version) then begin
              InnerCtor := '';
              if TryBuildInnerTableCtor(BIdx, Idx, InnerConsumed, InnerCtor) then
                Val := InnerCtor;
              Break;
            end;
          end;
        end;
      end;
      if (Length(Key) >= 2) and (Key[1] = '"') then begin
        KName := Copy(Key, 2, Length(Key) - 2);
        if IsValidLuaIdent(KName) then
          CtorStr := CtorStr + KName + ' = ' + Val
        else
          CtorStr := CtorStr + '[' + Key + '] = ' + Val;
      end else
        CtorStr := CtorStr + '[' + Key + '] = ' + Val;
      Inc(I);
    end;
  end;

  CtorStr := CtorStr + '}';

  { Cache the inner constructor expression }
  Idx := NodeIdx(NewTblNode^.Dest.Reg, NewTblNode^.Dest.Version);
  if (Idx >= 0) and (Idx < Length(FExprStr)) then
    FExprStr[Idx] := CtorStr;

  { Consumed count: NEWTABLE + array values + hash entries + optional SETLIST }
  if FoundSetList then
    ConsumedCount := (SetListIdx - StartIdx) + 1
  else if LastSettableIdx >= StartIdx then
    ConsumedCount := (LastSettableIdx - StartIdx) + 1
  else
    ConsumedCount := 1 + ArrayCount + HashCount;

  Result := True;
end;

{ ======================================================================
  EmitTempLoweredMultiAssign - fallback for multi-assign groups where
  direct parallel assignment isn't safe (alias/side-effect risk).
  Emits:
    local _t1, _t2, ... = rhs1, rhs2, ...
    local? lhs1 = _t1
    local? lhs2 = _t2
    ...
  For table-access LHS (e.g., t[k]), never emits 'local'.
  ====================================================================== }
procedure TDecompiler.EmitTempLoweredMultiAssign(
  const LHSNames: array of AnsiString;
  const RHSExprs: array of AnsiString;
  const LHSNeedsLocalDecl: array of Boolean;
  const LHSIsTableAccess: array of Boolean);
var
  I, N: Integer;
  TempNames, TempRHS, Line: AnsiString;
begin
  N := Length(LHSNames);
  if N = 0 then Exit;

  { Step 1: Capture all RHS into temporaries }
  TempNames := '';
  TempRHS := '';
  for I := 0 to N - 1 do begin
    if TempNames <> '' then TempNames := TempNames + ', ';
    TempNames := TempNames + '_t' + IntToStr(I + 1);
    if I <= High(RHSExprs) then begin
      if TempRHS <> '' then TempRHS := TempRHS + ', ';
      TempRHS := TempRHS + RHSExprs[I];
    end;
  end;
  EmitLine('local ' + TempNames + ' = ' + TempRHS);

  { Step 2: Assign temps to final targets }
  for I := 0 to N - 1 do begin
    Line := '';
    if LHSNeedsLocalDecl[I] and not LHSIsTableAccess[I] then
      Line := 'local ';
    Line := Line + LHSNames[I] + ' = _t' + IntToStr(I + 1);
    EmitLine(Line);
  end;
end;

{ ======================================================================
  MultiAssignNeedsTemps - determine whether a multi-assign group needs
  temp-lowered emission due to LHS-RHS aliasing or side effects.

  Parameters:
    Blk: the basic block containing the group
    ComputeStart..ComputeEnd: node indices in Blk^.Nodes for RHS value defs
    WriteBackStart..WriteBackEnd: node indices for LHS write-back (MOVE/SETTABLE)

  Returns True if temp-lowered emission is required.

  Detection rules (conservative - any doubt --> True):
    1. SSA_CALL in compute window --> True (potential side effects)
    2. RHSReadSet ∩ LHSWriteSet ≠ ∅ --> True (LHS-RHS aliasing)
    3. RHSReadSet ∩ AddressReadSet ≠ ∅ --> True (SETTABLE address aliasing)
    4. GETTABLE/SETTABLE in both compute AND write-back --> True (metamethod risk)
    5. Cannot reliably compute sets --> True (conservative default)
  ====================================================================== }
function TDecompiler.MultiAssignNeedsTemps(Blk: PBasicBlock;
  ComputeStart, ComputeEnd: Integer;
  WriteBackStart, WriteBackEnd: Integer): Boolean;
var
  I, J, R: Integer;
  Node: PSSANode;
  { Bit sets for register tracking (up to 256 registers) }
  RHSReadSet: array[0..255] of Boolean;    { registers read by compute phase }
  LHSWriteSet: array[0..255] of Boolean;   { registers written by write-back MOVEs }
  AddrReadSet: array[0..255] of Boolean;   { registers read by SETTABLE addresses }
  HasTableInCompute, HasTableInWriteBack: Boolean;

  procedure AddToRHSRead(Reg: Integer);
  begin
    if (Reg >= 0) and (Reg <= 255) then RHSReadSet[Reg] := True;
  end;

begin
  Result := False;

  { Initialize sets }
  for I := 0 to 255 do begin
    RHSReadSet[I] := False;
    LHSWriteSet[I] := False;
    AddrReadSet[I] := False;
  end;
  HasTableInCompute := False;
  HasTableInWriteBack := False;

  { Pass 1: Collect RHS read set from compute window }
  for I := ComputeStart to ComputeEnd do begin
    if (I < 0) or (I > High(Blk^.Nodes)) then begin Result := True; Exit; end;
    Node := Blk^.Nodes[I];
    case Node^.Kind of
      SSA_NOP, SSA_LOADK, SSA_LOADBOOL, SSA_LOADNIL,
      SSA_GETGLOBAL, SSA_GETUPVAL, SSA_VARARG, SSA_NEWTABLE:
        ; { no register reads (or reads from non-register sources) }
      SSA_MOVE:
        AddToRHSRead(Node^.OpA.Reg);
      SSA_GETTABLE: begin
        AddToRHSRead(Node^.OpA.Reg);
        AddToRHSRead(Node^.OpB.Reg);  { key - skip if RK constant (Reg < 0) }
        HasTableInCompute := True;
      end;
      SSA_BINOP: begin
        AddToRHSRead(Node^.OpA.Reg);
        AddToRHSRead(Node^.OpB.Reg);
      end;
      SSA_UNOP:
        AddToRHSRead(Node^.OpA.Reg);
      SSA_CONCAT: begin
        AddToRHSRead(Node^.OpA.Reg);
        AddToRHSRead(Node^.OpB.Reg);
      end;
      SSA_SELF: begin
        AddToRHSRead(Node^.OpA.Reg);
        AddToRHSRead(Node^.OpB.Reg);
      end;
      SSA_CALL: begin
        { Rule 1: CALL in compute window --> needs temps (side effects) }
        Result := True; Exit;
      end;
      SSA_PHI: begin
        for J := 0 to High(Node^.Operands) do
          AddToRHSRead(Node^.Operands[J].Reg);
      end;
    else
      { Unknown node kind in compute window --> conservative }
      Result := True; Exit;
    end;
  end;

  { Pass 2: Collect LHS write set and address read set from write-back window }
  for I := WriteBackStart to WriteBackEnd do begin
    if (I < 0) or (I > High(Blk^.Nodes)) then begin Result := True; Exit; end;
    Node := Blk^.Nodes[I];
    case Node^.Kind of
      SSA_MOVE:
        if (Node^.Dest.Reg >= 0) and (Node^.Dest.Reg <= 255) then
          LHSWriteSet[Node^.Dest.Reg] := True;
      SSA_SETTABLE: begin
        HasTableInWriteBack := True;
        { Collect table and key registers as address reads }
        R := Node^.OpA.Reg;
        if (R >= 0) and (R <= 255) then AddrReadSet[R] := True;
        R := Node^.OpB.Reg;
        if (R >= 0) and (R <= 255) then AddrReadSet[R] := True;
      end;
      SSA_GETTABLE: begin
        { GETTABLE in write-back: dest is LHS target }
        if (Node^.Dest.Reg >= 0) and (Node^.Dest.Reg <= 255) then
          LHSWriteSet[Node^.Dest.Reg] := True;
        HasTableInWriteBack := True;
      end;
      SSA_NOP:
        ; { skip }
    else
      { Unknown node in write-back --> conservative }
      Result := True; Exit;
    end;
  end;

  { Rule 2: Check RHSReadSet ∩ LHSWriteSet }
  for I := 0 to 255 do
    if RHSReadSet[I] and LHSWriteSet[I] then begin
      Result := True; Exit;
    end;

  { Rule 3: Check RHSReadSet ∩ AddressReadSet }
  for I := 0 to 255 do
    if RHSReadSet[I] and AddrReadSet[I] then begin
      Result := True; Exit;
    end;

  { Rule 4: Metamethod risk - table ops in both windows }
  if HasTableInCompute and HasTableInWriteBack then begin
    Result := True; Exit;
  end;
end;