axx.py

#!/usr/bin/env python3
# cython: language_level=3

"""
axx general assembler designed and programmed by Taisuke Maekawa
Refactored with OOP design for improved maintainability
"""

from decimal import Decimal, getcontext
try:
    import readline  # GNU readline (Unix/macOS only; not available on Windows)
except ImportError:
    pass  # Gracefully degrade on Windows or environments without readline
import string
import subprocess
import itertools
import struct
import sys
import os
import math
import re
import tempfile

# Pass1 リラクゼーションの初期比較用番兵オブジェクト。
# モジュールレベルで1度だけ生成することで、run() を複数回呼び出しても
# 同一オブジェクトとの `is not` 比較が常に正しく機能する。
_RELAXATION_SENTINEL = object()


# Expression mode constants
EXP_PAT = 0
EXP_ASM = 1
# exp_typ は後方互換のため残存するが、実際には AssemblerState.exp_typ を使用する。
# このグローバルは参照されなくなった（修正1対応）。
exp_typ = 'i'  # deprecated – do not use directly

# Special bracket characters
OB = chr(0x90)  # open double bracket
CB = chr(0x91)  # close double bracket

# Constants
UNDEF = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
VAR_UNDEF = 0

# Character sets
CAPITAL = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
LOWER = "abcdefghijklmnopqrstuvwxyz"
DIGIT = '0123456789'
XDIGIT = "0123456789ABCDEF"
ALPHABET = LOWER + CAPITAL

# Error messages
ERRORS = [
    "",
    "Invalid syntax.",
    "Address out of range.",
    "Value out of range.",
    "",
    "Register out of range.",
    "Port number out of range."
]


class AssemblerState:
    """Global state container for the assembler"""
    
    def __init__(self):
        # File paths
        self.outfile = ""
        self.expfile = ""
        self.expfile_elf = ""
        self.impfile = ""
        
        # Program counter and padding
        self.pc = 0
        self.padding = 0
        # pc_instr_start: binary_list中の$$が命令先頭アドレスを指すように、
        # makeobj呼び出し前にself.state.pcの値を保存する。
        self.pc_instr_start = 0
        # _in_binary_list: makeobj実行中はTrue。$$がpc_instr_startを
        # 返すのはbinary_list評価中のみ。.equなど他のコンテキストでは
        # $$=現在のPC (self.state.pc) を返す。
        self._in_binary_list = False
        
        # Character sets for parsing
        self.lwordchars = DIGIT + ALPHABET + "_."
        self.swordchars = DIGIT + ALPHABET + "_%$-~&|"
        
        # Current context
        self.current_section = ".text"
        self.current_file = ""
        
        # Data structures
        self.labels = {}
        self.sections = {}
        self.symbols = {}
        self.patsymbols = {}
        self.export_labels = {}
        self.pat = []
        
        # VLIW configuration
        self.vliwinstbits = 41
        self.vliwnop = []
        self.vliwbits = 128
        self.vliwset = []
        self.vliwflag = False
        self.vliwtemplatebits = 0x00
        self.vliwstop = 0
        self.vcnt = 1
        
        # Expression mode and errors
        self.expmode = EXP_PAT
        self.error_undefined_label = False
        self.error_label_conflict = False
        
        # Assembly configuration
        self.align = 16
        self.bts = 8
        self.endian = 'little'
        self.byte = 'yes'
        self.pas = 0
        self.debug = False
        
        # Current line info
        self.cl = ""
        self.ln = 0
        self.fnstack = []
        self.lnstack = []
        
        # Variables (a-z)
        self.vars = [VAR_UNDEF for i in range(26)]
        
        # Debug strings
        self.deb1 = ""
        self.deb2 = ""
        
        # Expression type mode: 'i' = integer, 'f' = float.
        # スレッドセーフかつ再入安全にするため、モジュールレベルのグローバルではなく
        # インスタンス変数として保持する。変更箇所では必ず try/finally で元に戻す。
        self.exp_typ: str = 'i'

        # Pass 1 size-estimation mode:
        # True の間は未定義ラベルを UNDEF ではなく 0 として返す。
        # forward参照があっても makeobj がサイズを正しく計算できるようにするため。
        self._pass1_size_mode = False

        # リラクゼーション用: 直前のpass1でのラベルアドレス記録
        # {label_name: pc_value} の辞書。収束判定に使う。
        # モジュールレベルの番兵で初期化することで run() 複数回呼び出しも安全。
        self._pass1_prev_label_pcs = _RELAXATION_SENTINEL

        # 標準出力へのリスト出力: True のときのみ lineassemble0 がリストを stdout に出力する。
        # False（デフォルト）のときはエラー/警告のみ表示し、バイナリ出力は通常通り行う。
        self.verbose: bool = False

        # stdin 入力を保持する一時ファイルパス。
        # 固定名 "axx.tmp" の代わりに tempfile で生成したパスを使うことで
        # 複数インスタンスの同時実行時の競合を防ぐ。
        # None のとき未生成。run() 終了後に cleanup される。
        self.stdin_tmp_path: str | None = None

        # ELF OSABI (FreeBSD==9,Linux==0)
        self.osabi: int = 9 # default OSABI==9(FreeBSD)
        # ELF relocatable object file output (-r / -m options)
        self.elf_objfile: str = ""
        self.elf_machine: int = 62   # default EM_X86_64

        # ELF relocation tracking
        # relocations: list of (section_name, sec_rel_byte_offset, sym_name, reloc_type, addend)
        self.relocations = []
        # _elf_tracking: True while assembling an instruction during pass2 ELF output
        self._elf_tracking = False

        # _elf_label_refs_seen: リロケーション候補。各エントリ: (label_name, abs_value, word_idx)
        # word_idx は makeobj() 内で参照が発生した objl インデックス（0 以上）。
        self._elf_label_refs_seen = []  # [(label_name, abs_word_value, word_idx)]

        # makeobj() が現在生成中のワードインデックス（objl への追加前の len(objl)）。
        # -1 は makeobj() の外（センチネル値）。
        self._elf_current_word_idx: int = -1

        # _elf_var_to_label: match() で !x がラベルを直接キャプチャしたとき
        # 変数名 → (label_name, label_value) を記録する辞書。
        # makeobj() 内で変数を読む際にリロケーション情報の生成に使う。
        # ラベル値そのものではなく式（label+offset等）でキャプチャした場合は
        # この辞書には登録しない（_elf_capturing_var が None に戻る前に複数の
        # get_value() 呼び出しが起きたケースは登録を取り消す）。
        self._elf_var_to_label: dict = {}  # {var_letter: (label_name, label_value)}

        # _elf_capturing_var: match() が !x 式を評価している最中にセットされる変数名。
        # get_value() はこれを見て _elf_var_to_label を更新する。
        # None のとき「キャプチャ中でない」。
        self._elf_capturing_var: str | None = None


class StringUtils:
    """Utility functions for string manipulation"""
    
    @staticmethod
    def upper(s):
        """Convert string to uppercase"""
        return ''.join(c.upper() if c in LOWER else c for c in s)
    
    @staticmethod
    def q(s, t, idx):
        """Quick comparison of substring"""
        return StringUtils.upper(s[idx:idx+len(t)]) == StringUtils.upper(t)
    
    @staticmethod
    def skipspc(s, idx):
        """Skip spaces and tabs in string"""
        while idx < len(s) and s[idx] in ' \t':
            idx += 1
        return idx
    
    @staticmethod
    def skip_squote_literal(s, i):
        """シングルクォートリテラルを先読みで消費する共通ヘルパー。

        Fix 5 (DRY): remove_comment_asm と vcnt カウントループに同一ロジックが
        重複していた。どちらもこのメソッドを呼び出すことで一元管理する。

        消費できた場合は消費後の idx を返す。
        消費できなかった（孤立クォート）場合は i+1 を返す（クォート自体を読み飛ばす）。
        消費したかどうかは (戻り値 > i + 1) で判定できる。

        対応パターン:
          '\\xNN'  ← 16進エスケープ (0〜2桁)
          '\\x'    ← 4文字エスケープ (backslash + char + closeq)
          'x'      ← 通常3文字リテラル
        """
        j = i + 1
        if j < len(s) and s[j] == '\\' and j + 1 < len(s):
            esc_char = s[j + 1]
            if esc_char in 'xX':
                k = j + 2
                hex_digits = 0
                while k < len(s) and s[k] in '0123456789abcdefABCDEF' and hex_digits < 2:
                    k += 1
                    hex_digits += 1
                if k < len(s) and s[k] == '\'':
                    return k + 1          # '\xNN' 消費成功
                # 閉じクォートが見つからない → 孤立クォート
            elif j + 2 < len(s) and s[j + 2] == '\'':
                return j + 3              # '\x' 4文字消費成功
            # 対応クローズクォートなし → 孤立クォート
        elif j < len(s) and j + 1 < len(s) and s[j + 1] == '\'':
            return j + 2                  # 'x' 3文字消費成功
        # 孤立クォート: クォート文字そのものだけ読み飛ばす
        return i + 1
    
    @staticmethod
    def reduce_spaces(text):
        """Reduce multiple spaces to single space"""
        return re.sub(r'\s{2,}', ' ', text)
    
    @staticmethod
    def remove_comment(l):
        """Remove /* style comments"""
        idx = 0
        while idx < len(l):
            if l[idx:idx+2] == '/*':
                return "" if idx == 0 else l[0:idx]
            idx += 1
        return l
    
    @staticmethod
    def remove_comment_asm(l):
        """Remove ; style comments, but preserve semicolons inside string literals.

        エスケープされた引用符 \\" は文字列の開始・終了とみなさない。
        これにより "hello \\"world\\"; not a comment" のような入力で
        誤ってコメント開始位置がずれる問題を修正。

        Fix ⑦: 旧実装のシングルクォートトグル方式では、'a'b'c' のような
        連続する文字リテラルが並ぶ入力で in_squote フラグが誤って残留し、
        後続のセミコロンがコメント開始とみなされない問題があった。

        修正後: トグル方式を廃止し、先読みペア確認方式を採用する。
        シングルクォートを見つけたら:
          - '\\x' 形式（エスケープ付き4文字）: 丸ごと消費してスキップ
          - 'x'   形式（通常3文字）         : 丸ごと消費してスキップ
          - 対応するクローズクォートが見つからない孤立クォート: そのまま通過
        これにより 'a'b'c';comment のような入力でも正しくセミコロンを検出できる。
        """
        in_dquote = False
        i = 0
        while i < len(l):
            ch = l[i]

            # ダブルクォート文字列内のエスケープ処理
            if ch == '\\' and in_dquote:
                if i + 1 < len(l):
                    i += 2
                else:
                    i += 1  # 末尾の孤立したバックスラッシュ
                continue

            if ch == '"':
                # Fix ①: 開き・閉じ両方でトグルする。
                # 旧実装は `not in_dquote` 条件のため開きクォートしか処理せず、
                # 閉じダブルクォートが来ても in_dquote が True のまま固着していた。
                # バックスラッシュエスケープ (\") は上の if ブロックで消費済みなので
                # ここでは素直にトグルするだけで正しい。
                in_dquote = not in_dquote
            elif ch == '\'' and not in_dquote:
                # Fix 5 (DRY): 共通ヘルパーでシングルクォートリテラルを消費する。
                i = StringUtils.skip_squote_literal(l, i)
                continue
            elif ch == ';' and not in_dquote:
                return l[:i].rstrip()

            i += 1
        # Fix 4: ループを抜けた時点で in_dquote=True なら未終端ダブルクォート文字列。
        # 行内のセミコロンはコメントとして扱われていないため出力に残る。
        # Fix 7 (new): 警告を stdout ではなく stderr に出力する。
        # バイナリ出力をパイプで受け取っている場合に stdout が汚染されないようにする。
        if in_dquote:
            print(f" warning - unterminated string literal in line: {l!r}", file=sys.stderr)
        return l.rstrip()
    
    @staticmethod
    def get_param_to_spc(s, idx):
        """Get parameter up to space"""
        t = ""
        idx = StringUtils.skipspc(s, idx)
        while idx < len(s) and s[idx] != ' ':
            t += s[idx]
            idx += 1
        return t, idx
    
    @staticmethod
    def get_param_to_eon(s, idx):
        """Get parameter to end of line or !!"""
        t = ""
        idx = StringUtils.skipspc(s, idx)
        while idx < len(s) and s[idx:idx+2] != '!!':
            t += s[idx]
            idx += 1
        return t, idx
    
    @staticmethod
    def get_string(l2):
        """Get quoted string with proper escape sequence handling"""
        idx = 0
        idx = StringUtils.skipspc(l2, idx)
        if l2 == '' or idx >= len(l2) or l2[idx] != '"':
            return ""
        idx += 1
        s = ""
        while idx < len(l2):
            if l2[idx] == '\\' and idx + 1 < len(l2):
                # エスケープシーケンスを処理
                next_char = l2[idx + 1]
                if next_char == '"':
                    s += '"'
                    idx += 2
                elif next_char == '\\':
                    s += '\\'
                    idx += 2
                elif next_char == 'n':
                    s += '\n'
                    idx += 2
                elif next_char == 't':
                    s += '\t'
                    idx += 2
                elif next_char == 'r':
                    s += '\r'
                    idx += 2
                elif next_char in 'xX':
                    # Fix: \xNN 形式の16進エスケープ（asciistr と同様の処理）
                    idx += 2
                    hex_str = ''
                    while idx < len(l2) and l2[idx] in '0123456789abcdefABCDEF' and len(hex_str) < 2:
                        hex_str += l2[idx]
                        idx += 1
                    # Fix 9: 3桁以上の16進数字が続く場合、余剰桁はそのまま文字列として
                    # 出力されるためユーザーが気づきにくい。警告を出す。
                    if idx < len(l2) and l2[idx] in '0123456789abcdefABCDEF':
                        print(f" warning - '\\x' escape takes at most 2 hex digits; "
                              f"extra digit(s) treated as literal characters in: {l2!r}")
                    if hex_str:
                        s += chr(int(hex_str, 16))
                    else:
                        # \x の後に16進数字がない場合はそのまま保持
                        s += 'x'
                else:
                    # その他のエスケープはそのまま保持
                    s += next_char
                    idx += 2
            elif l2[idx] == '"':
                return s
            else:
                s += l2[idx]
                idx += 1
        # 末尾まで達したが閉じ引用符がなかった
        # Fix 7 (new): 警告を stderr に出力する（stdout 汚染防止）。
        print(f" warning - unterminated string literal: {l2!r}", file=sys.stderr)
        return s


class Parser:
    """Parser for extracting tokens and strings from assembly code"""
    
    def __init__(self, state):
        self.state = state
    
    def get_intstr(self, s, idx):
        """Get integer string from position"""
        fs = ''
        while idx < len(s) and s[idx] in DIGIT:
            fs += s[idx]
            idx += 1
        return fs, idx
    
    def get_floatstr(self, s, idx):
        """Get float string from position.

        Fix 11: 単項マイナスは factor() が先に処理するため、
        factor1() から呼ばれる get_floatstr() で先頭の '-' を
        再度消費すると二重解釈になる。
        '-inf' だけは特別扱いとして残す（単項マイナス + inf では
        factor() の負号処理と組み合わせると正しく動くが、
        '-inf' という単一トークンとして見た方が自然で、
        既存の使用箇所すべてでその前提で動いている）。
        それ以外の数値先頭 '-' は消費しない。
        """
        if s[idx:idx+4] == '-inf':
            return '-inf', idx + 4
        elif s[idx:idx+3] == 'inf':
            return 'inf', idx + 3
        elif s[idx:idx+3] == 'nan':
            return 'nan', idx + 3
        else:
            fs = ''
            # Fix 11: 先頭の '-' は factor() の単項マイナス処理が担うため
            # ここでは消費しない（二重解釈を防ぐ）。
            while idx < len(s) and s[idx] in "0123456789.":
                fs += s[idx]
                idx += 1
            # Accept exponent part: e/E followed by optional sign and digits.
            # 修正: 指数部の数字が続かない場合（'1e', '1e+' など）は
            # 指数部をなかったことにして idx を巻き戻す。
            # そのまま float('1e') を呼ぶと ValueError になるため。
            if idx < len(s) and s[idx] in "eE":
                saved_idx = idx
                saved_fs  = fs
                fs += s[idx]
                idx += 1
                if idx < len(s) and s[idx] in "+-":
                    fs += s[idx]
                    idx += 1
                digits_start = idx
                while idx < len(s) and s[idx] in "0123456789":
                    fs += s[idx]
                    idx += 1
                if idx == digits_start:
                    # 数字がひとつもなかった → 指数部を破棄して巻き戻す
                    fs  = saved_fs
                    idx = saved_idx
            return fs, idx

    def isfloatstr(self,s,idx):
        sidx=idx
        v,idx = self.get_floatstr(s,idx)
        if idx==sidx:
            return False
        else:
            return True

    def get_curlb(self, s, idx):
        """Get curly bracket content.

        修正③: 閉じブレース '}' が見つからないまま文字列末尾に達した場合は
        f=False を返してエラーを呼び出し元に知らせる。旧実装は f=True のまま
        不完全な内容 t を返し、壊れた式がサイレントに評価されていた。
        """
        idx = StringUtils.skipspc(s, idx)
        f = False
        t = ''

        if idx < len(s) and s[idx] == '{':
            idx += 1
            idx = StringUtils.skipspc(s, idx)
            start_idx = idx
            while idx < len(s) and s[idx] != '}':
                t += s[idx]
                idx += 1
            if idx >= len(s):
                # 閉じブレースが見つからなかった
                print(f" error - missing closing '}}' in expression: '{{{t}'")
                # Fix ④修正: 旧実装は start_idx（'{' 内部）を返していたため、
                # 呼び出し元パーサーが '{' の中身を後続の式として誤解析していた。
                # len(s) を返してパースを強制終了させる。
                return False, '', len(s)
            # '}' を消費
            idx += 1
            f = True

        return f, t, idx

    def get_symbol_word(self, s, idx):
        """Get symbol word from position"""
        t = ""
        if idx < len(s) and s[idx] not in DIGIT and s[idx] in self.state.swordchars:
            t = s[idx]
            idx += 1
            while idx < len(s) and s[idx] in self.state.swordchars:
                t += s[idx]
                idx += 1
        return StringUtils.upper(t), idx
    
    def get_label_word(self, s, idx):
        """Get label word from position.

        A trailing ':' is consumed as part of the label definition only when
        it is NOT immediately followed by '=' (which would form ':=' – an
        assignment operator rather than a label terminator).

        ラベル名は大文字・小文字を区別する（case-sensitive）。
        「foo:」と定義した場合、「FOO」では参照できない。
        """
        t = ""
        if idx < len(s) and (s[idx] == '.' or (s[idx] not in DIGIT and s[idx] in self.state.lwordchars)):
            t = s[idx]
            idx += 1
            while idx < len(s) and s[idx] in self.state.lwordchars:
                t += s[idx]
                idx += 1

            # Consume ':' only when it is a label terminator, not part of ':='
            if idx < len(s) and s[idx] == ':' and (idx + 1 >= len(s) or s[idx + 1] != '='):
                idx += 1

        return t, idx
    
    def get_params1(self, l, idx):
        """Get parameters separated by ::"""
        idx = StringUtils.skipspc(l, idx)
        
        if idx >= len(l):
            return "", idx
        
        s = ""
        while idx < len(l):
            if l[idx:idx+2] == '::':
                idx += 2
                break
            else:
                s += l[idx]
                idx += 1
        return s.rstrip(' \t'), idx

def enfloat(a):
    # Fix: a が 0〜2^32-1 の範囲外のとき struct.pack('I', a) は struct.error になる。
    # 呼び出し元でマスクしているが念のため二重ガードする。
    try:
        float_value = struct.unpack('f', struct.pack('I', int(a) & 0xFFFFFFFF))[0]
    except (struct.error, OverflowError, ValueError):
        float_value = 0.0
    return float_value

def endouble(a):
    # Fix: a が 0〜2^64-1 の範囲外のとき struct.pack('Q', a) は struct.error になる。
    try:
        double_value = struct.unpack('d', struct.pack('Q', int(a) & 0xFFFFFFFFFFFFFFFF))[0]
    except (struct.error, OverflowError, ValueError):
        double_value = 0.0
    return double_value

# enflt / endbl は enfloat / endouble の別名。
# factor1() および xeval() の safe_env から参照されるが、
# これまで定義が存在せず NameError でクラッシュしていた。
enflt = enfloat
endbl = endouble

class IEEE754Converter:
    """IEEE 754 floating point conversion utilities"""
    
    @staticmethod
    def decimal_to_ieee754_32bit_hex(a):
        """Convert decimal to IEEE 754 32-bit hex.

        Uses Python's struct module for the actual bit conversion so that
        the result is identical to what the hardware would produce.  The
        Decimal-based path was previously incorrect because Decimal.adjusted()
        returns a *decimal* (base-10) exponent, not a binary (base-2) one,
        which produced wrong bit patterns for most non-power-of-10 values.
        """
        if a == 'inf':
            return "0x7F800000"
        elif a == '-inf':
            return "0xFF800000"
        elif a == 'nan':
            return "0x7FC00000"

        # Fix 1: 不正な文字列（"0x10", "1+2" 等）は Decimal() が
        # decimal.InvalidOperation を送出する。ValueError に統一して呼び出し元で捕捉できるようにする。
        try:
            fval = float(Decimal(a))
        except Exception as _e:
            raise ValueError(f"decimal_to_ieee754_32bit_hex: invalid input {a!r}") from _e
        try:
            bits = struct.unpack('I', struct.pack('f', fval))[0]
        except (struct.error, OverflowError) as _e:
            raise ValueError(f"decimal_to_ieee754_32bit_hex: cannot pack {fval!r}") from _e
        return f"0x{bits:08X}"
    
    @staticmethod
    def decimal_to_ieee754_64bit_hex(a):
        """Convert decimal to IEEE 754 64-bit hex.

        Uses struct for correctness (same reason as the 32-bit variant).
        """
        if a == 'inf':
            return "0x7FF0000000000000"
        elif a == '-inf':
            return "0xFFF0000000000000"
        elif a == 'nan':
            return "0x7FF8000000000000"

        # Fix 1: 不正な文字列は Decimal() が decimal.InvalidOperation を送出する。
        # ValueError に統一して呼び出し元で捕捉できるようにする。
        try:
            fval = float(Decimal(a))
        except Exception as _e:
            raise ValueError(f"decimal_to_ieee754_64bit_hex: invalid input {a!r}") from _e
        try:
            bits = struct.unpack('Q', struct.pack('d', fval))[0]
        except (struct.error, OverflowError) as _e:
            raise ValueError(f"decimal_to_ieee754_64bit_hex: cannot pack {fval!r}") from _e
        return f"0x{bits:016X}"
    
    @staticmethod
    def decimal_to_ieee754_128bit_hex(a):
        """Convert decimal to IEEE 754 128-bit (binary128 / quad) hex.

        Python's struct does not support binary128, so we implement the
        conversion with the Decimal module at high precision.
        The binary exponent is found by integer bit-length of the scaled
        integer approximation, which avoids any float-precision loss.
        Precision is set to 60 digits to cover the 112-bit significand
        (~34 significant decimal digits) with rounding headroom.
        """
        BIAS = 16383
        SIGNIFICAND_BITS = 112
        EXPONENT_BITS = 15

        getcontext().prec = 60  # 112ビット仮数部(約34桁)を十分カバー

        if a == 'inf':
            a = 'Infinity'
        elif a == '-inf':
            a = '-Infinity'
        elif a == 'nan':
            a = 'NaN'
        d = Decimal(a)

        if d.is_nan():
            sign = 0
            exponent = (1 << EXPONENT_BITS) - 1
            fraction = 1 << (SIGNIFICAND_BITS - 1)
        elif d == Decimal('Infinity'):
            sign = 0
            exponent = (1 << EXPONENT_BITS) - 1
            fraction = 0
        elif d == Decimal('-Infinity'):
            sign = 1
            exponent = (1 << EXPONENT_BITS) - 1
            fraction = 0
        elif d == 0:
            sign = 0
            exponent = 0
            fraction = 0
        else:
            sign = 0 if d >= 0 else 1
            d = abs(d)

            two = Decimal(2)

            # 2進指数を純粋なDecimal演算で求める:
            #   d に 2^SIGNIFICAND_BITS を掛けて整数化し、
            #   そのbit長から指数を逆算する。float変換は一切使わない。
            scaled = int(d * (two ** SIGNIFICAND_BITS))
            if scaled == 0:
                exp_unbiased = -(BIAS - 1)
            else:
                # bit_length() - 1 = floor(log2(scaled))
                exp_unbiased = scaled.bit_length() - 1 - SIGNIFICAND_BITS

            scale = two ** exp_unbiased
            normalized = d / scale

            # 念のため境界を確認・微調整
            while normalized >= 2:
                exp_unbiased += 1
                normalized /= 2
            while normalized < 1:
                exp_unbiased -= 1
                normalized *= 2

            biased_exp = exp_unbiased + BIAS

            # Fix: 非常に大きな数値（例: Decimal('1e100000')）は biased_exp が
            # 最大指数 (1<<EXPONENT_BITS)-1 を超えて Infinity になる。
            # 最大有限指数を超えた場合は +Infinity として扱う。
            _MAX_EXP = (1 << EXPONENT_BITS) - 1
            if biased_exp >= _MAX_EXP:
                # Overflow → Infinity
                sign_bit = sign
                exponent = _MAX_EXP
                fraction = 0
                bits = (sign_bit << 127) | (exponent << SIGNIFICAND_BITS) | fraction
                return f"0x{bits:032X}"

            if biased_exp <= 0:
                # サブノーマル数
                exponent = 0
                shift = two ** (1 - BIAS - SIGNIFICAND_BITS)
                fraction = int(d / shift + Decimal('0.5'))
            else:
                exponent = biased_exp
                # 仮数部ビット（最近接丸め）
                fraction = int((normalized - 1) * (two ** SIGNIFICAND_BITS) + Decimal('0.5'))

            fraction &= (1 << SIGNIFICAND_BITS) - 1

        bits = (sign << 127) | (exponent << SIGNIFICAND_BITS) | fraction
        return f"0x{bits:032X}"

    @staticmethod
    def decimal_eval_expr(text):
        """四則演算式を Decimal で評価して binary128 の整数ビットパターンを返す。

        対応文法:
            expr   = term   (('+' | '-') term)*
            term   = factor (('*' | '/') factor)*
            factor = '(' expr ')' | ['-'] number
            number = decimal リテラル (Decimal で解析)

        シンボル・ラベルを含む式（Decimal で解析できない場合）は
        ValueError を送出する。呼び出し側は except して
        float モードのフォールバックに切り替える。
        """
        getcontext().prec = 60
        text = text.strip()

        def skip(s, i):
            while i < len(s) and s[i] in ' \t':
                i += 1
            return i

        def parse_number(s, i):
            i = skip(s, i)
            neg = False
            if i < len(s) and s[i] == '-':
                neg = True
                i += 1
                i = skip(s, i)
            # Fix Q: 'inf' / 'nan' を Decimal で正しく処理する。
            # 旧実装は '0123456789.' 以外を即 ValueError にしていたため
            # qad{inf} / qad{-inf} が xeval フォールバックに落ち、
            # そこで float(inf) → int() が OverflowError になっていた。
            for kw, dval in (('inf', Decimal('Infinity')), ('nan', Decimal('NaN'))):
                if s[i:i+len(kw)] == kw:
                    v = -dval if neg else dval
                    return v, i + len(kw)
            # 符号のみは数値ではない
            if i >= len(s) or s[i] not in '0123456789.':
                raise ValueError(f"expected number at {i!r}")
            start = i
            while i < len(s) and s[i] in '0123456789.':
                i += 1
            if i < len(s) and s[i] in 'eE':
                i += 1
                if i < len(s) and s[i] in '+-':
                    i += 1
                while i < len(s) and s[i] in '0123456789':
                    i += 1
            try:
                v = Decimal(s[start:i])
            except Exception as _e:
                # Fix ⑨修正: Decimal() は decimal.InvalidOperation を送出することがあり、
                # 呼び出し側の except (ValueError, ZeroDivisionError) では補足されず
                # 伝播してしまう。すべての変換失敗を ValueError に統一する。
                raise ValueError(f"invalid decimal literal: {s[start:i]!r}") from _e
            return (-v if neg else v), i

        def parse_factor(s, i):
            i = skip(s, i)
            if i < len(s) and s[i] == '(':
                # Fix 2 (修正): '(' ブランチも深いネストで RecursionError が発生する。
                # '-' / '+' ブランチは Fix 1 で修正済みだったが、括弧ブランチは未対処だった。
                try:
                    v, i = parse_expr(s, i + 1)
                except RecursionError:
                    raise ValueError("decimal_eval_expr: expression nesting too deep")
                i = skip(s, i)
                if i < len(s) and s[i] == ')':
                    i += 1
                return v, i
            if i < len(s) and s[i] == '-':
                # Fix 1: 深いネストで RecursionError が発生する可能性がある。
                # ValueError に変換して呼び出し元の except で捕捉できるようにする。
                try:
                    v, i = parse_factor(s, i + 1)
                except RecursionError:
                    raise ValueError("decimal_eval_expr: expression nesting too deep")
                return -v, i
            if i < len(s) and s[i] == '+':
                try:
                    return parse_factor(s, i + 1)
                except RecursionError:
                    raise ValueError("decimal_eval_expr: expression nesting too deep")
            return parse_number(s, i)

        def parse_term(s, i):
            v, i = parse_factor(s, i)
            while True:
                i = skip(s, i)
                if i < len(s) and s[i] == '*':
                    t, i = parse_factor(s, i + 1)
                    v *= t
                elif i + 1 < len(s) and s[i] == '/' and s[i+1] == '/':
                    # '//' → floor division（'/' の前に判定する）
                    t, i = parse_factor(s, i + 2)
                    if t == 0:
                        raise ZeroDivisionError("floor division by zero in qad{}")
                    v = Decimal(int(v // t))
                elif i < len(s) and s[i] == '/' and (i + 1 >= len(s) or s[i+1] != '/'):
                    t, i = parse_factor(s, i + 1)
                    if t == 0:
                        raise ZeroDivisionError("division by zero in qad{}")
                    v /= t
                elif i < len(s) and s[i] == '%':
                    # Fix: '%' (modulo) が未実装だったため qad{N%M} が ValueError を
                    # 送出し float フォールバックで 128bit 精度が失われていた。
                    t, i = parse_factor(s, i + 1)
                    if t == 0:
                        raise ZeroDivisionError("modulo by zero in qad{}")
                    v = Decimal(int(v) % int(t))
                else:
                    break
            return v, i

        def parse_expr(s, i):
            v, i = parse_term(s, i)
            while True:
                i = skip(s, i)
                if i < len(s) and s[i] == '+':
                    t, i = parse_term(s, i + 1)
                    v += t
                elif i < len(s) and s[i] == '-':
                    t, i = parse_term(s, i + 1)
                    v -= t
                else:
                    break
            return v, i

        val, _ = parse_expr(text, 0)
        # Decimal を文字列に変換して binary128 に変換
        return IEEE754Converter.decimal_to_ieee754_128bit_hex(str(val))


class VariableManager:
    """Manages assembler variables (a-z)"""
    
    def __init__(self, state):
        self.state = state
    
    def get(self, s):
        """Get variable value by letter"""
        c = ord(StringUtils.upper(s))
        return self.state.vars[c - ord('A')]
    
    def put(self, s, v):
        """Set variable value by letter"""
        if StringUtils.upper(s) in CAPITAL:
            c = ord(StringUtils.upper(s))
            # 【バグ修正⑦】旧実装は常に int(v) で切り捨てていた。
            # !F / !D 経由の値は match() 側で既に IEEE754 整数ビットパターンに
            # 変換されてから渡されるので int() で問題ない。
            # しかし exp_typ='f' モードで a:=3.14 のように生の float が渡された
            # 場合は int(3.14)==3 となり精度が失われる。
            # 修正: Decimal 型も適切に処理する。小数部を持つ値はそのまま保持し、
            # 整数値のみ int に変換する。
            if isinstance(v, Decimal):
                # Fix ⑭ (新規): Decimal('Infinity') / Decimal('NaN') は
                # to_integral_value() が OverflowError / InvalidOperation を
                # 投げ、旧実装の except Exception でそのまま int(v) が再試行
                # されるが int(Decimal('Infinity')) も OverflowError になる。
                # 結果として vars に壊れた値が書き込まれるか、別の例外が伝播した。
                # 修正: 有限値かどうかを先に確認し、非有限は float として保持する。
                if not v.is_finite():
                    self.state.vars[c - ord('A')] = float(v)
                elif v == v.to_integral_value():
                    self.state.vars[c - ord('A')] = int(v)
                else:
                    self.state.vars[c - ord('A')] = float(v)
            elif isinstance(v, float) and not v.is_integer():
                self.state.vars[c - ord('A')] = v
            else:
                # Fix: float('inf') / float('nan') / Decimal('Infinity') などは
                # int() が OverflowError / ValueError になる。非有限値はそのまま保持。
                try:
                    self.state.vars[c - ord('A')] = int(v)
                except (OverflowError, ValueError):
                    self.state.vars[c - ord('A')] = v

class LabelManager:
    """Manages assembly labels"""
    
    def __init__(self, state):
        self.state = state
    
    def get_section(self, k):
        """Get label section"""
        self.state.error_undefined_label = False
        try:
            v = self.state.labels[k][1]
        except (KeyError, IndexError):
            v = UNDEF
            self.state.error_undefined_label = True
        return v
    
    def get_value(self, k):
        """Get label value"""
        self.state.error_undefined_label = False
        try:
            v = self.state.labels[k][0]
        except (KeyError, IndexError):
            if self.state._pass1_size_mode:
                # Pass1 サイズ推定モード中は 0 を返す。
                # error_undefined_label は False のまま（Trueにするとmakeobjがスキップする）。
                return 0
            v = UNDEF
            self.state.error_undefined_label = True
            # pass2 または単パスモード（pas==0）のときだけエラーを表示する。
            # pass1 では forward reference が多発するため表示しない。
            if self.state.pas == 2 or self.state.pas == 0:
                _fn = self.state.current_file or ""
                _ln = self.state.ln
                print(f" error - Label undefined: '{k}'"
                      f"  [{_fn}:{_ln}]", file=sys.stderr)
            return v
        # ELF リロケーション追跡
        # is_equ=True の定数ラベルはリロケーション不要なので追跡しない
        _is_equ = len(self.state.labels[k]) > 2 and self.state.labels[k][2]
        if self.state._elf_tracking and not self.state.error_undefined_label and not _is_equ:
            if self.state._elf_capturing_var is not None:
                # match() が !var 式を評価中: 変数→ラベル名の対応を記録。
                # 1 回の変数キャプチャで get_value() が 2 回以上呼ばれた場合
                # （複合式: label1 + label2 など）は信頼できないので登録を取り消す。
                cv = self.state._elf_capturing_var
                if cv not in self.state._elf_var_to_label:
                    self.state._elf_var_to_label[cv] = (k, v)
                else:
                    # 2 回目以降 → 複合式なのでリロケーション不可としてマーク
                    self.state._elf_var_to_label[cv] = None
            elif self.state._elf_current_word_idx >= 0:
                # makeobj() 内でオブジェクト式がラベルを直接参照
                self.state._elf_label_refs_seen.append(
                    (k, v, self.state._elf_current_word_idx))
        return v
    
    def put_value(self, k, v, s, is_equ=False):
        """Set label value.

        is_equ=True  : .equ で定義された定数ラベル（リロケーション不要）
        is_equ=False : アドレスラベル（リロケーション対象になり得る）
        """
        if self.state.pas == 1 or self.state.pas == 0:
            # パス1/インタラクティブ: 同名ラベルの二重定義はエラー
            if k in self.state.labels:
                # Fix 3 (new): インポートラベル（is_imported=True）と同名のソースラベルを
                # 定義しようとした場合、インポートラベルはリラクゼーション先頭で
                # _imported_labels から復元されるため「既存ラベル」として検出される。
                # しかしソースラベルによるインポートラベルの上書きは正当な操作なので
                # エラーにせず警告のみ出して続行する。
                existing = self.state.labels[k]
                old_is_imported = len(existing) > 3 and existing[3]
                if old_is_imported:
                    # インポートラベルの上書き：警告のみ（エラーにしない）
                    pass
                else:
                    self.state.error_label_conflict = True
                    print(f" error - label already defined.")
                    return False
        elif self.state.pas == 2:
            # パス2: パス1で登録されていないラベルが新出現した場合はエラー
            if k not in self.state.labels:
                self.state.error_label_conflict = True
                print(f" error - label '{k}' not defined in pass 1.")
                return False
            # Fix 8 (original): パス1とパス2で is_equ フラグが食い違う場合を検出する。
            # Fix 4 (new): ただし imp_label() が is_equ=True で登録したインポートラベルを
            # ソース内のアドレスラベル（is_equ=False）が上書きする場合は意図的なものなので
            # 警告を抑制する。is_imported フラグを確認して判断する。
            old_is_equ      = len(self.state.labels[k]) > 2 and self.state.labels[k][2]
            old_is_imported = len(self.state.labels[k]) > 3 and self.state.labels[k][3]
            if old_is_equ != is_equ and not old_is_imported:
                print(f" warning - label '{k}' is_equ flag changed between pass 1 "
                      f"and pass 2 (was {old_is_equ}, now {is_equ}). "
                      f"ELF relocation output may be incorrect.")

        if k in self.state.patsymbols:
            print(f" error - '{k}' is a pattern file symbol.")
            return False
        
        self.state.error_label_conflict = False
        # Fix 1 (new): is_imported フラグ（第4要素）を保持する。
        # imp_label() が [v, sec, False, True] の4要素で登録したラベルを
        # put_value() が3要素リストで上書きすると is_imported が失われ、
        # write_elf_obj() がインポートラベルをローカルシンボルに格下げしてしまう。
        existing = self.state.labels.get(k)
        is_imported = (existing is not None and len(existing) > 3 and existing[3])
        self.state.labels[k] = [v, s, is_equ, is_imported]
        return True

    def printlabels(self):
        # Fix 8 (new): ラベル一覧を stdout ではなく stderr に出力する。
        # バイナリ出力をパイプで受け取っている場合に stdout が汚染されないようにする。
        # また Python の辞書 repr() の代わりに1行1ラベルの可読フォーマットで出力する。
        result = {}
        for key, value in self.state.labels.items():
            num = value[0]
            section = value[1]
            # UNDEF (256ビット整数) は専用文字列、float は repr()、int は hex() で表示。
            if num == UNDEF:
                num_str = "UNDEF"
            elif isinstance(num, float):
                num_str = repr(num)
            else:
                try:
                    num_str = hex(int(num))
                except (TypeError, ValueError, OverflowError):
                    num_str = repr(num)
            result[key] = [num_str, section]
        for k, v in sorted(result.items()):
            print(f"  {k:40s}  {v[0]}  ({v[1]})", file=sys.stderr)
        
class SymbolManager:
    """Manages assembler symbols"""
    
    def __init__(self, state):
        self.state = state
    
    def get(self, w):
        """Get symbol value"""
        w = w.upper()
        return self.state.symbols.get(w, "")


class ExpressionEvaluator:
    """Evaluates mathematical expressions"""
    
    def __init__(self, state, var_manager, label_manager, symbol_manager, parser):
        self.state = state
        self.var_manager = var_manager
        self.label_manager = label_manager
        self.symbol_manager = symbol_manager
        self.parser = parser
    
    def nbit(self, l):
        """Count number of bits needed to represent value"""
        b = 0
        # Fix: float('inf') や float('nan') を int() に渡すと OverflowError が発生する。
        # 非有限の float は 0 ビットとして扱いエラーを防ぐ。
        if isinstance(l, float) and not l == l:   # NaN check (NaN != NaN)
            return 0
        if isinstance(l, float) and (l == float('inf') or l == float('-inf')):
            return 0
        # 修正: float が渡された場合 r >>= 1 で TypeError になるため
        # 事前に int に変換する。abs() の後で int 化することで負値も安全に処理できる。
        try:
            r = int(abs(l))
        except (OverflowError, ValueError):
            return 0
        while r:
            r >>= 1
            b += 1
        return b
    
    def err(self, m):
        """Print error message"""
        print(m)
        return -1
    
    def factor(self, s, idx):
        """Parse factor in expression"""
        idx = StringUtils.skipspc(s, idx)
        x = 0
        
        if idx + 4 <= len(s) and s[idx:idx+4] == '!!!!' and self.state.expmode == EXP_PAT:
            x = self.state.vliwstop
            idx += 4
        elif idx + 3 <= len(s) and s[idx:idx+3] == '!!!' and self.state.expmode == EXP_PAT:
            x = self.state.vcnt
            idx += 3
        elif idx < len(s) and s[idx] == '-':
            # Fix: 深くネストした単項マイナス（例: ----x）は RecursionError になりうる。
            # Python のデフォルト再帰限界は ~1000 であり、悪意あるまたは誤った入力で
            # クラッシュする。try/except で安全に 0 を返す。
            try:
                x, idx = self.factor(s, idx + 1)
            except RecursionError:
                if self.state.pas == 2 or self.state.pas == 0:
                    print(" error - expression nesting too deep (RecursionError) in unary '-'.")
                return 0, idx
            x = -x
        elif idx < len(s) and s[idx] == '~':
            try:
                x, idx = self.factor(s, idx + 1)
            except RecursionError:
                if self.state.pas == 2 or self.state.pas == 0:
                    print(" error - expression nesting too deep (RecursionError) in unary '~'.")
                return 0, idx
            # Fix: x が float('inf') / float('nan') のとき int(x) が OverflowError になる。
            # nbit() と同じ方針: 非有限の float は 0 として扱う。
            try:
                x = ~int(x)
            except (OverflowError, ValueError):
                if self.state.pas == 2 or self.state.pas == 0:
                    print(f" error - cannot apply bitwise NOT (~) to non-finite float value.")
                x = 0
        elif idx < len(s) and s[idx] == '@':
            try:
                x, idx = self.factor(s, idx + 1)
            except RecursionError:
                if self.state.pas == 2 or self.state.pas == 0:
                    print(" error - expression nesting too deep (RecursionError) in unary '@'.")
                return 0, idx
            x = self.nbit(x)
        elif idx < len(s) and s[idx] == '*':
            if idx+1<len(s) and s[idx+1] == '(':
                x, idx = self.expression(s,idx+2)
                if idx<len(s) and s[idx] == ',':
                    x2,idx = self.expression(s,idx+1)
                    if idx<len(s) and s[idx] == ')':
                        idx+=1
                        # Fix: x2 が負のとき x2*8 < 0 → ValueError: negative shift count。
                        # Fix(new): x2 が float('inf')/nan のとき int(x2) → OverflowError。
                        # 両方をまとめて try/except でガードする。
                        try:
                            shift_amount = int(x2) * 8
                        except (OverflowError, ValueError):
                            if self.state.pas == 2 or self.state.pas == 0:
                                print(" error - non-finite byte-extract offset in *(expr, expr).")
                            x = 0
                        else:
                            if shift_amount < 0:
                                if self.state.pas == 2 or self.state.pas == 0:
                                    print(" error - negative byte-extract offset in *(expr, expr).")
                                x = 0
                            else:
                                x = x >> shift_amount
                    else:
                        # 修正⑩: 閉じ括弧 ')' がない場合はエラーを報告して 0 を返す
                        print(" error - missing ')' in *(expr, expr) expression.")
                        x=0
                else:
                    # 修正⑩: カンマがない場合はエラーを報告して 0 を返す
                    print(" error - missing ',' in *(expr, expr) expression.")
                    x=0
            else:
                # Fix: '*' の後に '(' が続かない場合は *(expr,expr) 構文のミスタイプ。
                # エラーメッセージを出力し x=0 のまま返す。
                # idx を進めないため、呼び出し元の term0() が '*' を二項演算子として
                # 再解釈し 0 * (次の式) = 0 となる（サイレントなセマンティクスは変わらないが
                # 少なくとも問題を通知する）。
                print(" error - expected '(' after '*' in *(expr,expr) expression.")
                # x=0, idx unchanged
        else:
            prev_idx = idx
            x, idx = self.factor1(s, idx)
            # Fix 2: factor1 が何も消費せず (idx 不変) かつ NUL でも終端でもない位置で
            # 停止した場合、未知トークンがサイレントに 0 になっている。
            # pass2/対話モードのみ警告を出す（pass1 は forward 参照で頻繁に発生するため抑制）。
            if (idx == prev_idx
                    and idx < len(s)
                    and s[idx] not in (chr(0), ',', ')', ']', CB, ' ', '\t')
                    and (self.state.pas == 2 or self.state.pas == 0)):
                print(f" warning - unrecognized token at position {idx} in expression: "
                      f"{s[idx:idx+8]!r} (treated as 0)")

        idx = StringUtils.skipspc(s, idx)
        return x, idx

    def xeval(self, x, _=None):
        # Fix: re.escape() の結果を文字クラス [..] 内に埋め込むと、
        # .labelc で lwordchars に ']' '\\' '^'(先頭) '-'(中間) が追加されたとき
        # re.error が発生する。文字クラス内で安全なエスケープを行う専用関数を使う。
        def _cc_escape(chars):
            """文字クラス [...] の中で安全なエスケープ文字列を生成する。"""
            out = []
            for c in chars:
                if c == '\\':
                    out.append('\\\\')
                elif c == ']':
                    out.append('\\]')
                elif c == '^':
                    out.append('\\^')
                elif c == '-':
                    out.append('\\-')
                else:
                    out.append(re.escape(c))
            return ''.join(out)

        escaped = _cc_escape(self.state.lwordchars)
        pattern = rf":([{escaped}]+)(?=[^{escaped}]|$)"

        def replacer(match):
            label_name = match.group(1)
            try:
                val = self.state.labels[label_name][0]
            except (KeyError, IndexError):
                self.state.error_undefined_label = True
                val = 0
                return hex(0)
            # Fix ⑤修正: UNDEF (2^256-1) やそれに由来する超大整数が xeval に
            # 流れ込むと hex() で 64 桁の文字列になり、Python の多倍長整数演算で
            # 天文学的に遅くなる。2^128 以上は「UNDEF 由来」として 0 に置き換える。
            _UNDEF_THRESHOLD = 1 << 128
            if val == UNDEF or (isinstance(val, int) and val >= _UNDEF_THRESHOLD):
                self.state.error_undefined_label = True
                return hex(0)
            # ELF追跡: get_value() と同じ分岐方針で記録する。
            # .equ 定義ラベルはリロケーション不要なので除外する。
            _is_equ = (len(self.state.labels.get(label_name, [])) > 2
                       and self.state.labels[label_name][2])
            if self.state._elf_tracking and not _is_equ:
                if self.state._elf_capturing_var is not None:
                    cv = self.state._elf_capturing_var
                    if cv not in self.state._elf_var_to_label:
                        self.state._elf_var_to_label[cv] = (label_name, val)
                    else:
                        self.state._elf_var_to_label[cv] = None
                elif self.state._elf_current_word_idx >= 0:
                    self.state._elf_label_refs_seen.append(
                        (label_name, val, self.state._elf_current_word_idx))
            # Fix 1: val が float の場合 hex() は TypeError になる。
            # exp_typ='f' モードで定義された .equ ラベルは float を持ちうる。
            # 非有限 float (inf/nan) および OverflowError も安全に処理する。
            try:
                return hex(int(val))
            except (TypeError, ValueError, OverflowError):
                self.state.error_undefined_label = True
                return hex(0)

        s = re.sub(pattern, replacer, x)

        # Fix 3: eval() の代わりに AST ウォークによるホワイトリスト検証を行う。
        # '__builtins__' を空にするだけではクラス継承チェーン経由の
        # 任意コード実行を防げないため、許可ノード種別を明示的に制限する。
        import ast as _ast

        _ALLOWED_NODES = (
            _ast.Expression,
            _ast.BinOp, _ast.UnaryOp,
            _ast.Add, _ast.Sub, _ast.Mult, _ast.Div, _ast.FloorDiv,
            _ast.Mod, _ast.Pow,
            _ast.BitAnd, _ast.BitOr, _ast.BitXor,
            _ast.LShift, _ast.RShift,
            _ast.Invert, _ast.UAdd, _ast.USub,
            _ast.Constant,
            _ast.Call, _ast.Name, _ast.Load,
            _ast.IfExp,
            _ast.Compare,
            _ast.Eq, _ast.NotEq, _ast.Lt, _ast.LtE, _ast.Gt, _ast.GtE,
            _ast.BoolOp, _ast.And, _ast.Or,
        )
        _ALLOWED_NAMES = {"enfloat", "endouble", "enflt", "endbl"}

        try:
            tree = _ast.parse(s, mode='eval')
        except SyntaxError as e:
            raise ValueError(f"xeval: parse error in '{s}': {e}")

        for node in _ast.walk(tree):
            if not isinstance(node, _ALLOWED_NODES):
                raise ValueError(
                    f"xeval: disallowed AST node {type(node).__name__} in '{s}'")
            if isinstance(node, _ast.Name) and node.id not in _ALLOWED_NAMES:
                raise ValueError(
                    f"xeval: disallowed name '{node.id}' in '{s}'")
            if isinstance(node, _ast.Call):
                if (not isinstance(node.func, _ast.Name)
                        or node.func.id not in _ALLOWED_NAMES):
                    raise ValueError(
                        f"xeval: disallowed function call in '{s}'")

        safe_env = {
            "__builtins__": {},
            "enfloat": enfloat,
            "endouble": endouble,
            "enflt": enflt,
            "endbl": endbl,
        }
        result = eval(compile(tree, '<xeval>', 'eval'), safe_env, {})
        if not isinstance(result, (int, float, bool)):
            raise ValueError(f"xeval: unsafe result type {type(result)}")
        return result

    def factor1(self, s, idx):
        """Parse primary factor"""
        x = 0
        idx = StringUtils.skipspc(s, idx)
        
        if idx >= len(s):
            return x, idx
        
        if s[idx] == '(':
            x, idx = self.expression(s, idx + 1)
            if idx < len(s) and s[idx] == ')':
                idx += 1
            else:
                # Fix 2: 閉じ括弧がない不正な入力を検出して報告する。
                # 旧実装はエラーなしに続行し、パース位置がずれたまま処理が続いていた。
                print(" error - missing closing ')' in expression.")
        # Fix ⑥: 境界チェックを idx+4<=len(s) に統一する。
        elif idx+4<=len(s) and s[idx:idx+4]=="'\\t'":
            x=0x09
            idx+=4
        elif idx+4<=len(s) and s[idx:idx+4]=="'\\''":
            x=ord("'")
            idx+=4
        elif idx+4<=len(s) and s[idx:idx+4]=="'\\\\'":
            x=ord("\\")
            idx+=4
        elif idx+4<=len(s) and s[idx:idx+4]=="'\\n'":
            x=0x0a
            idx+=4
        elif idx+4<=len(s) and s[idx:idx+4]=="'\\0'":
            x=0x00
            idx+=4
        elif idx+4<=len(s) and s[idx:idx+4]=="'\\r'":
            x=0x0d
            idx+=4
        elif idx+4<=len(s) and s[idx:idx+4]=="'\\a'":
            x=0x07
            idx+=4
        elif idx+4<=len(s) and s[idx:idx+4]=="'\\b'":
            x=0x08
            idx+=4
        elif idx+4<=len(s) and s[idx:idx+4]=="'\\f'":
            x=0x0c
            idx+=4
        elif idx+4<=len(s) and s[idx:idx+4]=="'\\v'":
            x=0x0b
            idx+=4
        # Fix 3 (new): 4文字エスケープリテラルをすべて上で処理してから
        # 3文字一般リテラル 'x' を処理する。これにより '\0' '\r' などが
        # バックスラッシュをそのまま ord('\\')=92 として返す誤りを防ぐ。
        # 3文字判定は「s[idx+1] がバックスラッシュでない」ことを確認してから行う。
        # Fix 4 (original): idx+3 <= len(s) に変更（末尾3文字も正しくマッチ）
        elif idx+3<=len(s) and s[idx]=='\'' and s[idx+1] != '\\' and s[idx+2]=='\'':
            x=ord(s[idx+1])
            idx+=3
        elif StringUtils.q(s, '$$', idx):
            idx += 2
            # binary_list中(makeobj内)では命令先頭アドレスpc_instr_startを返す。
            # .equなど他のコンテキストでは現在のPC(self.state.pc)を返す。
            x = self.state.pc_instr_start if self.state._in_binary_list else self.state.pc
        elif StringUtils.q(s, '#', idx):
            idx += 1
            t, idx = self.parser.get_symbol_word(s, idx)
            _sym_val = self.symbol_manager.get(t)
            # Bugfix: symbol_manager.get() は未定義シンボルに "" (空文字列) を返す。
            # "" が x に代入されると後続の算術演算（term0 等）で TypeError が発生し、
            # 「パターンマッチ失敗」として誤報告されていた。
            # 修正: 未定義シンボル（"" のまま）は 0 として扱いエラーを明示する。
            if _sym_val == "":
                if self.state.pas == 2 or self.state.pas == 0:
                    print(f" error - undefined symbol: '#{t}'")
                x = 0
            else:
                x = _sym_val
        elif StringUtils.q(s, '0b', idx):
            idx += 2
            while idx < len(s) and s[idx] in "01":
                x = 2 * x + int(s[idx], 2)
                idx += 1
        elif StringUtils.q(s, '0x', idx):
            idx += 2
            while idx < len(s) and StringUtils.upper(s[idx]) in XDIGIT:
                x = 16 * x + int(s[idx].lower(), 16)
                idx += 1
        elif (idx + 3 <= len(s) and s[idx:idx+3] == 'qad'
              # Bugfix: 'qad' の後（スペース可）に '{' が続く場合のみキーワードとして扱う。
              # これがないと 'qad_label' や 'qadrant' のようなラベル名が
              # qad キーワードブランチに誤って入り、ラベル値が 0 になるサイレントバグが起きる。
              and (lambda _j=StringUtils.skipspc(s, idx + 3): _j < len(s) and s[_j] == '{')()):
            idx += 3
            idx = StringUtils.skipspc(s, idx)
            if idx < len(s) and s[idx] == '{':
                # get_curlb で {} 内の式テキスト全体を取得（算術式に対応）
                f, t, idx = self.parser.get_curlb(s, idx)
                if not f:
                    # get_curlb は既にエラーを表示済み。x=0 のまま返る。
                    # idx は len(s) になっているのでそのまま抜ける。
                    pass
                else:
                    try:
                        h = IEEE754Converter.decimal_eval_expr(t)
                    except (ValueError, ZeroDivisionError):
                        # シンボル・ラベルなど Decimal 評価できない場合は
                        # xeval（ラベル置換 + Python eval）で数値を得る。
                        #
                        # Fix ⑯ (新規): 旧実装は float 経由で repr() を作ってから
                        # decimal_to_ieee754_128bit_hex() に渡していた。float は
                        # 53bit 精度なので qad{} の「128bit 精度」が失われる。
                        # 修正: xeval の結果が整数または整数値の float ならば
                        # str(int(v)) → Decimal(整数) → binary128 の経路を使い
                        # 精度を保持する。真に非整数の場合は Decimal(repr(v)) で
                        # 最大限の精度を確保した上で変換する。
                        # （label+N のような整数式は int() 経路が適用され精度は保たれる）
                        v = self.xeval(t, None)
                        if isinstance(v, int) or (
                                isinstance(v, float) and v.is_integer()):
                            h = IEEE754Converter.decimal_to_ieee754_128bit_hex(
                                    str(int(v)))
                        else:
                            # 非整数 float: repr() で 53bit 相当の最大桁数を使用。
                            # xeval が Python の float を返す以上 53bit が上限だが、
                            # Decimal() を経由することで binary128 変換は正確に行われる。
                            h = IEEE754Converter.decimal_to_ieee754_128bit_hex(
                                    str(Decimal(repr(float(v)))))
                    x = int(h, 16)
        elif (idx + 3 <= len(s) and s[idx:idx+3] == 'dbl'
              # Bugfix: 'dbl' 前置ラベル名誤解析防止。'{' が続く場合のみキーワード扱い。
              and (lambda _j=StringUtils.skipspc(s, idx + 3): _j < len(s) and s[_j] == '{')()):
            idx += 3
            f, t, idx = self.parser.get_curlb(s, idx)
            if f:
                if t == 'nan':
                    x = 0x7ff8000000000000
                elif t == 'inf':
                    x = 0x7ff0000000000000
                elif t == '-inf':
                    x = 0xfff0000000000000
                else:
                    # Fix: xeval が UNDEF 由来の巨大整数を返すと float() / struct.pack で
                    # OverflowError / struct.error が発生する。
                    try:
                        v = float(self.xeval(t, None))
                        x = int.from_bytes(struct.pack('>d', v), "big")
                    except (OverflowError, ValueError, struct.error):
                        if self.state.pas == 2 or self.state.pas == 0:
                            print(f" error - dbl{{}}: cannot convert expression to float64; using 0.")
                        x = 0
        elif (idx + 3 <= len(s) and s[idx:idx+3] == 'flt'
              # Bugfix: 'flt' 前置ラベル名誤解析防止。'{' が続く場合のみキーワード扱い。
              and (lambda _j=StringUtils.skipspc(s, idx + 3): _j < len(s) and s[_j] == '{')()):
            idx += 3
            f, t, idx = self.parser.get_curlb(s, idx)
            if f:
                if t == 'nan':
                    x = 0x7fc00000
                elif t == 'inf':
                    x = 0x7f800000
                elif t == '-inf':
                    x = 0xff800000
                else:
                    # Fix: xeval が UNDEF 由来の巨大整数を返すと float() / struct.pack で
                    # OverflowError / struct.error が発生する。
                    try:
                        v = float(self.xeval(t, None))
                        x = int.from_bytes(struct.pack('>f', v), "big")
                    except (OverflowError, ValueError, struct.error):
                        if self.state.pas == 2 or self.state.pas == 0:
                            print(f" error - flt{{}}: cannot convert expression to float32; using 0.")
                        x = 0
        elif (idx + 5 <= len(s) and s[idx:idx+5] == 'enflt'
              # Bugfix: 'enflt' 前置ラベル名誤解析防止。'{' が続く場合のみキーワード扱い。
              and (lambda _j=StringUtils.skipspc(s, idx + 5): _j < len(s) and s[_j] == '{')()):
            idx += 5
            f, t, idx = self.parser.get_curlb(s, idx)
            if f:
                # Bugfix3 (false positive): expression() を呼ぶ前に
                # error_undefined_label をリセットすることで、
                # enflt{} の中身が定数のとき誤エラーが出なくなる。
                #
                # Bugfix4 (side effect of Bugfix3): リセット前の状態（外側の式で
                # 既に検出した未定義ラベル情報）を保存し、内側の式の結果と OR 合成して
                # 復元する。こうすることで "undef_label + enflt{1.5}" のように
                # enflt{} より先に未定義ラベルが評価されたケースでも、
                # 外側の error_undefined_label=True が消えずに残る。
                _outer_undef = self.state.error_undefined_label
                self.state.error_undefined_label = False
                v, _ = self.expression(t + chr(0), 0)
                _inner_undef = self.state.error_undefined_label
                # 外側と内側の未定義ラベルを OR 合成して伝播させる
                self.state.error_undefined_label = _outer_undef or _inner_undef
                # Bugfix (struct.error): v が UNDEF (256bit 整数) のとき struct.pack('I', v) は
                # struct.error を送出する。修正: 0〜2^32-1 の範囲にマスクしてから渡す。
                # Bugfix2 (silent NaN): UNDEF をマスクすると 0xFFFFFFFF → NaN になり
                # エラーメッセージなしに誤った浮動小数点値が格納されていた。
                # 修正: 未定義ラベル検出時は 0 を使ってエラーを明示する。
                if _inner_undef:
                    if self.state.pas == 2 or self.state.pas == 0:
                        print(" error - enflt{}: expression contains undefined label.")
                    x = enflt(0)
                else:
                    # Fix: v が float('inf')/nan のとき int(v) は OverflowError になる。
                    try:
                        x = enflt(int(v) & 0xFFFFFFFF)
                    except (OverflowError, ValueError):
                        if self.state.pas == 2 or self.state.pas == 0:
                            print(" error - enflt{}: non-finite float value; using 0.")
                        x = enflt(0)
        elif (idx + 5 <= len(s) and s[idx:idx+5] == 'endbl'
              # Bugfix: 'endbl' 前置ラベル名誤解析防止。'{' が続く場合のみキーワード扱い。
              and (lambda _j=StringUtils.skipspc(s, idx + 5): _j < len(s) and s[_j] == '{')()):
            idx += 5
            f, t, idx = self.parser.get_curlb(s, idx)
            if f:
                # Bugfix3/4: enflt と同様に外側の状態を保存し、内側の結果と OR 合成する。
                _outer_undef = self.state.error_undefined_label
                self.state.error_undefined_label = False
                v, _ = self.expression(t + chr(0), 0)
                _inner_undef = self.state.error_undefined_label
                self.state.error_undefined_label = _outer_undef or _inner_undef
                # Bugfix (struct.error): v が UNDEF のとき struct.pack('Q', v) がクラッシュする。
                # Bugfix2 (silent NaN): enflt と同様に未定義ラベル時は 0 を使いエラーを明示する。
                if _inner_undef:
                    if self.state.pas == 2 or self.state.pas == 0:
                        print(" error - endbl{}: expression contains undefined label.")
                    x = endbl(0)
                else:
                    # Fix: v が float('inf')/nan のとき int(v) は OverflowError になる。
                    try:
                        x = endbl(int(v) & 0xFFFFFFFFFFFFFFFF)
                    except (OverflowError, ValueError):
                        if self.state.pas == 2 or self.state.pas == 0:
                            print(" error - endbl{}: non-finite float value; using 0.")
                        x = endbl(0)
        elif self.state.exp_typ=='i' and idx < len(s) and s[idx].isdigit():
                fs, idx = self.parser.get_intstr(s, idx)
                x = int(fs)  # int(float(fs)) would lose precision for large integers
        elif self.state.exp_typ=='f' and idx < len(s) and (self.parser.isfloatstr(s,idx)):
                fs,idx = self.parser.get_floatstr(s,idx)
                # Fix: get_floatstr が空文字列を返した場合（例: 小数点のみ '.'）は
                # float('') が ValueError になる。0.0 として扱う。
                try:
                    x = float(fs) if fs else 0.0
                except ValueError:
                    x = 0.0
        elif (idx < len(s) and
              s[idx] in LOWER and (idx + 1 >= len(s) or s[idx+1] not in self.state.lwordchars)):
            ch = s[idx]
            if idx + 3 <= len(s) and s[idx+1:idx+3] == ':=':
                x, idx = self.expression(s, idx + 3)
                self.var_manager.put(ch, x)
            else:
                x = self.var_manager.get(ch)
                idx += 1
                # Fix ⑥: ELF追跡: makeobj() 内で変数を読んだとき、その変数が
                # match() でラベルを直接キャプチャしたものであればリロケーション候補
                # として記録する。
                # 旧実装は expmode==EXP_PAT かつ _elf_current_word_idx>=0 の条件で
                # _elf_var_to_label を参照していたが、_elf_tracking フラグの確認が
                # 先行するため tracking が False の場合は辞書参照自体をスキップできる。
                # またキー存在確認の前に _elf_tracking を先にチェックすることで
                # 不要な辞書ルックアップを削減する。
                if (self.state._elf_tracking
                        and self.state._elf_current_word_idx >= 0):
                    entry = self.state._elf_var_to_label.get(ch)
                    if entry is not None:
                        lname, lval = entry
                        self.state._elf_label_refs_seen.append(
                            (lname, lval, self.state._elf_current_word_idx))
        elif idx < len(s) and s[idx] in self.state.lwordchars:
            w, idx_new = self.parser.get_label_word(s, idx)
            if idx != idx_new:
                idx = idx_new
                x = self.label_manager.get_value(w)
        
        idx = StringUtils.skipspc(s, idx)
        return x, idx
    
    def term0_0(self, s, idx):
        """Handle exponentiation"""
        x, idx = self.factor(s, idx)
        while idx < len(s) and StringUtils.q(s, '**', idx):
            t, idx = self.factor(s, idx + 2)
            # Fix 4 (new): 指数の安全チェック。
            # ① t が負 → Python では float になり後続ビット演算が TypeError になる。
            #   整数 x の場合は 0 を返す（x**(-n) は実数だがアセンブラ文脈では無意味）。
            # ② t が非常に大きな整数 → メモリと時間を天文学的に消費する。
            #   現実的なアセンブラで指数が 1024 を超えることはないため上限を設ける。
            _EXP_MAX = 1024
            try:
                t_int = int(t)
            except (ValueError, OverflowError):
                t_int = 0
            if t_int < 0:
                self.err("Negative exponent in ** expression; result set to 0.")
                x = 0
                break
            if t_int > _EXP_MAX:
                self.err(f"Exponent {t_int} exceeds maximum {_EXP_MAX} in ** expression; result set to 0.")
                x = 0
                break
            x = x ** t_int
            # Fix 2 (new): 底 x が float のとき（割り算の結果や exp_typ='f' モード）
            # x ** t_int は float を返す。後続の term2〜term6 でビット演算（<<, &, ~）が
            # 行われると TypeError が発生する。
            # 底が整数値の float（例: 2.0）は int に変換して精度を保持する。
            # 真に非整数の float はそのまま保持する（float モード処理に委ねる）。
            if isinstance(x, float) and x.is_integer():
                x = int(x)
        return x, idx
    
    def term0(self, s, idx):
        """Handle multiplication, division, modulo"""
        x, idx = self.term0_0(s, idx)
        while idx < len(s):
            if s[idx] == '*' and (idx + 1 >= len(s) or s[idx+1] != '*'):
                t, idx = self.term0_0(s, idx + 1)
                x *= t
            elif StringUtils.q(s, '//', idx):
                t, idx = self.term0_0(s, idx + 2)
                if t == 0:
                    self.err("Division by 0 error.")
                    # Fix 1 (new): ゼロ除算時は x を 0 に確定して while を抜ける。
                    # 旧実装は err() が -1 を返すだけで例外を投げないため、x が前の値の
                    # まま while ループが継続し、誤った値が後続の演算に伝播していた。
                    x = 0
                    break
                else:
                    x //= t
            elif s[idx] == '/':
                t, idx = self.term0_0(s, idx + 1)
                if t == 0:
                    self.err("Division by 0 error.")
                    x = 0
                    break
                else:
                    # 整数同士で割り切れる場合は int のまま返して 53bit float 精度落ちを防ぐ。
                    # 割り切れない場合（真の実数除算）は float で返す。
                    if isinstance(x, int) and isinstance(t, int):
                        q, r = divmod(x, t)
                        x = q if r == 0 else x / t
                    else:
                        x = x / t
            elif s[idx] == '%':
                t, idx = self.term0_0(s, idx + 1)
                if t == 0:
                    self.err("Division by 0 error.")
                    x = 0
                    break
                else:
                    x = x % t
            else:
                break
        return x, idx
    
    def term1(self, s, idx):
        """Handle addition, subtraction"""
        x, idx = self.term0(s, idx)
        while idx < len(s):
            if s[idx] == '+':
                t, idx = self.term0(s, idx + 1)
                x += t
            elif s[idx] == '-':
                t, idx = self.term0(s, idx + 1)
                x -= t
            else:
                break
        return x, idx
    
    def term2(self, s, idx):
        """Handle bit shifts"""
        x, idx = self.term1(s, idx)
        # Fix: ** 演算子と同様に、シフト量に現実的な上限を設ける。
        # 上限なしだと 1<<100000000 のような式で 120MB の巨大整数が即座に作られる。
        # 現実のアセンブラで 65536 ビット超のシフトは非現実的。
        _SHIFT_MAX = 65536
        while idx < len(s):
            if StringUtils.q(s, '<<', idx):
                t, idx = self.term1(s, idx + 2)
                try:
                    x = int(x)
                    t = int(t)
                except (ValueError, OverflowError):
                    x = 0; break
                # Fix: 負のシフト量は ValueError になる。ガードして 0 を返す。
                if t < 0:
                    if self.state.pas == 2 or self.state.pas == 0:
                        print(f" error - negative shift count ({t}) in << expression.")
                    x = 0; break
                # Fix: 過大なシフト量は巨大整数を作りメモリを大量消費する。
                if t > _SHIFT_MAX:
                    if self.state.pas == 2 or self.state.pas == 0:
                        print(f" error - shift count {t} exceeds maximum {_SHIFT_MAX} in << expression.")
                    x = 0; break
                x <<= t
            elif StringUtils.q(s, '>>', idx):
                t, idx = self.term1(s, idx + 2)
                try:
                    x = int(x)
                    t = int(t)
                except (ValueError, OverflowError):
                    x = 0; break
                # Fix: 負のシフト量は ValueError になる。ガードして 0 を返す。
                if t < 0:
                    if self.state.pas == 2 or self.state.pas == 0:
                        print(f" error - negative shift count ({t}) in >> expression.")
                    x = 0; break
                # >> は右シフトなので大きな値でもメモリ問題は起きないが統一性のためガードする。
                if t > _SHIFT_MAX:
                    x = 0; break
                x >>= t
            else:
                break
        return x, idx
    
    def _safe_int(self, v, op_name):
        """float/Decimal を安全に int に変換する。非有限値はエラーを出して 0 を返す。"""
        try:
            return int(v)
        except (OverflowError, ValueError):
            if self.state.pas == 2 or self.state.pas == 0:
                print(f" error - non-finite value {v!r} in bitwise '{op_name}' operation; treated as 0.")
            return 0

    def term3(self, s, idx):
        """Handle bitwise AND"""
        x, idx = self.term2(s, idx)
        while idx < len(s) and s[idx] == '&' and (idx + 1 >= len(s) or s[idx+1] != '&'):
            t, idx = self.term2(s, idx + 1)
            x = self._safe_int(x, '&') & self._safe_int(t, '&')
        return x, idx
    
    def term4(self, s, idx):
        """Handle bitwise OR"""
        x, idx = self.term3(s, idx)
        while idx < len(s) and s[idx] == '|' and (idx + 1 >= len(s) or s[idx+1] != '|'):
            t, idx = self.term3(s, idx + 1)
            x = self._safe_int(x, '|') | self._safe_int(t, '|')
        return x, idx
    
    def term5(self, s, idx):
        """Handle bitwise XOR"""
        x, idx = self.term4(s, idx)
        while idx < len(s) and s[idx] == '^':
            t, idx = self.term4(s, idx + 1)
            x = self._safe_int(x, '^') ^ self._safe_int(t, '^')
        return x, idx
    
    def term6(self, s, idx):
        """Handle sign extension.

        修正⑨: t（ビット幅）が非常に大きい場合、`(~0) << t` が Python の
        任意精度整数で天文学的なサイズになり、後続の演算が極端に遅くなる。
        現実的なアセンブラでは符号拡張のビット幅が 128 を超えることはない
        ため、上限を設けてガードする。上限を超えた場合はゼロを返す
        （ビット幅 0 と同じ扱い）。

        Fix ②修正: term0 の '/' 演算が float を返すことがあり、その値が
        term6 まで伝播すると x >> (t-1) でビット演算できず TypeError になる。
        また term5 が float の t を返す場合も同様。演算前に明示的に int へ変換する。
        （term2〜term5 が int(x) を呼んでいるのと同じ方針）
        """
        _SEXT_MAX_BITS = 128  # 符号拡張ビット幅の上限
        x, idx = self.term5(s, idx)
        # Use '\'' as sign-extension operator only when followed by a digit or '('
        # to avoid ambiguity with character literal closing quotes.
        # Fix ⑰ (新規): remove_comment_asm が Fix ⑬ で \xNN を正しく消費するため
        # 孤立クォートの混入は大幅に減少するが、以下のガードで二重防護する。
        # 符号拡張演算子は必ず正の整数ビット幅（1 以上）が後に続く。
        # 次トークンが数字または '(' でない場合は演算子ではなく閉じクォートとみなす。
        while idx < len(s) and s[idx] == '\'':
            next_idx = idx + 1
            next_idx = StringUtils.skipspc(s, next_idx)
            if next_idx >= len(s) or (s[next_idx] not in DIGIT and s[next_idx] != '('):
                break
            t, idx = self.term5(s, idx + 1)
            # Fix ②: float が来たときの TypeError を防ぐため int に変換する
            try:
                x = int(x)
                t = int(t)
            except (ValueError, OverflowError):
                x = 0
                break
            if t <= 0:
                x = 0
            elif t > _SEXT_MAX_BITS:
                # 修正⑨: 非現実的なビット幅は 0 として扱う
                print(f" warning - sign-extension bit width {t} exceeds maximum {_SEXT_MAX_BITS}, result set to 0.")
                x = 0
            else:
                x = (x & ~((~0) << t)) | ((~0) << t if (x >> (t-1) & 1) else 0)
        return x, idx
    
    def term7(self, s, idx):
        """Handle comparisons"""
        x, idx = self.term6(s, idx)
        while idx < len(s):
            if StringUtils.q(s, '<=', idx):
                t, idx = self.term6(s, idx + 2)
                x = 1 if x <= t else 0
            elif s[idx] == '<':
                t, idx = self.term6(s, idx + 1)
                x = 1 if x < t else 0
            elif StringUtils.q(s, '>=', idx):
                t, idx = self.term6(s, idx + 2)
                x = 1 if x >= t else 0
            elif s[idx] == '>':
                t, idx = self.term6(s, idx + 1)
                x = 1 if x > t else 0
            elif StringUtils.q(s, '==', idx):
                t, idx = self.term6(s, idx + 2)
                x = 1 if x == t else 0
            elif StringUtils.q(s, '!=', idx):
                t, idx = self.term6(s, idx + 2)
                x = 1 if x != t else 0
            else:
                break
        return x, idx
    
    def term8(self, s, idx):
        """Handle logical NOT"""
        if idx + 4 <= len(s) and s[idx:idx+4] == 'not(':
            x, idx = self.expression(s, idx + 3)
            x = 0 if x else 1
        else:
            x, idx = self.term7(s, idx)
        return x, idx
    
    def term9(self, s, idx):
        """Handle logical AND"""
        x, idx = self.term8(s, idx)
        while idx < len(s) and StringUtils.q(s, '&&', idx):
            t, idx = self.term8(s, idx + 2)
            x = 1 if x and t else 0
        return x, idx
    
    def term10(self, s, idx):
        """Handle logical OR"""
        x, idx = self.term9(s, idx)
        while idx < len(s) and StringUtils.q(s, '||', idx):
            t, idx = self.term9(s, idx + 2)
            x = 1 if x or t else 0
        return x, idx
    
    def term11(self, s, idx):
        """Handle ternary operator (right-associative: a?b:c?d:e => a?b:(c?d:e))

        Fix ①: 旧実装は真ブランチ・偽ブランチを必ず両方評価してから
        条件に応じてどちらの値を返すかを選んでいた。
        変数代入（a:=expr）などの副作用を含むブランチでは、
        選ばれなかった側の副作用まで実行されてしまう問題があった。

        修正後: 評価前後で vars をスナップショット/リストアすることで、
        選ばれなかったブランチの変数変更を確実に取り消す。
        パーサーの性質上（終端位置を得るために両ブランチを評価する必要がある）
        式を評価しない訳にはいかないため、副作用のみロールバックする方式を採る。

        Fix ⑦: error_undefined_label フラグも選択されたブランチのものを
        採用するように修正する。旧実装は「最後に評価したブランチ」（偽ブランチ）
        のフラグが残るため、条件が真のとき偽ブランチに未定義ラベルがあると
        誤ってエラーとして報告されていた。

        Fix ⑫ (新規): ELF リロケーション追跡状態（_elf_label_refs_seen /
        _elf_var_to_label）も選ばれなかったブランチの副作用を取り消す。
        旧実装では両ブランチを評価するたびにこれらリストに追記されるため、
        使われない側のリロケーションエントリが混入し、ELF オブジェクトファイルに
        誤ったリロケーションが生成されていた。
        """
        x, idx = self.term10(s, idx)
        if idx < len(s) and StringUtils.q(s, '?', idx):
            # Fix 6: 両ブランチを評価してから副作用をロールバックする方式は
            # ネストが深いほどスナップショットのコピーコストが増大する。
            # _elf_label_refs_seen は list コピーが高コストになりうるため、
            # スナップショット時点の長さを記録し、ロールバックはスライスで行う。
            saved_vars              = self.state.vars[:]
            saved_err_undef         = self.state.error_undefined_label
            saved_err_conflict      = self.state.error_label_conflict
            saved_elf_refs_len      = len(self.state._elf_label_refs_seen)   # Fix 6
            saved_elf_v2l           = dict(self.state._elf_var_to_label)

            t, idx = self.term11(s, idx + 1)   # 真ブランチ評価（右結合）
            vars_after_true         = self.state.vars[:]
            err_after_true          = self.state.error_undefined_label
            conflict_after_true     = self.state.error_label_conflict
            refs_after_true         = list(self.state._elf_label_refs_seen)  # Fix ⑫
            v2l_after_true          = dict(self.state._elf_var_to_label)     # Fix ⑫

            if idx < len(s) and StringUtils.q(s, ':', idx):
                # 偽ブランチ評価前に vars / ELF 追跡状態を元の状態に戻す
                self.state.vars                     = saved_vars[:]
                self.state.error_undefined_label    = saved_err_undef
                self.state.error_label_conflict     = saved_err_conflict
                # Fix 6: スライスで saved 長さまで切り戻す（新規コピー不要）
                del self.state._elf_label_refs_seen[saved_elf_refs_len:]
                self.state._elf_var_to_label        = dict(saved_elf_v2l)
                u, idx = self.term11(s, idx + 1)  # 偽ブランチ評価（右結合）
                err_after_false         = self.state.error_undefined_label
                conflict_after_false    = self.state.error_label_conflict

                if x != 0:
                    # 条件が真: 真ブランチの値・変数状態・エラーフラグ・ELF状態を採用
                    self.state.vars                     = vars_after_true
                    self.state.error_undefined_label    = err_after_true
                    self.state.error_label_conflict     = conflict_after_true
                    self.state._elf_label_refs_seen     = refs_after_true
                    self.state._elf_var_to_label        = v2l_after_true
                    x = t
                else:
                    # 条件が偽: 偽ブランチの値・変数状態・エラーフラグをそのまま使う
                    x = u
            else:
                # ':' がない不完全な三項演算子: a?b の形式。
                if x != 0:
                    # 条件が真: 真ブランチの値・変数状態・エラーフラグ・ELF状態を採用
                    # Fix ⑫ (修正): 旧実装は ELF 追跡状態（_elf_label_refs_seen /
                    # _elf_var_to_label）の復元が漏れていた。真ブランチ評価後に
                    # refs_after_true / v2l_after_true を採用することで
                    # 誤ったリロケーションエントリの混入を防ぐ。
                    self.state.vars                     = vars_after_true
                    self.state.error_undefined_label    = err_after_true
                    self.state.error_label_conflict     = conflict_after_true
                    self.state._elf_label_refs_seen     = refs_after_true
                    self.state._elf_var_to_label        = v2l_after_true
                    x = t
                else:
                    # 条件が偽: 真ブランチの副作用を取り消し、0 を返す
                    self.state.vars                     = saved_vars
                    self.state.error_undefined_label    = saved_err_undef
                    self.state.error_label_conflict     = saved_err_conflict
                    del self.state._elf_label_refs_seen[saved_elf_refs_len:]  # Fix 6
                    self.state._elf_var_to_label        = dict(saved_elf_v2l)
                    x = 0
        return x, idx
    
    def expression(self, s, idx):
        """Main expression evaluator (internal, s must already be NUL-terminated)"""
        idx = StringUtils.skipspc(s, idx)
        x, idx = self.term11(s, idx)
        return x, idx

    def _terminate(self, s):
        """Return s with a single NUL sentinel appended (idempotent)."""
        if not s or s[-1] != chr(0):
            return s + chr(0)
        return s

    def expression_pat(self, s, idx):
        """Expression in pattern mode"""
        prev = self.state.expmode
        self.state.expmode = EXP_PAT
        try:
            return self.expression(self._terminate(s), idx)
        finally:
            self.state.expmode = prev

    def expression_asm(self, s, idx):
        """Expression in assembly mode"""
        prev = self.state.expmode
        self.state.expmode = EXP_ASM
        try:
            return self.expression(self._terminate(s), idx)
        finally:
            self.state.expmode = prev
    

    def expression_esc(self, s, idx, stopchar):
        """Expression with escaped stop character.

        stopchar は「どの括弧にも囲まれていない深さ0の位置」でのみ NUL に置換する。
        ( ) と [ ] を別カウンタで管理していた旧実装は、両者が混在した場合
        （例: `([)]` のような不正なネストや、stopcharが `)` のケース）に
        誤動作する可能性があった。

        修正後はスタック方式で開き括弧の種類を積み、対応する閉じ括弧が来たときだけ
        pop する。スタックが空のときに stopchar が現れた場合のみ NUL に置換する。
        これにより `([])`, `[(])` などの混在パターンも正確に処理できる。

        また、パターンファイルで [[/]] を変換した特殊文字 OB(0x90)/CB(0x91) も
        ブラケットペアとしてスタック追跡の対象に含める（旧実装では未対応だった）。
        """
        # prefix (s[:idx]) はそのままコピー
        result = list(s[:idx])

        # 開き括弧 → 対応する閉じ括弧（OB/CB を追加）
        OPEN_TO_CLOSE = {'(': ')', '[': ']', OB: CB}
        CLOSE_CHARS   = set(OPEN_TO_CLOSE.values())

        stack = []   # 開き括弧を積むスタック

        for ch in s[idx:]:
            # 【バグ修正①】深さ0でstopcharに一致するかを最初に確認する。
            # 旧実装では stopchar が '(' '[' OB のいずれかのとき、
            # 「開き括弧」として先にスタックに積まれてしまい stopchar として
            # 機能しなかった。判定順を逆転し、depth==0 && ch==stopchar を
            # 括弧判定より優先することで全 stopchar を正しく処理できる。
            if not stack and ch == stopchar:
                # 深さ0 かつ stopchar → ここで式を終端。
                # NUL を挿入したら残りの文字は追加しない（stopchar 以降が
                # result に混入すると expression() が誤った位置で継続する）。
                result.append(chr(0))
                break
            elif ch in OPEN_TO_CLOSE:
                # 開き括弧: スタックに積んで出力
                stack.append(ch)
                result.append(ch)
            elif ch in CLOSE_CHARS:
                if stack and OPEN_TO_CLOSE.get(stack[-1]) == ch:
                    # 対応する開き括弧と一致 → ネストを1段抜ける
                    stack.pop()
                    result.append(ch)
                else:
                    # 対応不一致の閉じ括弧（不正な入力）はそのまま出力
                    result.append(ch)
            else:
                result.append(ch)

        replaced = ''.join(result)
        return self.expression(self._terminate(replaced), idx)

    def expression_esc_float(self,s,idx,stopchar):
        # Fix 6: exp_typ だけでなく expmode も保存・復元する。
        # expression_esc 内部で expmode を変更するコードが呼ばれると
        # 呼び出し元に戻ったとき expmode が変わったままになる。
        prev_typ  = self.state.exp_typ
        prev_mode = self.state.expmode
        self.state.exp_typ = 'f'
        try:
            v,idx = self.expression_esc(s,idx,stopchar)
        finally:
            self.state.exp_typ  = prev_typ
            self.state.expmode  = prev_mode
        return (v,idx)


class BinaryWriter:
    """Handles binary output to files"""
    
    def __init__(self, state):
        self.state = state
        self._buffer = {}   # {position: byte_value} のランダムアクセスバッファ
    
    def _store(self, position, word_val):
        """ワード単位でバッファに格納"""
        # Fix: bts <= 0 はマスクが 0 になりデータが全ゼロになる。
        # fwrite でもガードしているが、将来の直接呼び出し経路に備えて二重防護する。
        if self.state.bts <= 0:
            return
        # Fix(new): 負のアドレスは bytearray インデックス計算を壊す。早期リターンする。
        if position < 0:
            return
        # 11ビットなら 0x7ff でマスクして格納
        mask = (1 << self.state.bts) - 1
        self._buffer[position] = word_val & mask
    
    def flush(self):
        """バッファをファイルに書き出す"""
        if not self.state.outfile or not self._buffer:
            return

        # Fix 6 (new): bts == 0 の場合は bytes_per_word = 0 になり出力が空になる。
        # サイレントな空ファイル生成を防ぐため、明示的に警告を出して早期リターンする。
        if self.state.bts <= 0:
            print(f" warning - flush: bts={self.state.bts} is invalid (<=0); "
                  f"output file '{self.state.outfile}' will be empty.", file=sys.stderr)
            return

        # Fix ⑧修正: bts == 0 の場合は bytes_per_word = 0 になり
        # total_size = 0 → data[base_idx + i] への書き込みで IndexError が発生する。
        # .bits 0 のような不正な設定を早期検出してエラーを出す。
        if self.state.bts <= 0:
            print(f" error - bts (word bit width) is {self.state.bts}; cannot write output.",
                  file=__import__('sys').stderr)
            return

        # Fix(new): 負のキーが混入している場合はスキップして安全に処理する。
        # _store でもガードしているが、旧バージョンのバッファが持ち越された場合への防護。
        valid_buffer = {k: v for k, v in self._buffer.items() if k >= 0}
        if not valid_buffer:
            return

        max_word_pos = max(valid_buffer.keys())
        
        # 1ワードあたりに必要なバイト数を計算 (例: 11bit -> 2bytes)
        word_bits = self.state.bts
        bytes_per_word = (word_bits + 7) // 8
        
        total_size = (max_word_pos + 1) * bytes_per_word

        # Fix(new): total_size が 0 以下になる場合（全キーが負など）は書き出しスキップ。
        if total_size <= 0:
            return

        # Fix: total_size が非常に大きい場合（例: .ORG で PC を巨大値にセット後に出力）
        # bytearray(total_size) がメモリ不足でクラッシュする。現実的な上限を設ける。
        _MAX_OUTPUT_BYTES = 1 << 30  # 1 GB
        if total_size > _MAX_OUTPUT_BYTES:
            print(f" error - output size {total_size} bytes exceeds maximum {_MAX_OUTPUT_BYTES}. "
                  f"Check for incorrect .ORG or address values.",
                  file=__import__('sys').stderr)
            return

        # 修正8: .padding で設定した state.padding 値で全ワードを初期化してから
        # 実際に書き込まれたワードで上書きする。
        # Fix (perf): 1ワードのバイトパターンを bytes で構築してから *repeat で
        # 全バッファを一括初期化する。Python ループより大幅に速い。
        # pad_bytes の長さは bytes_per_word なので
        # len(pad_bytes) * (max_word_pos+1) == total_size が常に成立する。
        pad_val = int(self.state.padding) & ((1 << word_bits) - 1)
        if pad_val != 0:
            tmp = pad_val
            if self.state.endian == 'little':
                pad_bytes = bytes([(tmp >> (8 * i)) & 0xff for i in range(bytes_per_word)])
            else:
                pad_bytes = bytes([(tmp >> (8 * (bytes_per_word - 1 - i))) & 0xff
                                   for i in range(bytes_per_word)])
            data = bytearray(pad_bytes * (max_word_pos + 1))
        else:
            data = bytearray(total_size)

        for pos, val in valid_buffer.items():
            # 書き込み先のバイト位置を特定
            base_idx = pos * bytes_per_word
            
            # エンディアンに基づいてバイト列に変換
            temp_val = val
            if self.state.endian == 'little':
                for i in range(bytes_per_word):
                    if base_idx + i < total_size:
                        data[base_idx + i] = temp_val & 0xff
                        temp_val >>= 8
            else:
                for i in range(bytes_per_word - 1, -1, -1):
                    if base_idx + i < total_size:
                        data[base_idx + i] = temp_val & 0xff
                        temp_val >>= 8
                        
        with open(self.state.outfile, 'wb') as f:
            f.write(data)

    def fwrite(self, position, x, prt):
        """1ワードをバッファへ書き込み"""
        # Fix: bts <= 0 の場合はマスクが 0 になりデータが全ゼロになる。
        # flush() にはガードがあるが fwrite 自体には なかったので早期リターンする。
        if self.state.bts <= 0:
            return 0
        # デバッグ表示用のマスク
        mask = (1 << self.state.bts) - 1
        val = x & mask
        
        if prt:
            b = self.state.bts
            colm = (b + 3) // 4  # bビットを16進表示するのに必要な桁数（切り上げ）
            print(f" 0x{val:0{colm}x}", end='')

        self._store(position, val)
        return 1 # 1ワード書き込んだことを返す

    def outbin2(self, a, x):
        """Output binary without printing"""
        if self.state.pas == 2 or self.state.pas == 0:
            try:
                self.fwrite(a, int(x), 0)
            except (OverflowError, ValueError):
                if self.state.pas == 2 or self.state.pas == 0:
                    print(f" error - non-finite value {x!r} cannot be written as binary word.")

    def outbin(self, a, x):
        """Output binary with printing"""
        if self.state.pas == 2 or self.state.pas == 0:
            # -v オプション対応: ファイルアセンブル時 (pas==2) は verbose のときのみ hex 表示。
            # 対話モード (pas==0) は常に表示する。
            _prt = 1 if ((self.state.pas == 2 and self.state.verbose) or self.state.pas == 0) else 0
            try:
                self.fwrite(a, int(x), _prt)
            except (OverflowError, ValueError):
                if self.state.pas == 2 or self.state.pas == 0:
                    print(f" error - non-finite value {x!r} cannot be written as binary word.")
    
    def align_(self, addr):
        """Align address"""
        # Fix 6/15: state.align == 0（.ALIGN 0 や初期化ミスなど）の場合、
        # addr % 0 で ZeroDivisionError が発生する。
        # 0 以下のアライメント値はアライメントなし（そのまま返す）として扱う。
        if self.state.align <= 0:
            return addr
        a = addr % self.state.align
        if a == 0:
            return addr
        return addr + self.state.align - a


class DirectiveProcessor:
    """Processes assembler directives"""
    
    def __init__(self, state, expr_eval, binary_writer):
        self.state = state
        self.expr_eval = expr_eval
        self.binary_writer = binary_writer
    
    def add_avoiding_dup(self, l, e):
        """Add element to list avoiding duplicates"""
        if e not in l:
            l.append(e)
        return l
    
    def clear_symbol(self, i):
        """Clear symbol directive"""
        if len(i) == 0 or i[0] != '.clearsym':
            return False
        
        if len(i) >= 3 and i[2] != '':
            key = StringUtils.upper(i[2]) # This is an abbreviation for field 1, so this is OK.
            self.state.symbols.pop(key, None)
        else:
            self.state.symbols = {}
        
        return True
    
    def set_symbol(self, i):
        """Set symbol directive"""
        if len(i) == 0 or i[0] != '.setsym':
            return False
        
        # 引数チェック: 少なくとも .setsym KEY が必要
        if len(i) < 2:
            print(f" error - .setsym directive requires at least a symbol name")
            return False
        
        key = StringUtils.upper(i[1])
        if len(i) > 2:
            v, idx = self.expr_eval.expression_pat(i[2], 0)
        else:
            v = 0
        self.state.symbols[key] = v
        return True
    
    def bits(self, i):
        """Bits directive"""
        if len(i) == 0 or i[0] != '.bits':
            return False
        
        # Fix ④: エンディアンは 'big' / 'little' が明示指定された場合のみ変更する。
        # 旧実装は i[1] が 'big' 以外のとき無条件に 'little' に上書きしていたため、
        # '.bits 16' のようにビット幅だけ指定するとエンディアンが変わってしまっていた。
        if len(i) >= 2:
            if i[1].lower() == 'big':
                self.state.endian = 'big'
            elif i[1].lower() == 'little':
                self.state.endian = 'little'
            # それ以外 (数値等) はビット幅として後続の処理に渡す。エンディアン変更なし。
        
        # Fix 3: エンディアン指定のみ (.bits big / .bits little) の場合は
        # bts を変更しない。旧実装は else: v=8 で無条件に 8 に上書きしていた。
        v = None
        if len(i) >= 3:
            v, idx = self.expr_eval.expression_pat(i[2], 0)
        elif len(i) >= 2 and i[1].lower() not in ('big', 'little'):
            # 引数が1つでエンディアン指定でない場合はそれがビット幅
            v, idx = self.expr_eval.expression_pat(i[1], 0)
        if v is not None:
            try:
                self.state.bts = int(v)
            except (OverflowError, ValueError):
                print(f" error - .bits: non-finite bit width value.")
        return True
    
    def paddingp(self, i):
        """Padding directive"""
        if len(i) == 0 or i[0] != '.padding':
            return False
        
        # Fix 6 (new): パターン行のフィールド配置は
        #   i[0]=cmd, i[1]=error式, i[2]=obj式（padding値）
        # だが、省略形 `.padding :: value` では i[1]='value', i[2] が欠如する。
        # 旧実装は i[2] だけ見ていたため省略形では常に v=0 になっていた。
        # 修正: i[2] が存在する場合は i[2] を、そうでなければ i[1] を値として読む。
        if len(i) >= 3 and i[2] != '':
            v, idx = self.expr_eval.expression_pat(i[2], 0)
        elif len(i) >= 2 and i[1] != '':
            v, idx = self.expr_eval.expression_pat(i[1], 0)
        else:
            v = 0
        try:
            self.state.padding = int(v)
        except (OverflowError, ValueError):
            print(f" error - .padding: non-finite or invalid value; padding unchanged.")
        return True
    
    def symbolc(self, i):
        """Symbol characters directive"""
        if len(i) == 0 or i[0] != '.symbolc':
            return False
        
        if len(i) > 2 and i[2] != '':
            self.state.swordchars = ALPHABET + DIGIT + i[2]
        return True
    
    def vliwp(self, i):
        """VLIW directive"""
        if len(i) == 0 or i[0] != ".vliw":
            return False
        
        # 引数チェック: .vliw には5つのパラメータが必要
        if len(i) < 5:
            print(f" error - .vliw directive requires 4 parameters (vliwbits, vliwinstbits, vliwtemplatebits, nop_value), got {len(i)-1}")
            return False
        
        v1, idx = self.expr_eval.expression_pat(i[1], 0)
        v2, idx = self.expr_eval.expression_pat(i[2], 0)
        v3, idx = self.expr_eval.expression_pat(i[3], 0)
        v4, idx = self.expr_eval.expression_pat(i[4], 0)

        # Fix: v1/v2/v3 が非有限 float のとき int() は OverflowError になる。
        try:
            self.state.vliwbits        = int(v1)
            self.state.vliwinstbits    = int(v2)
            self.state.vliwtemplatebits = int(v3)
        except (OverflowError, ValueError):
            print(f" error - .vliw: non-finite parameter value.")
            return False
        self.state.vliwflag = True
        
        l = []
        # Fix ⑦: ループ変数を `_byte_idx` に変更して引数 `i` のシャドウイングを解消する。
        for _byte_idx in range(self.state.vliwinstbits // 8 + (0 if self.state.vliwinstbits % 8 == 0 else 1)):
            l += [v4 & 0xff]
            v4 >>= 8
        self.state.vliwnop = l
        return True
    
    def epic(self, i):
        """EPIC directive"""
        if len(i) == 0 or StringUtils.upper(i[0]) != "EPIC":
            return False
        
        if len(i) <= 1 or i[1] == '':
            return False
        
        # 引数チェック: EPIC には少なくとも2つのパラメータが必要
        if len(i) < 3:
            print(f" error - EPIC directive requires 2 parameters (indices, pattern), got {len(i)-1}")
            return False
        
        s = i[1]
        idxs = []
        idx = 0
        while True:
            v, idx = self.expr_eval.expression_pat(s, idx)
            idxs += [v]
            if idx < len(s) and s[idx] == ',':
                idx += 1
                continue
            break
        
        s2 = i[2]
        self.state.vliwset = self.add_avoiding_dup(self.state.vliwset, [idxs, s2])
        return True
    
    def error(self, s):
        """Process error directive.

        Fix 10: error_code はローカル変数に代入するだけで戻り値がなく、
        呼び出し元でエラーを検知できなかった。
        戻り値として (triggered: bool, code: int) を返すよう変更する。

        Fix (new): expression_pat がパース不能な文字（')' など）に当たると
        idx を進めないまま返すため、while True ループが永遠に抜けられない
        無限ループになっていた。各イテレーションで idx が進んだかを確認し、
        進まなかった場合は残りをスキップして終了する。
        """
        ss = s.replace(' ', '')
        if ss == "":
            return False, 0
        
        s += chr(0)
        idx = 0
        error_code = 0
        triggered = False
        
        while True:
            ch = s[idx] if idx < len(s) else chr(0)
            if ch == chr(0):
                break
            if ch == ',':
                idx += 1
                continue
            
            idx_before = idx   # Fix: 進捗チェック用に保存
            prev_typ = self.expr_eval.state.exp_typ
            self.expr_eval.state.exp_typ = 'f'
            try:
                u, idxn = self.expr_eval.expression_pat(s, idx)
                idx = idxn
                if idx < len(s) and s[idx] == ';':
                    idx += 1
                # Fix 8: エラーコード式（t）も同じ exp_typ='f' コンテキストで評価する。
                # 旧実装は u の評価後に exp_typ を元に戻してから t を評価していたため、
                # expmode/exp_typ の混在状態が生じ、整数リテラルのコードが float 解析に
                # 切り替わらないケースがあった。
                t, idx = self.expr_eval.expression_pat(s, idx)
            finally:
                self.expr_eval.state.exp_typ = prev_typ
            
            # Fix: idx が全く進まなかった → パース不能文字で無限ループになる。
            # 残りの文字を読み飛ばして終了する。
            if idx <= idx_before:
                break

            if (self.state.pas == 2 or self.state.pas == 0) and u:
                t_int = int(t)
                print(f"Line {self.state.ln} Error code {t_int} ", end="")
                if 0 <= t_int < len(ERRORS):
                    print(f"{ERRORS[t_int]}", end='')
                print(": ")
                error_code = t_int
                triggered = True

        return triggered, error_code


class PatternMatcher:
    """Handles pattern matching for assembly instructions"""
    
    def __init__(self, state, expr_eval, var_manager, symbol_manager, parser):
        self.state = state
        self.expr_eval = expr_eval
        self.var_manager = var_manager
        self.symbol_manager = symbol_manager
        self.parser = parser
    
    def remove_brackets(self, s, l):
        """Remove specified bracket pairs.

        修正3: 旧実装はネスト深度 (open_count) をグループIDとして使っていた。
        これだと兄弟関係にある [[A]] [[B]] は両方 open_count==1 になり、
        個別に指定できなかった。

        修正後: OB を見るたびに単調増加するシリアル番号を割り当て、
        スタックで対応する CB と紐付ける。
        remove_brackets(t, [1,3]) は「シリアル1番と3番のグループを除去せよ」
        という意味になり、どの兄弟でも正しく個別指定できる。
        match0 が渡す l のシリアルは 1-origin の連番 (sl = [1,2,...,cnt]) なので
        この変更と完全に対応している。
        """
        # --- シリアル番号と文字位置の対応表を構築 ---
        serial = 0          # 次に割り当てるシリアル
        stack = []          # (serial, open_pos) のスタック
        bracket_pairs = {}  # serial -> (open_pos, close_pos)

        for i, char in enumerate(s):
            if char == OB:
                serial += 1
                stack.append((serial, i))
            elif char == CB:
                if stack:
                    ser, open_pos = stack.pop()
                    bracket_pairs[ser] = (open_pos, i)

        # --- l に含まれるシリアルのグループを除去 ---
        result = list(s)
        for index in l:
            if index in bracket_pairs:
                start_pos, end_pos = bracket_pairs[index]
                for j in range(start_pos, end_pos + 1):
                    result[j] = ''

        return ''.join(result)
    
    def match(self, s, t):
        """Match assembly line against pattern"""
        self.state.deb1 = s
        self.state.deb2 = t
        
        t = t.replace(OB, '').replace(CB, '')
        idx_s = 0
        idx_t = 0
        idx_s = StringUtils.skipspc(s, idx_s)
        idx_t = StringUtils.skipspc(t, idx_t)
        s += chr(0)
        t += chr(0)
        
        while True:
            idx_s = StringUtils.skipspc(s, idx_s)
            idx_t = StringUtils.skipspc(t, idx_t)
            b = s[idx_s]
            a = t[idx_t]
            
            if a == chr(0) and b == chr(0):
                return True
            
            if a == '\\':
                idx_t += 1
                if idx_t < len(t) and t[idx_t] == b:
                    idx_t += 1
                    idx_s += 1
                    continue
                else:
                    return False
            elif a in CAPITAL:   # Fix: isupper() はUnicode大文字も含むため CAPITAL で限定
                if a == b.upper():
                    idx_s += 1
                    idx_t += 1
                    continue
                else:
                    return False
            elif a == '!':
                idx_t += 1
                # Fix 1: パターンが '!' で終端している場合の IndexError を防ぐ
                if idx_t >= len(t):
                    return False
                a = t[idx_t]
                idx_t += 1
                # Fix 1b: '!' の直後が NUL（番兵）や無効文字の場合は不正パターン
                # a が chr(0) のまま else 分岐に流れると番兵を消費してループが壊れる
                if a == chr(0):
                    return False
                if a == 'F':
                    # Fix 2a: !F の変数名取得前に境界チェック
                    if idx_t >= len(t):
                        return False
                    a = t[idx_t]
                    # Fix 2a-2: 変数名が NUL または無効文字なら不正パターン
                    if a == chr(0) or a not in LOWER:
                        return False
                    idx_t = StringUtils.skipspc(t, idx_t+1)
                    if idx_t < len(t) and t[idx_t] == '\\':
                        idx_t += 1                                    # skip '\'
                        stopchar = t[idx_t] if idx_t < len(t) else chr(0)
                        idx_t += 1                                    # skip stopchar in pattern
                    else:
                        stopchar = chr(0)

                    # Fix: expression_esc_float が例外を投げても _elf_capturing_var が
                    # True のまま残らないよう try/finally でリセットを保証する。
                    # !F は整数キャプチャではないのでキャプチャ変数は設定不要だが、
                    # 将来の変更に備えて他ブランチと対称なパターンにしておく。
                    try:
                        v, idx_s = self.expr_eval.expression_esc_float(s, idx_s, stopchar)
                    finally:
                        self.state._elf_capturing_var = None
                    # Fix: UNDEF や非有限値が渡ると float() や struct.pack で
                    # OverflowError / struct.error が発生する。安全に 0 にフォールバック。
                    try:
                        v = float(v)
                        v = int.from_bytes(struct.pack('>f', v), "big")
                    except (OverflowError, ValueError, struct.error):
                        if self.state.pas == 2 or self.state.pas == 0:
                            print(f" error - !F: cannot convert value to float32; using 0.")
                        v = 0
                    self.var_manager.put(a, v)
                    # consume stopchar from source as well
                    if stopchar != chr(0) and idx_s < len(s) and s[idx_s] == stopchar:
                        idx_s += 1
                    continue
                elif a == 'D':
                    # Fix 2b: !D の変数名取得前に境界チェック
                    if idx_t >= len(t):
                        return False
                    a = t[idx_t]
                    # Fix 2b-2: 変数名が NUL または無効文字なら不正パターン
                    if a == chr(0) or a not in LOWER:
                        return False
                    idx_t = StringUtils.skipspc(t, idx_t+1)
                    if idx_t < len(t) and t[idx_t] == '\\':
                        idx_t += 1                                    # skip '\'
                        stopchar = t[idx_t] if idx_t < len(t) else chr(0)
                        idx_t += 1                                    # skip stopchar in pattern
                    else:
                        stopchar = chr(0)

                    # Fix: expression_esc_float が例外を投げても _elf_capturing_var が
                    # True のまま残らないよう try/finally でリセットを保証する。
                    try:
                        v, idx_s = self.expr_eval.expression_esc_float(s, idx_s, stopchar)
                    finally:
                        self.state._elf_capturing_var = None
                    # Fix: UNDEF や非有限値が渡ると float() や struct.pack で
                    # OverflowError / struct.error が発生する。安全に 0 にフォールバック。
                    try:
                        v = float(v)
                        v = int.from_bytes(struct.pack('>d', v), "big")
                    except (OverflowError, ValueError, struct.error):
                        if self.state.pas == 2 or self.state.pas == 0:
                            print(f" error - !D: cannot convert value to float64; using 0.")
                        v = 0
                    self.var_manager.put(a, v)
                    # consume stopchar from source as well
                    if stopchar != chr(0) and idx_s < len(s) and s[idx_s] == stopchar:
                        idx_s += 1
                    continue
                elif a == 'Q':
                    # !Q<var> : ソースから浮動小数点式を読み取り、
                    # IEEE754 128ビット(quad)整数ビットパターンとして変数に格納する
                    # Fix 2c: !Q の変数名取得前に境界チェック
                    if idx_t >= len(t):
                        return False
                    a = t[idx_t]
                    # Fix 2c-2: 変数名が NUL または無効文字なら不正パターン
                    if a == chr(0) or a not in LOWER:
                        return False
                    idx_t = StringUtils.skipspc(t, idx_t+1)
                    if idx_t < len(t) and t[idx_t] == '\\':
                        idx_t += 1                                    # skip '\'
                        stopchar = t[idx_t] if idx_t < len(t) else chr(0)
                        idx_t += 1                                    # skip stopchar in pattern
                    else:
                        stopchar = chr(0)

                    # ソーステキストの開始位置を記録
                    idx_s_q_start = idx_s

                    # float モードで式の終端位置を検出
                    # Fix: expression_esc_float が例外を投げても _elf_capturing_var が残留しないよう
                    # try/finally で確実に None に戻す。
                    try:
                        v, idx_s_after = self.expr_eval.expression_esc_float(s, idx_s, stopchar)
                    finally:
                        self.state._elf_capturing_var = None

                    # stopchar 手前までのソーステキストを抽出
                    raw_text = s[idx_s_q_start:idx_s_after]
                    # stopchar が末尾に含まれていれば除去
                    if stopchar != chr(0) and raw_text.endswith(stopchar):
                        raw_text = raw_text[:-1]
                    raw_text = raw_text.strip()

                    # qad{...} ラッパーを剥がす（!Q qad{3.14*2+1} と書かれた場合）
                    if raw_text.startswith('qad{') and raw_text.endswith('}'):
                        raw_text = raw_text[4:-1].strip()

                    try:
                        h = IEEE754Converter.decimal_eval_expr(raw_text)
                    except (ValueError, ZeroDivisionError):
                        # Decimal 評価不能（ラベル参照など）。
                        # v は expression_esc_float の戻り値（Python int か float）。
                        # ・整数値 → Decimal(int) で完全精度（ラベルアドレスは整数なので典型的にこちら）
                        # ・float 値 → repr() で53bit分の最大桁数を使用（精度損失は避けられない）
                        if isinstance(v, int) or (
                                isinstance(v, float) and v.is_integer()):
                            h = IEEE754Converter.decimal_to_ieee754_128bit_hex(
                                    str(int(v)))
                        else:
                            h = IEEE754Converter.decimal_to_ieee754_128bit_hex(
                                    repr(float(v)))

                    x = int(h, 16)
                    self.var_manager.put(a, x)
                    idx_s = idx_s_after
                    # consume stopchar from source as well
                    if stopchar != chr(0) and idx_s < len(s) and s[idx_s] == stopchar:
                        idx_s += 1
                    continue
                elif a == '!':
                    # Fix 2d: !! の変数名取得前に境界チェック
                    if idx_t >= len(t):
                        return False
                    a = t[idx_t]
                    # Fix 2d-2: 変数名が NUL または無効文字なら不正パターン
                    if a == chr(0) or a not in LOWER:
                        return False
                    idx_t += 1
                    # ELF追跡: !!a（factor キャプチャ）
                    # Fix: factor() が例外を投げても _elf_capturing_var が残留しないよう
                    # try/finally で確実に None に戻す。
                    self.state._elf_capturing_var = a
                    try:
                        v, idx_s = self.expr_eval.factor(s, idx_s)
                    finally:
                        self.state._elf_capturing_var = None
                    self.var_manager.put(a, v)
                    continue
                else:
                    # Fix 1c: else 分岐の変数名 a も NUL/無効文字チェック
                    # （'!' の直後に stopchar指定なし の通常キャプチャ）
                    if a == chr(0) or a not in LOWER:
                        return False
                    idx_t = StringUtils.skipspc(t, idx_t)
                    if idx_t < len(t) and t[idx_t] == '\\':
                        idx_t += 1                                    # skip '\'
                        stopchar = t[idx_t] if idx_t < len(t) else chr(0)
                        idx_t += 1                                    # skip stopchar in pattern
                    else:
                        stopchar = chr(0)

                    # ELF追跡: !a（expression キャプチャ）
                    # Fix: expression_esc() が例外を投げても _elf_capturing_var が残留しないよう
                    # try/finally で確実に None に戻す。
                    self.state._elf_capturing_var = a
                    try:
                        v, idx_s = self.expr_eval.expression_esc(s, idx_s, stopchar)
                    finally:
                        self.state._elf_capturing_var = None
                    self.var_manager.put(a, v)
                    # consume stopchar from source as well
                    if stopchar != chr(0) and idx_s < len(s) and s[idx_s] == stopchar:
                        idx_s += 1
                    continue
            elif a in LOWER:
                idx_t += 1
                prev_idx_s = idx_s
                w, idx_s = self.parser.get_symbol_word(s, idx_s)
                v = self.symbol_manager.get(w)
                if v == "":
                    return False
                # Fix 5 (new): get_symbol_word がソース位置を進めなかった場合
                # （ソース側が空白やNULなど）、continue するとループが止まらなくなる。
                # idx_s が変化しなければマッチ失敗として扱う。
                if idx_s == prev_idx_s:
                    return False
                self.var_manager.put(a, v)
                continue
            elif a == b:
                idx_t += 1
                idx_s += 1
                continue
            else:
                return False
    
    def match0(self, s, t):
        """Match with optional bracket combinations.

        各 match() 試行の前に vars をスナップショットし、
        マッチ失敗した試行で書き込まれた変数値を必ずリストアする。
        これにより、失敗した組み合わせの副作用が次の試行に持ち越されない。
        """
        t = t.replace('[[', OB).replace(']]', CB)
        cnt = t.count(OB)
        sl = [_ + 1 for _ in range(cnt)]

        # Fix: cnt が大きいとき組み合わせ数は 2^cnt になり事実上無限ループになる。
        # 現実のパターンファイルで [[]] が 20 を超えることはないため上限を設ける。
        _MAX_OPT_GROUPS = 20
        if cnt > _MAX_OPT_GROUPS:
            if self.state.pas == 2 or self.state.pas == 0:
                print(f" warning - pattern has {cnt} optional groups (max {_MAX_OPT_GROUPS}); "
                      f"truncating to avoid combinatorial explosion.")
            sl = sl[:_MAX_OPT_GROUPS]
            cnt = _MAX_OPT_GROUPS

        for i in range(len(sl) + 1):
            ll = list(itertools.combinations(sl, i))
            for j in ll:
                lt = self.remove_brackets(t, list(j))
                # マッチ前の vars を保存
                saved_vars = self.state.vars[:]
                # Fix ④ / Fix 8: ELF追跡状態も保存する。
                # _elf_label_refs_seen はリスト全体コピーでなく長さだけ記録し、
                # 失敗時は del [n:] でロールバック（term11と同方式でコピー負荷を削減）。
                saved_refs_len = len(self.state._elf_label_refs_seen)
                saved_v2l      = dict(self.state._elf_var_to_label)
                if self.match(s, lt):
                    return True
                # 失敗 → vars と ELF 追跡状態をリストア
                self.state.vars = saved_vars
                del self.state._elf_label_refs_seen[saved_refs_len:]
                self.state._elf_var_to_label = saved_v2l
        return False


class PatternFileReader:
    """Reads and processes pattern files"""
    
    def __init__(self, parser):
        self.parser = parser
    
    def readpat(self, fn, base_dir=None, _depth=0):
        """Read pattern file.

        base_dir: 呼び出し元パターンファイルのディレクトリ。
        None のときはプロセスの CWD を基準にする（トップレベル呼び出し）。
        相対パスの fn は base_dir（または CWD）を基準に解決する。

        戻り値: パターンエントリのリスト。ファイルが存在しない・読めない場合は例外を伝播する。
        """
        if fn == '':
            return []

        # Fix: 深い .INCLUDE ネストは RecursionError になる。現実的な上限を設ける。
        _MAX_PAT_DEPTH = 50
        if _depth > _MAX_PAT_DEPTH:
            print(f" error - pattern .INCLUDE nesting exceeds {_MAX_PAT_DEPTH}: '{fn}'")
            return []
        
        # 相対パスを解決する
        if base_dir and not os.path.isabs(fn):
            fn = os.path.join(base_dir, fn)
        
        # このファイルと同じディレクトリを、再帰的な .INCLUDE の基準にする
        this_dir = os.path.dirname(os.path.abspath(fn))
        
        p = []
        w = []
        with open(fn, "rt") as f:
            while True:
                l = f.readline()
                if not l:
                    break
                
                l = StringUtils.remove_comment(l)
                l = l.replace('\t', ' ')
                l = l.replace(chr(13), '')
                l = l.replace('\n', '')
                l = StringUtils.reduce_spaces(l)
                
                ww = self.include_pat(l, this_dir, _depth=_depth + 1)
                if ww is not None:   # Fix: None=非.INCLUDE行, []=空/エラー, list=パターン
                    w = w + ww
                    continue
                else:
                    r = []
                    idx = 0
                    while True:
                        s, idx = self.parser.get_params1(l, idx)
                        r += [s]
                        if len(l) <= idx:
                            break
                    l = r
                    
                    if len(l) == 1:
                        p = [l[0], '', '', '', '', '']
                    elif len(l) == 2:
                        p = [l[0], '', l[1], '', '', '']
                    elif len(l) == 3:
                        p = [l[0], l[1], l[2], '', '', '']
                    elif len(l) == 4:
                        p = [l[0], l[1], l[2], l[3], '', '']
                    elif len(l) == 5:
                        p = [l[0], l[1], l[2], l[3], l[4], '']
                    elif len(l) == 6:
                        p = [l[0], l[1], l[2], l[3], l[4], l[5]]
                    else:
                        # Fix 11: フィールドが7個以上の行はサイレントに切り捨てていた。
                        # パターンファイルの書き間違い（区切り文字ミス等）を検出するため
                        # 警告を出力する。
                        print(f" warning - pattern line has more than 6 fields "
                              f"(extra fields ignored): {l[6:]!r}")
                        p = [l[0], l[1], l[2], l[3], l[4], l[5]]
                    w.append(p)
        
        return w
    
    def include_pat(self, l, base_dir=None, _depth=0):
        """Include pattern directive.

        修正7: 旧実装は StringUtils.skipspc で先頭スペースをスキップして
        idx を求めておきながら、ファイル名の抽出に固定オフセット l[8:] を
        使っていた。インデントがある行（例: "  .INCLUDE foo.axx"）では
        l[8:] が .INCLUDE 文字列の途中から始まってしまいファイル名を
        正しく取り出せなかった。
        修正後: l[idx+8:] を使い、スキップ後の先頭位置から 8 文字
        (.INCLUDE) 分進んだ位置からファイル名を読み取る。

        修正5: ファイル名は base_dir を基準に解決する。

        修正⑥: get_string() がファイル名の取得に失敗した場合（クォート抜けなど）
        は空リストをサイレントに返さずエラーを表示する。

        Fix (new): 旧実装は戻り値が [] のとき「.INCLUDE 行でない」と「空ファイルを
        インクルード」の両方を区別できず、後者のとき .INCLUDE 行が通常パターンとして
        再解析される問題があった。
        修正: .INCLUDE にマッチしなかった場合は None を返し、呼び出し元で None と
        空リストを区別する。マッチして空ファイルだった場合は [] を返す。
        """
        idx = StringUtils.skipspc(l, 0)
        i = l[idx:idx+8]
        i = i.upper()
        if i != ".INCLUDE":
            return None   # Fix: マッチなしは None で返す（空リストと区別）
        s = StringUtils.get_string(l[idx+8:])
        if s == "":
            # get_string が失敗した（引用符がないか空文字列）
            raw = l[idx+8:].strip()
            if raw:
                # 引用符なしでファイル名が書かれているかもしれない。
                # スペースまでをファイル名として試みる（緩やかなフォールバック）。
                fallback, _ = StringUtils.get_param_to_spc(raw, 0)
                if fallback:
                    import sys as _sys
                    print(f" warning - .INCLUDE filename not quoted: {fallback!r}. "
                          "Please use double quotes.", file=_sys.stderr)
                    s = fallback
                else:
                    print(f" error - .INCLUDE directive has no filename: {l!r}")
                    return []   # マッチしたがエラー → 空リスト
            else:
                print(f" error - .INCLUDE directive has no filename: {l!r}")
                return []   # マッチしたがエラー → 空リスト
        w = self.readpat(s, base_dir, _depth=_depth)
        return w   # 空ファイルなら [] だが呼び出し元で区別される


class ObjectGenerator:
    """Generates object code from expressions"""
    
    def __init__(self, state, expr_eval, binary_writer):
        self.state = state
        self.expr_eval = expr_eval
        self.binary_writer = binary_writer
    
    def replace_percent_with_index(self, s):
        """Replace %% with sequential numbers starting from 0"""
        count = 0
        result = []
        i = 0
        while i < len(s):
            if i + 1 < len(s) and s[i:i+2] == '%%':
                result.append(str(count))
                count += 1
                i += 2
            elif i+1<len(s) and s[i:i+2] == "%0":
                count = 0
                i += 2
            else:
                result.append(s[i])
                i += 1
        return ''.join(result)

    def e_p(self, pattern):
        """Expand @@[n,pattern] syntax"""
        result = []
        has_content = False
        i = 0
        while i < len(pattern):
            if i + 3 <= len(pattern) and pattern[i:i+3] == '@@[':
                # @@[ found
                i += 3
                depth = 1
                expr_start = i
                comma_pos = -1
                
                while i < len(pattern) and depth > 0:
                    if pattern[i] == '[':
                        depth += 1
                    elif pattern[i] == ']':
                        depth -= 1
                        if depth == 0:
                            break
                    elif pattern[i] == ',' and depth == 1 and comma_pos == -1:
                        comma_pos = i
                    i += 1
                
                # Bugfix: 旧コメントは「comma_pos > 0」が不要と指摘していたが
                # 実装は直していなかった。`comma_pos >= 0` が正しい条件。
                # -1 は「カンマ未発見」を意味し、0 はパターン先頭にカンマが
                # ある合法なケース（@@[,pattern] で式が空 → n=0 として展開しない）。
                # comma_pos >= expr_start だけで「カンマが式開始位置より後にある」
                # ことを保証できるため、二重条件は不要だった。
                if comma_pos >= 0 and comma_pos >= expr_start:
                    expr = pattern[expr_start:comma_pos]
                    rep_pattern = pattern[comma_pos+1:i]
                    
                    # Evaluate expression
                    # 修正: 直前の処理でerror_undefined_labelが残っている場合に
                    # n=0と誤判定されるのを防ぐため、評価前にリセットする。
                    self.state.error_undefined_label = False
                    n, idx = self.expr_eval.expression_pat(expr, 0)
                    # Fix: 未定義ラベルや UNDEF 由来の巨大値が n に入ると
                    # range(int(UNDEF)) が実質無限ループになりプロセスがハングする。
                    # error_undefined_label フラグと現実的な上限でガードする。
                    _N_MAX = 1 << 24  # 16M 回展開は非現実的
                    if self.state.error_undefined_label:
                        n = 0  # forward参照は 0 扱いにしてサイズ推定を続ける
                    try:
                        n_int = int(n)
                    except (ValueError, OverflowError):
                        n_int = 0
                    if n_int > _N_MAX:
                        if self.state.pas == 2 or self.state.pas == 0:
                            print(f" error - @@[n,...]: repeat count {n_int} exceeds maximum {_N_MAX}.")
                        n_int = 0
                    # Expand pattern n times
                    if n_int > 0:
                        n = n_int  # 以降は検証済みの整数を使う
                        has_content = True
                        for j in range(int(n)):
                            if j > 0:
                                result.append(',')
                            result.append(rep_pattern)
                    
                    i += 1  # Skip closing ]
                else:
                    result.append('@@[')
                    has_content = True
            else:
                result.append(pattern[i])
                has_content = True
                i += 1
        
        return ''.join(result), not has_content

    def makeobj(self, s):
        """Make object code from expression string"""
        # Expand @@[] and replace %%
        s,z = self.e_p(s)
        s = self.replace_percent_with_index(s)

        # 修正: ','の正規化（,,→,, strip(',')）を抑制する。
        # ','はbinary_listのセパレータであり、アライメント指示ではない。
        # @@[0,...]が空展開されても余分な処理は行わない。

        s += chr(0)
        idx = 0
        objl = []
        
        if z:
            return objl

        self.state._in_binary_list = True
        # e_p/replace_percent_with_index は前処理。ここで一度リセットしておき、
        # 直前の処理の残留フラグがループ内の判定を汚染しないようにする。
        self.state.error_undefined_label = False
        try:
            while True:
                if idx >= len(s) or s[idx] == chr(0):
                    break

                if s[idx] == ',':
                    # 修正: ','はセパレータのみ。アライメントパディングは挿入しない。
                    idx += 1
                    continue

                semicolon = False
                if s[idx] == ';':
                    semicolon = True
                    idx += 1

                self.state._elf_current_word_idx = len(objl)

                # pass==1では常に_pass1_size_modeで評価する。
                # 未定義ラベル(EXTERN等)があっても0として扱い、
                # @@[8,*(e,%%)]のような式でも8バイト分が正しく計上される。
                if self.state.pas == 1:
                    self.state._pass1_size_mode = True
                x, idx = self.expr_eval.expression_pat(s, idx)
                if self.state.pas == 1:
                    self.state._pass1_size_mode = False
                    self.state.error_undefined_label = False

                if (semicolon == True and x != 0) or (semicolon == False):
                    objl += [x]
                elif semicolon:
                    self.state._elf_label_refs_seen = [
                        e for e in self.state._elf_label_refs_seen
                        if e[2] != self.state._elf_current_word_idx
                    ]

                if idx < len(s) and s[idx] == ',':
                    idx += 1
                    continue
                break
        finally:
            # makeobj() を抜けたら必ずセンチネルに戻す（例外安全）
            self.state._elf_current_word_idx = -1
            self.state._in_binary_list = False
            if self.state.pas == 1:
                self.state._pass1_size_mode = False

        return objl


class VLIWProcessor:
    """Handles VLIW instruction processing"""
    
    def __init__(self, state, expr_eval, binary_writer):
        self.state = state
        self.expr_eval = expr_eval
        self.binary_writer = binary_writer
    
    def vliwprocess(self, line, idxs, objl, flag, idx, lineassemble2_func):
        """Process VLIW instruction"""
        objs = [objl]
        idxlst = [idxs]
        self.state.vliwstop = 0
        
        while True:
            idx = StringUtils.skipspc(line, idx)
            if idx + 4 <= len(line) and line[idx:idx+4] == '!!!!':
                idx += 4
                self.state.vliwstop = 1
                continue
            elif idx + 2 <= len(line) and line[idx:idx+2] == '!!':
                idx += 2
                # Bugfix: 旧実装は次スロット処理前に _elf_label_refs_seen を [] に
                # リセットしていた。これにより最初のスロットで収集した ELF 追跡データが
                # 消えてしまっていた。
                #
                # 実際には lineassemble() の finally ブロックが lineassemble2() 返却直後に
                # _elf_tracking = False にするため、2スロット目以降の lineassemble2_func
                # 呼び出しは _elf_tracking=False の状態で動作し、新たな追跡データは
                # 追加されない。そのため「スロット間の word_idx 混在」の危険はなく、
                # リセットは不要（かつ有害）だった。
                #
                # _elf_current_word_idx は makeobj() の finally が -1 に戻すので
                # ここでリセットしなくて構わない。_elf_capturing_var も同様。
                idxs, objl, flag, idx = lineassemble2_func(line, idx)
                # Fix J: lineassemble2_func が flag=False（エラー）を返した場合、
                # objl が空リストになるが objs/idxlst にそのまま追加すると
                # 後続の bytes 結合でスロット数がずれる。
                # flag=False のときは VLIW スロット全体をエラーとして中断する。
                if not flag:
                    return False
                objs += [objl]
                idxlst += [idxs]
                continue
            else:
                break
        
        if self.state.vliwtemplatebits == 0:
            self.state.vliwset = [[[0], "0"]]
        
        vbits = abs(self.state.vliwbits)

        # Fix ③: vliwinstbits が 0 の場合、noi の計算でゼロ除算が発生する。
        # .vliw ディレクティブで不正な値が渡された場合を想定してガードする。
        if self.state.vliwinstbits == 0:
            if self.state.pas == 0 or self.state.pas == 2:
                print(" error - vliwinstbits is zero; cannot compute instruction slots.")
            return False
        for k in self.state.vliwset:
            # Fix 5 (new): 旧実装は sorted(k[0]) == sorted(idxlst) で比較していたため
            # スロット順序が無視され、スロット1→2 の命令とスロット2→1 の命令が
            # 同じテンプレートにマッチしてしまい、順序依存テンプレートで誤バイナリが生成された。
            # 修正: list 同士を直接比較することで順序を保持した照合を行う。
            if list(k[0]) == list(idxlst) or self.state.vliwtemplatebits == 0:
                im = 2 ** self.state.vliwinstbits - 1
                tm = 2 ** abs(self.state.vliwtemplatebits) - 1
                pm = 2 ** vbits - 1
                x, idx = self.expr_eval.expression_pat(k[1], 0)
                templ = x & tm
                
                values = []
                nob = vbits // 8 + (0 if vbits % 8 == 0 else 1)
                ibyte = self.state.vliwinstbits // 8 + (0 if self.state.vliwinstbits % 8 == 0 else 1)
                noi = (vbits - abs(self.state.vliwtemplatebits)) // self.state.vliwinstbits
                
                for j in objs:
                    for m in j:
                        values += [m]
                
                # Fix ⑧: NOP 埋め処理は出力を伴わないが vliwnop バイトを
                # values に追加する。pass1 でも走ること自体は問題ないが、
                # values が変化することでリラクゼーション中の状態が不安定になるため
                # 補足ガードとして pass 情報を残す（実害は小さいが明示化する）。
                target_len = ibyte * noi
                if len(values) > target_len:
                    if self.state.pas == 2 or self.state.pas == 0:
                        print(f"warning-VLIW:{len(values)} values exceed slot capacity {target_len},truncating.")
                    values = values[:target_len]
                else:
                    # Bugfix: 旧実装は `range(target_len - len(values))` 回 vliwnop を追加
                    # していたが、vliwnop は ibyte 個のリストなので1回の追加で ibyte 個増える。
                    # 結果として (target_len - len(values)) * ibyte 個追加され、
                    # values が target_len の ibyte 倍まで膨れ上がっていた。
                    # その後の `values[:target_len]` 切り捨てで長さは戻るが、
                    # 内容は NOP ではなく命令バイトの繰り返しになるため誤ったバイナリが生成された。
                    #
                    # 正しい実装: 不足スロット数 = (target_len - len(values)) // ibyte 回追加。
                    # 端数バイト（ibyte で割り切れない不足分）は 0x00 で埋める。
                    _deficit = target_len - len(values)
                    _full_nops, _remainder = divmod(_deficit, ibyte) if ibyte > 0 else (0, _deficit)
                    for _ in range(_full_nops):
                        values += self.state.vliwnop
                    # 端数: vliwnop の先頭バイトで埋める（ibyte が割り切れない異常ケース）
                    if _remainder > 0:
                        values += (self.state.vliwnop + [0] * _remainder)[:_remainder]
                
                v1 = []
                cnt = 0
                
                for j in range(noi):
                    vv = 0
                    # Fix 4: バイト結合順をエンディアン設定に合わせる。
                    # 旧実装は常に MSB 先頭（ビッグエンディアン順）で結合していたため、
                    # state.endian == 'little' の場合に命令フィールドが逆転していた。
                    if self.state.endian == 'little':
                        for i in range(ibyte):
                            if len(values) > cnt:
                                vv |= (values[cnt] & 0xff) << (8 * i)
                            cnt += 1
                    else:
                        for i in range(ibyte):
                            vv <<= 8
                            if len(values) > cnt:
                                vv |= values[cnt] & 0xff
                            cnt += 1
                    v1 += [vv & im]
                
                r = 0
                for v in v1:
                    r = (r << self.state.vliwinstbits) | v
                r = r & pm
                
                if self.state.vliwtemplatebits < 0:
                    res = r | (templ << (vbits - abs(self.state.vliwtemplatebits)))
                else:
                    res = (r << self.state.vliwtemplatebits) | templ
                
                q = 0
                # Fix ⑥修正: 旧実装は vliwbits の符号（>0=MSB先頭, <0=LSB先頭）で
                # バイト出力順を決定しており、state.endian 設定と整合していなかった。
                # 他のバイト出力系（flush, _extract）はすべて state.endian で分岐している。
                # 修正後: state.endian を唯一の基準とする。
                # vliwbits の符号は abs() で絶対値を取り出す用途のみに使用する。
                if vbits < 8:
                    # Fix 6: vbits < 8 では bc = vbits - 8 が負になり
                    # '0xff << bc' で ValueError が発生する。
                    # 1バイト未満のワードは下位ビットのみを出力する。
                    self.binary_writer.outbin(self.state.pc, res & ((1 << vbits) - 1))
                    q = 1
                elif self.state.endian == 'little':
                    # リトルエンディアン: LSB から順に書き出す。
                    # Fix: 旧実装は vbits // 8 回しかループしないため、vbits が
                    # 8 の倍数でない場合（例: 12bit → 1バイトしか書かれず上位 4bit
                    # が消える）に出力が欠落していた。(vbits + 7) // 8 に修正する。
                    total_bytes = (vbits + 7) // 8
                    for cnt in range(total_bytes):
                        self.binary_writer.outbin(self.state.pc + cnt, res & 0xff)
                        res >>= 8
                        q += 1
                else:
                    # ビッグエンディアン: MSB から順に書き出す。
                    # Fix: 旧実装は bc = vbits - 8 を初期シフト量にしていたため、
                    # vbits が 8 の倍数でないとき bc が途中で負になり ValueError
                    # が発生した。また vbits // 8 回しかループしないため上位ビットが
                    # 消失していた。バイト i は (res >> ((total_bytes-1-i)*8)) & 0xff
                    # で正確に計算できる。
                    total_bytes = (vbits + 7) // 8
                    for cnt in range(total_bytes):
                        shift = (total_bytes - 1 - cnt) * 8
                        self.binary_writer.outbin(self.state.pc + cnt, (res >> shift) & 0xff)
                        q += 1
                
                self.state.pc += q
                break
        else:
            # Fix ③修正: 旧実装は pas==0 か pas==2 のときだけ return False していたため、
            # pas==1 ではエラーを出さず True を返してしまい、Pass1 のサイズ推定が
            # VLIW テンプレート未定義のまま通過し、Pass2 でアドレスがずれていた。
            # 修正後: 全 pass で False を返す。Pass1 の try/except が処理する。
            if self.state.pas == 0 or self.state.pas == 2:
                print(" error - No vliw instruction-set defined.")
            return False
        return True


class AssemblyDirectiveProcessor:
    """Processes assembly-level directives"""
    
    def __init__(self, state, expr_eval, binary_writer, label_manager, parser):
        self.state = state
        self.expr_eval = expr_eval
        self.binary_writer = binary_writer
        self.label_manager = label_manager
        self.parser = parser
    
    def labelc_processing(self, l, ll):
        """Label characters directive"""
        if l.upper() != '.LABELC':
            return False
        if ll:
            self.state.lwordchars = ALPHABET + DIGIT + ll
        return True
    
    def label_processing(self, l):
        """Process label definitions"""
        if l == "":
            return ""
        
        label, idx = self.parser.get_label_word(l, 0)
        lidx = idx
        
        if label != "" and idx > 0 and l[idx-1] == ':':
            idx = StringUtils.skipspc(l, idx)
            e, idx = StringUtils.get_param_to_spc(l, idx)
            if e.upper() == '.EQU':
                expr_part = l[idx:]
                # Fix 4 補足: label_processing は lineassemble2 のパターンスキャンより
                # 前に呼ばれるため、前行の処理で error_undefined_label が True のまま
                # 残っている可能性がある。評価前にリセットして「この式自体」の結果だけを見る。
                self.state.error_undefined_label = False
                u, _ = self.expr_eval.expression_asm(expr_part, 0)
                # pass2/対話モードで未定義ラベルが残っていたらエラーを出して
                # put_value をスキップする。UNDEF 値がラベルに登録されると後続の
                # 計算が全て壊れる。pass1 は forward 参照が正常なのでスキップしない。
                if self.state.error_undefined_label:
                    if self.state.pas == 2 or self.state.pas == 0:
                        print(f" error - .EQU '{label}': expression contains undefined label.")
                    return ""
                # is_equ=True: 定数ラベル（.equ 式の結果）はリロケーション対象外
                self.label_manager.put_value(label, u, self.state.current_section, is_equ=True)
                return ""
            else:
                # is_equ=False: アドレスラベル（リロケーション対象になり得る）
                # Fix D: put_value の戻り値を確認してエラー時は行を返さない。
                # 二重定義エラーなどで False が返った場合、行の残りを処理しても
                # ラベルが未登録のままパターンスキャンに渡ると誤ったマッチが起きる。
                ok = self.label_manager.put_value(
                    label, self.state.pc, self.state.current_section, is_equ=False)
                if ok is False:
                    return ""
                return l[lidx:]
        return l
    
    def asciistr(self, l2):
        """Process ASCII string"""
        idx = 0
        if l2 == '' or l2[idx] != '"':
            return False
        idx += 1
        
        while idx < len(l2) and not l2[idx]=='"':
            # Fix 5 (new): ch=None をセンチネルとして使い、エラー時は outbin をスキップ。
            # None のまま下まで到達した場合はバイトを出力しない。
            ch = None
            if l2[idx:idx+2] == '\\0':
                idx += 2
                ch = chr(0)
            elif l2[idx:idx+2] == '\\t':
                idx += 2
                ch = '\t'
            elif l2[idx:idx+2] == '\\n':
                idx += 2
                ch = '\n'
            elif l2[idx:idx+2] == '\\r':
                idx += 2
                ch = '\r'
            elif l2[idx:idx+2] == '\\\\':
                idx += 2
                ch = '\\'
            elif l2[idx:idx+2] == '\\"':
                idx += 2
                ch = '"'
            elif l2[idx:idx+2] in ('\\x', '\\X'):
                # \xNN 形式の16進エスケープ（最大2桁）
                idx += 2
                hex_str = ''
                while idx < len(l2) and l2[idx] in '0123456789abcdefABCDEF' and len(hex_str) < 2:
                    hex_str += l2[idx]
                    idx += 1
                if hex_str:
                    ch = chr(int(hex_str, 16))
                else:
                    # Fix 5: \x の直後に16進数字がない場合、エラーを報告して
                    # ディレクティブ全体を失敗扱いにする（return False）。
                    # ch=None のままループを続けると後続の文字が出力されてしまい、
                    # バイナリが部分的に変化する問題があった。
                    print(f" error - '\\x' escape requires at least one hex digit in string: {l2!r}")
                    return False
            else:
                ch = l2[idx]
                idx += 1
            if ch is not None:
                self.binary_writer.outbin(self.state.pc, ord(ch))
                self.state.pc += 1
        # Fix: 閉じダブルクォートが見つからずループを抜けた場合は警告する
        if idx >= len(l2):
            print(f" warning - unterminated string literal in .ASCII/.ASCIZ: {l2!r}")
        return True
    
    def export_processing(self, l1, l2):
        """Export / Global directive.
        .EXPORT label  -- mark label(s) as globally visible (ELF STB_GLOBAL)
        .GLOBAL label  -- alias for .EXPORT (GAS/NASM compatible syntax)
        Both directives are only active during pass2 and interactive mode.
        """
        if not (self.state.pas == 2 or self.state.pas == 0):
            return False
        _l1u = StringUtils.upper(l1)
        if _l1u != ".EXPORT" and _l1u != ".GLOBAL":
            return False
        
        idx = 0
        l2 += chr(0)
        while idx < len(l2) and l2[idx] != chr(0):
            idx = StringUtils.skipspc(l2, idx)
            s, idx = self.parser.get_label_word(l2, idx)
            if s == "":
                break
            if idx < len(l2) and l2[idx] == ':':
                idx += 1
            v = self.label_manager.get_value(s)
            sec = self.label_manager.get_section(s)
            # is_equ フラグを labels から取得して export_labels にも保持する。
            # write_elf_obj() で定数ラベル(SHN_ABS)とアドレスラベルを区別するために必要。
            _lentry = self.state.labels.get(s, [])
            is_equ = len(_lentry) > 2 and _lentry[2]
            self.state.export_labels[s] = [v, sec, is_equ]
            if idx < len(l2) and l2[idx] == ',':
                idx += 1
        return True
    
    def zero_processing(self, l1, l2):
        """Zero directive

        Fix ②: pass1 でディレクティブの引数に未定義ラベルが含まれると
        expression_asm() が UNDEF (約10^77) を返す。
        このまま range(UNDEF) を実行するとプロセスが事実上フリーズする。
        zero_processing はパターンスキャンの try/except ブロック外で
        直接呼ばれるため、_pass1_size_mode フォールバックも効かない。

        修正: error_undefined_label フラグを確認して UNDEF を早期検出する。
        また負値もガードしてエラーを出す。
        """
        if StringUtils.upper(l1) != ".ZERO":
            return False
        x, idx = self.expr_eval.expression_asm(l2, 0)
        # 未定義ラベルが含まれる場合は UNDEF が返る → range(UNDEF) でフリーズする
        if self.state.error_undefined_label:
            # pass2 なら未定義ラベルエラーとして報告（pass1 はスキップ）
            if self.state.pas == 2 or self.state.pas == 0:
                print(f" error - .ZERO argument contains undefined label.")
            return True
        try:
            x = int(x)
        except (OverflowError, ValueError):
            if self.state.pas == 2 or self.state.pas == 0:
                print(f" error - .ZERO argument is non-finite or invalid.")
            return True
        if x < 0:
            print(f" error - .ZERO requires a non-negative count, got {x}.")
            return True
        # Fix: 上限ガード（UNDEF 由来の巨大値でのフリーズ防止）
        _ZERO_MAX = 1 << 28  # 256MB 超は非現実的
        if x > _ZERO_MAX:
            if self.state.pas == 2 or self.state.pas == 0:
                print(f" error - .ZERO count {x} exceeds maximum {_ZERO_MAX}.")
            return True
        for i in range(x):
            self.binary_writer.outbin2(self.state.pc, 0x00)
            self.state.pc += 1
        return True
    
    def ascii_processing(self, l1, l2):
        """ASCII directive"""
        if StringUtils.upper(l1) != ".ASCII":
            return False
        return self.asciistr(l2)
    
    def asciiz_processing(self, l1, l2):
        """ASCIZ directive"""
        if StringUtils.upper(l1) != ".ASCIZ":
            return False
        # Bug修正: asciistr() が文字列バイトを出力する。
        # 旧コードは f = self.asciistr(l2) の戻り値(bool)だけ見て
        # 文字列本体をスキップし、0x00 のみ書いていた。
        # 修正: asciistr() で文字列を出力した後、ヌル終端を追加する。
        if not self.asciistr(l2):
            if self.state.pas == 2 or self.state.pas == 0:
                print(f" error - .ASCIZ requires a quoted string.")
            return False
        # ヌル終端を追加 (asciistr はヌルを書かない)
        self.binary_writer.outbin(self.state.pc, 0x00)
        self.state.pc += 1
        return True
    
    def section_processing(self, l1, l2):
        """Section directive"""
        if StringUtils.upper(l1) != ".SECTION" and StringUtils.upper(l1) != ".SEGMENT":
            return False
        
        if l2 != '':
            # Fix 3 (original) / Fix 4 (new): セクションを切り替える前に現在セクションの
            # 暫定サイズを更新する。暫定サイズは entry_pc（第3要素）からの差分で計算する。
            # 旧実装は word_start（第1要素）からの全体幅を使っていたため、非連続セクションで
            # 過大なサイズが書き込まれていた。
            #
            # Bugfix（暫定サイズ累積方式）:
            # 旧実装は old_entry[1] == 0 のときだけ暫定サイズを書き込んでいた。
            # ENDSECTION なしでセクションを複数回行き来すると、2回目以降のブロック分が
            # 加算されず、最初のブロックのサイズのみが記録される問題があった。
            # 修正後: sections エントリの第4要素 confirmed (bool) で
            # ENDSECTION 確定済みサイズと暫定サイズを区別する。
            #   confirmed=False : 暫定サイズ（累積更新可）
            #   confirmed=True  : ENDSECTION 確定済み（上書き禁止）
            #
            # Bugfix2: AssemblerState の初期 current_section (".text") は
            # sections 辞書に登録されていない。最初の SECTION ディレクティブより前に
            # 命令を出力すると、その分が sections に記録されず write_elf_obj() で
            # ELF に含まれなくなる。
            # 修正: old_sec が sections 未登録の場合は、PC=0 から現在までのデータを
            # 初期エントリとして登録してから暫定サイズを更新する。
            old_sec = self.state.current_section
            if old_sec not in self.state.sections:
                # まだ登録されていない初期セクション: word_start=0, entry_pc=0 で作成
                self.state.sections[old_sec] = [0, 0, 0, False]
            old_entry = self.state.sections[old_sec]
            _confirmed = len(old_entry) > 3 and old_entry[3]
            if not _confirmed:
                # 暫定サイズ: 今回ブロック分を累積加算する
                _entry_pc = old_entry[2] if len(old_entry) > 2 else old_entry[0]
                tentative = self.state.pc - _entry_pc
                if tentative > 0:
                    old_entry[1] += tentative

            self.state.current_section = l2
            if l2 not in self.state.sections:
                # [word_start, word_count, entry_pc, confirmed]
                # entry_pc: このセクションに「今」入った時点の PC。
                # ENDSECTION でのサイズ計算に使う。
                # confirmed=False: まだ ENDSECTION で確定していない。
                self.state.sections[l2] = [self.state.pc, 0, self.state.pc, False]
            else:
                # Fix 2 (new): 同一セクションの再宣言時、ENDSECTION で確定済みのサイズ
                # （confirmed=True）を Fix 3 のリセット処理が消してしまう問題を修正する。
                # start を最小値として保持し、confirmed=True なら size は保護する。
                # entry_pc を「今回の宣言時 PC」に更新することで、
                # ENDSECTION が「今回入ってから現在まで」の正しい差分を計算できる。
                existing_start     = self.state.sections[l2][0]
                existing_size      = self.state.sections[l2][1]
                existing_confirmed = len(self.state.sections[l2]) > 3 and self.state.sections[l2][3]
                new_start = min(existing_start, self.state.pc)
                # confirmed=True の確定済みサイズは保護する
                # entry_pc は今回の宣言時 PC に更新
                self.state.sections[l2] = [new_start, existing_size, self.state.pc, existing_confirmed]
        return True
    
    def align_processing(self, l1, l2):
        """Align directive"""
        if StringUtils.upper(l1) != ".ALIGN":
            return False
        
        if l2 != '':
            u, idx = self.expr_eval.expression_asm(l2, 0)
            # Fix 6: .ALIGN 0 や負値は不正。ゼロ除算を防ぐためここで検証する。
            # Fix: u が float('inf')/nan の場合も int() で OverflowError になるためガード。
            try:
                u_int = int(u)
            except (OverflowError, ValueError):
                print(f" error - .ALIGN argument is non-finite or invalid.")
                return True
            if u_int <= 0:
                print(f" error - .ALIGN requires a positive value, got {u_int}.")
                return True
            self.state.align = u_int
        
        self.state.pc = self.binary_writer.align_(self.state.pc)
        return True
    
    def endsection_processing(self, l1, l2):
        """End section directive"""
        if StringUtils.upper(l1) != ".ENDSECTION" and StringUtils.upper(l1) != ".ENDSEGMENT":
            return False
        if self.state.current_section not in self.state.sections:
            print(f" error - .ENDSECTION without matching .SECTION for '{self.state.current_section}'.")
            return True
        entry = self.state.sections[self.state.current_section]
        start = entry[0]
        # Fix 2 (new): 非連続セクション（.text → .data → .text → ENDSECTION）で
        # pc - start を使うと「最初の宣言 PC から現在まで」の幅になり過大になる。
        # section_processing が entry_pc（第3要素）に「今回の宣言時 PC」を記録しているので
        # それを使って「今回のブロック分」だけのサイズを計算する。
        # 累積サイズ = 既存の確定サイズ + 今回のブロック分
        entry_pc = entry[2] if len(entry) > 2 else start
        block_size = self.state.pc - entry_pc
        if block_size < 0:
            print(f" warning - ENDSECTION: computed block size {block_size} < 0 for "
                  f"'{self.state.current_section}'; keeping previous size.")
            return True
        # 既存の確定済みサイズに今回のブロック分を加算して確定させる。
        # 初回（re-declaration なし）は entry[1]==0 なのでそのまま block_size になる。
        new_size = entry[1] + block_size
        # Bugfix: confirmed=True を第4要素として設定し、ENDSECTION 確定済みであることを記録する。
        # section_processing の暫定サイズ更新はこのフラグを見て上書きを抑止する。
        #
        # Bugfix2（entry_pc 更新）: confirmed=True のまま entry_pc が古い値に残ると、
        # その後に同一セクションへ再入して ENDSECTION する際に
        # section_processing が entry_pc を今回の PC に更新するが（else ブランチ）、
        # ENDSECTION は entry_pc を使って block_size を計算するため問題ない。
        # ただし ENDSECTION 直後に next SECTION が来ず再度 ENDSECTION が来た場合、
        # entry_pc が現在 PC を指すよう今の PC で更新しておくことで二重カウントを防ぐ。
        self.state.sections[self.state.current_section] = [start, new_size, self.state.pc, True]
        return True
    
    def extern_processing(self, l1, l2):
        """Extern directive with optional reloc type override.
        .EXTERN label::plt32 [, label2::gotpcrel, ...]
        """
        if StringUtils.upper(l1) != ".EXTERN":
            return False

        idx = 0
        l2 = l2 + chr(0)
        while idx < len(l2) and l2[idx] != chr(0):
            idx = StringUtils.skipspc(l2, idx)
            label_part, idx = self.parser.get_label_word(l2, idx)
            if not label_part:
                break

            # get_label_word はラベル終端の ':' を1文字消費する。
            # '.extern foo::plt32' では最初の ':' が消費され idx は2番目の ':'
            # を指すため、'::' チェックが ':' + 次文字になりマッチしない。
            # 直前文字が ':' かつ現在位置も ':' なら1文字戻して '::' を正しく検出する。
            if idx > 0 and l2[idx - 1] == ':' and idx < len(l2) and l2[idx] == ':':
                idx -= 1  # ':' 消費を巻き戻して '::' を先頭から検出できるようにする

            # デフォルトリロケーション型をアーキテクチャから決定する。
            # .extern label::plt32 のように明示指定した場合はそちらを優先する。
            _em_ext = self.state.elf_machine
            if _em_ext == 3:          # i386: R_386_PC32=2
                reloc_type = 2
            elif _em_ext == 40:       # ARM: R_ARM_REL32=3
                reloc_type = 3
            elif _em_ext == 183:      # AArch64: R_AARCH64_PREL32=261
                reloc_type = 261
            elif _em_ext == 243:      # RISC-V: R_RISCV_32=1
                reloc_type = 1
            elif _em_ext == 20:       # PPC: R_PPC_REL32=26
                reloc_type = 26
            else:                     # x86-64 (62) およびその他: R_X86_64_PC32=2
                reloc_type = 2
            if idx < len(l2) and l2[idx:idx+2] == '::':
                idx += 2
                rt_start = idx
                while idx < len(l2) and l2[idx] not in ' \t,:' + chr(0):
                    idx += 1
                rt_str = l2[rt_start:idx].strip().lower()

                if rt_str:
                    rtype_map = {
                        # 絶対リロケーション
                        'abs64':  1,   # R_X86_64_64      – 64bit 絶対アドレス
                        'abs32':  10,  # R_X86_64_32      – 32bit ゼロ拡張絶対アドレス
                        'abs32s': 11,  # R_X86_64_32S     – 32bit 符号拡張絶対アドレス
                        'abs16':  12,  # R_X86_64_16      – 16bit 絶対アドレス
                        'abs8':   14,  # R_X86_64_8       –  8bit 絶対アドレス
                        # PC相対リロケーション
                        'pc32':   2,   # R_X86_64_PC32    – 32bit PC相対
                        'rel32':  2,   # R_X86_64_PC32    – pc32 の別名
                        'plt32':  4,   # R_X86_64_PLT32   – PLT経由32bit PC相対
                        'pc16':   13,  # R_X86_64_PC16    – 16bit PC相対
                        'pc8':    15,  # R_X86_64_PC8     –  8bit PC相対
                        'pc64':   24,  # R_X86_64_PC64    – 64bit PC相対
                        # GOT相対リロケーション
                        'got32':    3, # R_X86_64_GOT32      – GOTエントリへの32bit参照
                        'gotpcrel': 9, # R_X86_64_GOTPCREL   – GOTエントリへのPC相対32bit参照
                        'got64':   27, # R_X86_64_GOT64      – GOTエントリへの64bit参照
                    }
                    reloc_type = rtype_map.get(rt_str)
                    if reloc_type is None:
                        print(f" warning - unknown reloc type '{rt_str}' in .EXTERN", file=sys.stderr)

            if idx < len(l2) and l2[idx] == ':':
                idx += 1

            # ラベル登録（5要素形式を確実に）
            existing = self.state.labels.get(label_part)
            if existing is None or not (len(existing) > 3 and existing[3]):
                self.state.labels[label_part] = [0, '.text', False, True, reloc_type]
            elif len(existing) >= 5:
                if reloc_type is not None:
                    existing[4] = reloc_type   # 上書き

            idx = StringUtils.skipspc(l2, idx)
            if idx < len(l2) and l2[idx] == ',':
                idx += 1

        return True

    def org_processing(self, l1, l2):
        """ORG directive"""
        if StringUtils.upper(l1) != ".ORG":
            return False
        u, idx = self.expr_eval.expression_asm(l2, 0)
        # Fix ②: .ZERO と同様に未定義ラベルを早期検出する。
        # UNDEF (≈10^77) が返ると range(UNDEF - pc) でプロセスがフリーズし、
        # さらに pc = UNDEF となって後続の全処理が壊れる。
        if self.state.error_undefined_label:
            if self.state.pas == 2 or self.state.pas == 0:
                print(f" error - .ORG argument contains undefined label.")
            return True
        try:
            u = int(u)
        except (OverflowError, ValueError):
            if self.state.pas == 2 or self.state.pas == 0:
                print(f" error - .ORG argument is non-finite or invalid.")
            return True
        if u < 0:
            if self.state.pas == 2 or self.state.pas == 0:
                print(f" error - .ORG address must be non-negative, got {u}.")
            return True
        if idx + 2 <= len(l2) and l2[idx:idx+2].upper() == ',P':
            if u > self.state.pc:
                # Fix: 巨大なジャンプでフリーズしないよう上限ガード
                _ORG_FILL_MAX = 1 << 28
                fill_count = u - self.state.pc
                if fill_count > _ORG_FILL_MAX:
                    if self.state.pas == 2 or self.state.pas == 0:
                        print(f" error - .ORG ,P fill count {fill_count} exceeds maximum {_ORG_FILL_MAX}.")
                    return True
                for i in range(fill_count):
                    self.binary_writer.outbin2(i + self.state.pc, self.state.padding)
        self.state.pc = u
        return True


class Assembler:
    """Main assembler class"""
    
    def __init__(self):
        self.state = AssemblerState()
        self.parser = Parser(self.state)
        self.var_manager = VariableManager(self.state)
        self.label_manager = LabelManager(self.state)
        self.symbol_manager = SymbolManager(self.state)
        self.expr_eval = ExpressionEvaluator(self.state, self.var_manager, 
                                            self.label_manager, self.symbol_manager, self.parser)
        self.binary_writer = BinaryWriter(self.state)
        self.directive_proc = DirectiveProcessor(self.state, self.expr_eval, self.binary_writer)
        self.pattern_matcher = PatternMatcher(self.state, self.expr_eval, self.var_manager, 
                                             self.symbol_manager, self.parser)
        self.pattern_reader = PatternFileReader(self.parser)
        self.obj_gen = ObjectGenerator(self.state, self.expr_eval, self.binary_writer)
        self.vliw_proc = VLIWProcessor(self.state, self.expr_eval, self.binary_writer)
        self.asm_directive_proc = AssemblyDirectiveProcessor(self.state, self.expr_eval, 
                                                             self.binary_writer, self.label_manager, self.parser)
        # セクション情報の一時記録テーブル（imp_label が使用）。
        # アセンブリ中に構築される state.sections とは独立した辞書で、
        # import ファイルの解析中のみ参照される。
        self._imp_sections: dict = {}  # {sname: (start, size)}
    
    def include_asm(self, l1, l2):
        """Include directive.

        修正5: インクルードパスを現在アセンブル中のファイルのディレクトリを基準に解決する。
        旧実装はパスをそのまま open() に渡すため、プロセスの CWD と異なる場所にある
        ソースファイル内の相対パス .INCLUDE が常に失敗していた。
        stdin や対話モードの場合は解決不能なので CWD 基準のままとする。
        """
        if StringUtils.upper(l1) != ".INCLUDE":
            return False
        s = StringUtils.get_string(l2)
        if s:
            # 相対パスを現在ファイルのディレクトリ基準に解決する
            if not os.path.isabs(s):
                cur = self.state.current_file
                if cur and cur not in ("(stdin)", ""):
                    base = os.path.dirname(os.path.abspath(cur))
                    s = os.path.join(base, s)
            self.fileassemble(s)
        return True
    
    def lineassemble2(self, line, idx):
        """Assemble line (phase 2)"""
        l, idx = StringUtils.get_param_to_spc(line, idx)
        l2, idx = StringUtils.get_param_to_eon(line, idx)
        l = l.rstrip()
        l2 = l2.rstrip()
        l = l.replace(' ', '')
        
        if self.asm_directive_proc.section_processing(l, l2):
            return 0, [], True, idx
        if self.asm_directive_proc.endsection_processing(l, l2):
            return 0, [], True, idx
        if self.asm_directive_proc.zero_processing(l, l2):
            return 0, [], True, idx
        # Fix 2 (new): ascii_processing / asciiz_processing は
        # ① ディレクティブ名が一致しない → False（次のディレクティブへ）
        # ② ディレクティブ名は一致したが内容エラー → False（asciistr が False を返す）
        # の2通りで False を返す。旧実装は両方を「ディレクティブ不一致」として扱い、
        # エラー時にパターンスキャンへ落ちて誤った「構文エラー」が報告されていた。
        # 修正: ディレクティブ名が一致するかどうかを先に確認してから戻り値を判定する。
        _l_upper = StringUtils.upper(l)
        if _l_upper == '.ASCII':
            # Fix 4 (実装修正): ascii_processing の戻り値を実際に検査する。
            # コメントには「戻り値を確認する」と書いてあったが、戻り値を変数に
            # 受けておらず常に True を返していたため、asciistr() がエラーで
            # False を返してもバイナリへの書き込みが抜けたまま正常に見えていた。
            # 修正: 戻り値が False のときも True を返す（パターンスキャンへ落とさない）が、
            # エラーメッセージを出力してユーザーに知らせる。
            _ok = self.asm_directive_proc.ascii_processing(l, l2)
            if not _ok and (self.state.pas == 2 or self.state.pas == 0):
                print(f" error - .ASCII: failed to process string argument: {l2!r}")
            return 0, [], True, idx
        if _l_upper == '.ASCIZ':
            _ok = self.asm_directive_proc.asciiz_processing(l, l2)
            if not _ok and (self.state.pas == 2 or self.state.pas == 0):
                print(f" error - .ASCIZ: failed to process string argument: {l2!r}")
            return 0, [], True, idx
        if self.include_asm(l, l2):
            return 0, [], True, idx
        if self.asm_directive_proc.align_processing(l, l2):
            return 0, [], True, idx
        if self.asm_directive_proc.org_processing(l, l2):
            return 0, [], True, idx
        if self.asm_directive_proc.labelc_processing(l, l2):
            return 0, [], True, idx
        if self.asm_directive_proc.extern_processing(l, l2):
            return 0, [], True, idx
        if self.asm_directive_proc.export_processing(l, l2):  # handles .EXPORT and .GLOBAL
            return 0, [], True, idx

        # Fix 9: ソースファイル内の .setsym / .clearsym は lineassemble() 先頭の
        # "symbols = dict(patsymbols)" リセットによって次行では消えてしまう。
        # ソースレベルの場合は patsymbols も同時に更新することで永続させる。
        #
        # Fix ①修正: 旧実装は _i_src = [l, '', l2, '', '', ''] としていたため、
        # set_symbol が参照する i[1]（KEY名）が常に '' になっていた。
        # l2 の最初のトークンを KEY、残りを VALUE として正しく分割する。
        # .clearsym は i[2] をキー名として参照する（パターンファイルの慣習に合わせた設計）。
        _l_upper = l.upper()
        if _l_upper in ('.SETSYM', '.CLEARSYM'):
            _l2_key, _l2_key_end = StringUtils.get_param_to_spc(l2, 0)
            _l2_val = l2[_l2_key_end:].strip()
            if _l_upper == '.SETSYM':
                # set_symbol: i[0]=cmd, i[1]=KEY, i[2]=VALUE式
                # Fix 9: set_symbol/clear_symbol は i[0] を小文字の '.setsym'/'.clearsym'
                # と比較する。l は get_param_to_spc が返す元の大文字混在のトークンなので
                # l.lower() を使わないとディレクティブが無視されていた。
                _i_src = [l.lower(), _l2_key, _l2_val, '', '', '']
            else:
                # clear_symbol: i[0]=cmd, i[2]=KEY (全消去時は空)
                _i_src = [l.lower(), '', _l2_key, '', '', '']
        else:
            _i_src = [l, '', l2, '', '', '']
        if self.directive_proc.set_symbol(_i_src):
            self.state.patsymbols = dict(self.state.symbols)
            return 0, [], True, idx
        if self.directive_proc.clear_symbol(_i_src):
            self.state.patsymbols = dict(self.state.symbols)
            return 0, [], True, idx
        if l == "":
            return 0, [], False, idx
        
        of = 0
        se = False
        oerr = False
        pln = 0
        pl = ""
        idxs = 0
        objl = []
        loopflag = True
        
        for i in self.state.pat:
            pln += 1
            pl = i
            for a in LOWER:
                self.var_manager.put(a, VAR_UNDEF)
            
            if i is None: continue
            if self.directive_proc.set_symbol(i): continue
            if self.directive_proc.clear_symbol(i): continue
            if self.directive_proc.paddingp(i): continue
            if self.directive_proc.bits(i): continue
            if self.directive_proc.symbolc(i): continue
            if self.directive_proc.epic(i): continue
            if self.directive_proc.vliwp(i): continue
            
            lw = len([_ for _ in i if _])
            if lw == 0: continue
            
            lin = l + ' ' + l2
            lin = StringUtils.reduce_spaces(lin)
            
            if i[0] == '':
                # 番兵エントリ: マッチせずにループ終端に達したとみなす。
                # i[3] にはVLIWスロットインデックス式が入っているため、
                # 評価せずに break すると idxs が初期値 0 のまま返り
                # VLIWスロット配置が狂う。ここで必ず評価する。
                idxs, _ = self.expr_eval.expression_pat(i[3], 0)
                loopflag = False
                break
            
            self.state.error_undefined_label = False
            
            self.state.expmode=EXP_ASM
            if not self.state.debug:
                try:
                    if self.pattern_matcher.match0(lin, i[0]) == True:
                        # Fix 10: error() の戻り値でエラー発生を検知し、
                        # エラー時はオブジェクト生成をスキップする。
                        err_triggered, _err_code = self.directive_proc.error(i[1])
                        if not err_triggered:
                            # binary_list中の$$が命令先頭アドレスを指すように保存
                            self.state.pc_instr_start = self.state.pc
                            objl = self.obj_gen.makeobj(i[2])
                        else:
                            objl = []
                        # makeobj() の finally が _elf_current_word_idx を -1 に
                        # リセット済み。以降のサイズ式 expression_pat(i[3]) で発生する
                        # ラベル参照は word_idx=-1 となりリロケーション対象外になる。
                        idxs, _ = self.expr_eval.expression_pat(i[3], 0)
                        loopflag = False
                        break
                except (ArithmeticError, KeyError, IndexError, ValueError,
                        TypeError, AttributeError, OverflowError,
                        RecursionError, struct.error) as _exc:
                    # 修正④: 旧実装は `except Exception` で全例外を捕捉していたため、
                    # makeobj / expression_pat 内のコード実装バグ（TypeError 等）が
                    # 「forward参照エラー」として握りつぶされ、デバッグが困難だった。
                    # 対策:
                    #   - forward参照で発生し得る算術・辞書・値域・型変換系の例外のみを
                    #     列挙して捕捉する。
                    #   - それ以外の予期しない例外（RuntimeError, RecursionError 等）は
                    #     再 raise し、呼び出しスタックを確認できるようにする。
                    # ただし Pass2 / インタラクティブで発生した場合は従来通り oerr 扱い。
                    # Bugfix: struct.error (struct.pack の範囲外エラー) は上記リストに
                    # 含まれていなかったため、enflt/endbl に UNDEF が渡った場合などに
                    # 未捕捉のままクラッシュしていた。struct.error を追加する。
                    if self.state.pas == 1:
                        # Pass1: パターンはマッチしたが forward参照で makeobj が失敗した。
                        # ラベルを 0 と仮定してサイズだけ確定させ、PC を正しく進める。
                        # makeobj() の finally が _elf_current_word_idx を -1 にリセット
                        # するため、ここで追加リセットは不要。
                        if self.state.debug:
                            import traceback as _tb
                            print(f" [pass1 forward-ref fallback] {type(_exc).__name__}: {_exc}")
                            _tb.print_exc()
                        try:
                            self.state._pass1_size_mode = True
                            objl = self.obj_gen.makeobj(i[2])
                            idxs, _ = self.expr_eval.expression_pat(i[3], 0)
                        except (ArithmeticError, KeyError, IndexError, ValueError,
                                TypeError, AttributeError, OverflowError,
                                RecursionError, struct.error):
                            objl = []  # それでも失敗した場合はサイズ0のまま
                        finally:
                            self.state._pass1_size_mode = False
                            # Fix ⑧-2: _pass1_size_mode 中は get_value() が 0 を返しつつ
                            # error_undefined_label=True もセットする。フォールバック完了後も
                            # このフラグが残ったままだと、サイズ式 expression_pat(i[3]) で
                            # ラベルを参照した場合などに汚染が持ち越される。
                            # フォールバックは意図的な「未定義を 0 として扱う」処理なので
                            # 完了後はフラグをクリアする。
                            self.state.error_undefined_label = False
                        loopflag = False
                    else:
                        oerr = True
                        loopflag = False
                    break
            else:
                if self.pattern_matcher.match0(lin, i[0]) == True:
                    # Fix 10: error() の戻り値でエラー発生を検知する（デバッグモード）
                    err_triggered, _err_code = self.directive_proc.error(i[1])
                    if not err_triggered:
                        # binary_list中の$$が命令先頭アドレスを指すように保存
                        self.state.pc_instr_start = self.state.pc
                        objl = self.obj_gen.makeobj(i[2])
                    else:
                        objl = []
                    # makeobj() の finally が _elf_current_word_idx を -1 にリセット済み
                    idxs, _ = self.expr_eval.expression_pat(i[3], 0)
                    loopflag = False
                    break
        
        if loopflag == True:
            se = True
            pln = 0
            pl = ""
        
        if self.state.pas == 2 or self.state.pas == 0:
            _loc = f"  [{self.state.current_file}:{self.state.ln}]"
            if self.state.error_undefined_label:
                # get_value() で個別ラベル名は既に表示済み。
                # ここでは行レベルのサマリだけ出す。
                print(f" error - Undefined label in expression.{_loc}", file=sys.stderr)
                return 0, [], False, idx
            if se:
                print(f" error - Syntax error.{_loc}", file=sys.stderr)
                return 0, [], False, idx
            if oerr:
                print(f" ; pat {pln} {pl} error - Illegal syntax in assemble line or pattern line.{_loc}", file=sys.stderr)
                return 0, [], False, idx
        
        return idxs, objl, True, idx
    
    def lineassemble(self, line):
        """Assemble single line"""
        # Fix 6 (new): \r は lineassemble0 で除去されるが、.INCLUDE 経由など
        # lineassemble() が直接呼ばれる経路では \r が残る場合がある。
        # ここでも除去して入力を確実に正規化する。
        line = line.replace('\t', ' ').replace('\n', '').replace('\r', '')
        line = StringUtils.reduce_spaces(line)
        line = StringUtils.remove_comment_asm(line)
        if line == '':
            return False

        # 修正4a: .EQU 式はパターンファイル由来のシンボル（レジスタ名など）を
        # 参照できるべきだが、前行のパターンスキャンで蓄積された
        # 位置依存 .setsym の残留値には依存すべきでない。
        # そのため label_processing (= .EQU 評価) の前に symbols を
        # patsymbols ベースラインにリセットしてから評価する。
        self.state.symbols = dict(self.state.patsymbols)

        line = self.asm_directive_proc.label_processing(line)

        # 修正4b: 旧実装は clear_symbol([".clearsym","",...]) で symbols={} に
        # 空クリアしていた。これでは patsymbols に定義されたシンボルまで
        # 消えてしまい、lineassemble2 内のパターンスキャンが再構築する前の
        # .setsym 参照が失敗する。
        # 修正後: lineassemble2 の先頭でパターンスキャンが .setsym を
        # 順次適用するため、ここでの明示的クリアは不要。
        # patsymbols ベースラインは上記 4a で設定済み。
        
        # VLIW スロット数カウント: ソース行を '!!' で分割した「非空パート数」を vcnt とする。
        # Bugfix (Fix L): .ASCII "hello!!world" のように文字列リテラル内に '!!' が含まれると
        # vcnt が過大にカウントされ、VLIW パターンの !!! (vcnt 参照) が誤った値を返す。
        # 修正: ダブルクォート文字列の外側にある '!!' だけを区切りとして分割し、
        # 旧実装（split("!!") して非空要素を数える）と同じセマンティクスを保つ。
        #
        # Bugfix2 (Fix L 副作用): 前回の修正は '!!' カウント+1 方式だったため、
        # 行末または行頭に '!!' がある場合に空パートが余分にカウントされ
        # 旧実装より vcnt が1以上多くなっていた。
        # 修正: 分割後の各パートが空でないもの（!= ''）を数えることで旧実装と一致させる。
        #
        # Bugfix3: シングルクォート文字リテラル '!!' 内の !! も誤カウントされていた。
        # 修正: remove_comment_asm の Fix ⑦ と同様の先読みペア確認方式を採用する。
        _vparts = []
        _vpart_buf = []
        _in_dq_v = False
        _vi = 0
        while _vi < len(line):
            _vc = line[_vi]
            # ダブルクォート内のバックスラッシュエスケープを消費
            if _vc == '\\' and _in_dq_v:
                _vpart_buf.append(_vc)
                if _vi + 1 < len(line):
                    _vpart_buf.append(line[_vi + 1])
                _vi += 2
                continue
            if _vc == '"':
                _in_dq_v = not _in_dq_v
                _vpart_buf.append(_vc)
            elif _vc == "'" and not _in_dq_v:
                # Fix 5 (DRY): 共通ヘルパーでシングルクォートリテラルを消費する。
                _new_vi = StringUtils.skip_squote_literal(line, _vi)
                # 消費した文字をバッファに記録（このパートが空でないことを保証するため）
                _vpart_buf.extend(list(line[_vi:_new_vi]))
                _vi = _new_vi
                continue
            elif not _in_dq_v and line[_vi:_vi+2] == '!!':
                _vparts.append(''.join(_vpart_buf))
                _vpart_buf = []
                _vi += 2
                continue
            else:
                _vpart_buf.append(_vc)
            _vi += 1
        _vparts.append(''.join(_vpart_buf))
        self.state.vcnt = sum(1 for _p in _vparts if _p != '')

        # ELF リロケーション追跡: pass2 かつ ELF 出力時のみ有効
        # 修正②: lineassemble2 が例外を投げても _elf_tracking が True のまま
        # 残らないよう try/finally で確実にリセットする。
        if self.state.elf_objfile and self.state.pas == 2:
            self.state._elf_tracking = True
            self.state._elf_label_refs_seen = []
            self.state._elf_current_word_idx = -1    # makeobj 外はセンチネル
            self.state._elf_var_to_label = {}        # 命令ごとにリセット
            self.state._elf_capturing_var = None

        try:
            idxs, objl, flag, idx = self.lineassemble2(line, 0)
        finally:
            self.state._elf_tracking = False

        if flag == False:
            return False
        
        if self.state.vliwflag == False or (idx >= len(line) or line[idx:idx+2] != '!!'):
            of = len(objl)
            # ------------------------------------------------------------------ #
            # ELF リロケーション検出（トラッキング方式）
            # ------------------------------------------------------------------ #
            if self.state.elf_objfile and self.state.pas == 2 and objl and self.state._elf_label_refs_seen:
                bpw_r = max(1, (self.state.bts + 7) // 8)
                sec_name_r = self.state.current_section
                sec_start_w = 0
                if sec_name_r in self.state.sections:
                    sec_start_w = self.state.sections[sec_name_r][0]

                valid_refs = [(ln, aw, wi) for (ln, aw, wi) in self.state._elf_label_refs_seen if wi >= 0]
                valid_refs.sort(key=lambda r: r[2])

                # 複合式除外
                _widx_labels = {}
                for _ln, _, _wi in valid_refs:
                    _widx_labels.setdefault(_wi, set()).add(_ln)
                _ambiguous = {_wi for _wi, ns in _widx_labels.items() if len(ns) > 1}
                valid_refs = [r for r in valid_refs if r[2] not in _ambiguous]

                # グループ化
                groups = []
                gi = 0
                while gi < len(valid_refs):
                    lname, abs_w, widx = valid_refs[gi]
                    gj = gi + 1
                    while gj < len(valid_refs) and valid_refs[gj][0] == lname and valid_refs[gj][2] == widx + (gj - gi):
                        gj += 1
                    groups.append((lname, abs_w, widx, gj - gi))
                    gi = gj

                # アーキテクチャ別デフォルトリロケーション型マップ
                # キー: フィールドサイズ（バイト数） → ELF リロケーション型番号
                # 4バイトはアーキテクチャごとの主流型を使用。
                # 絶対参照が必要な場合は .extern label::abs32 等で明示する。
                _em = self.state.elf_machine
                if _em == 3:
                    # EM_386 (i386)
                    # R_386_32=1(ABS), R_386_PC32=2(PC相対), R_386_16=20, R_386_8=22
                    _rmap = {4: 2, 2: 20, 1: 22}          # 4バイトはPC相対(CALL/JMP主流)
                elif _em == 20:
                    # EM_PPC (PowerPC 32bit)
                    # R_PPC_ADDR32=1, R_PPC_REL32=26, R_PPC_ADDR16=4, R_PPC_ADDR8=0(無し)
                    _rmap = {4: 26, 2: 4}                  # 4バイトはPC相対
                elif _em == 40:
                    # EM_ARM
                    # R_ARM_ABS32=2, R_ARM_REL32=3, R_ARM_ABS16=4, R_ARM_ABS8=8
                    _rmap = {4: 3, 2: 4, 1: 8}             # 4バイトはPC相対(ARM主流)
                elif _em == 183:
                    # EM_AARCH64
                    # R_AARCH64_ABS64=257, R_AARCH64_PREL32=261, R_AARCH64_ABS16=259
                    # R_AARCH64_PREL64=260, R_AARCH64_PREL16=262
                    _rmap = {8: 257, 4: 261, 2: 262}       # 8バイト=ABS64, 4/2バイト=PC相対
                elif _em == 243:
                    # EM_RISCV
                    # R_RISCV_64=2, R_RISCV_32=1, R_RISCV_ADD32=35, R_RISCV_ADD16=34, R_RISCV_ADD8=33
                    _rmap = {8: 2, 4: 1, 2: 34, 1: 33}    # 基本的に絶対アドレス
                else:
                    # EM_X86_64 (62) およびその他
                    # R_X86_64_64=1(ABS64), R_X86_64_PC32=2(PC相対32), R_X86_64_16=12(ABS16), R_X86_64_8=14(ABS8)
                    # 4バイト: PC32(2) を使用。x86-64 では 4バイトフィールドは
                    # RIP相対(LEA/JMP/CALL 等)が主流で R_X86_64_32(10,絶対)は
                    # ほぼ使われない。絶対参照が必要なら .extern label::abs32 で明示する。
                    _rmap = {8: 1, 4: 2, 2: 12, 1: 14}    # x86_64 デフォルト

                # PC相対リロケーション型の集合（アーキテクチャ別）
                # addend = -num_bytes を適用するもの。絶対型は含めない。
                #
                # 【重要】アーキテクチャをまたいで単一セットにすると番号衝突が発生する。
                # 例: R_X86_64_64=1(絶対) vs R_ARM_PC24=1(PC相対)
                # → x86-64 で 1 が PC相対と誤判定され、MOVABS の 8バイトフィールドに
                #   addend=-8 が設定されてしまう（実際に発生したバグ）。
                # マシン番号ごとに PC相対型セットを定義することで衝突を防ぐ。
                _em_r = self.state.elf_machine
                if _em_r == 3:      # EM_386
                    # R_386_PC32=2, R_386_PC16=13, R_386_PC8=23
                    _pc_rel_types_all = {2, 13, 23}
                elif _em_r == 40:   # EM_ARM
                    # R_ARM_PC24=1, R_ARM_REL32=3
                    # ※ 1=R_ARM_PC24 は ARM 専用。x86-64 の 1(ABS64) と衝突するため分離必須。
                    _pc_rel_types_all = {1, 3}
                elif _em_r == 183:  # EM_AARCH64
                    # R_AARCH64_PREL64=260, R_AARCH64_PREL32=261, R_AARCH64_PREL16=262
                    _pc_rel_types_all = {260, 261, 262}
                elif _em_r == 20:   # EM_PPC
                    # R_PPC_REL24=10, R_PPC_REL32=26
                    _pc_rel_types_all = {10, 26}
                elif _em_r == 243:  # EM_RISCV
                    # RISC-V は基本的に絶対アドレス型のみ
                    _pc_rel_types_all = set()
                else:               # EM_X86_64 (62) およびその他
                    # R_X86_64_PC32=2, R_X86_64_GOT32=3, R_X86_64_PLT32=4,
                    # R_X86_64_GOTPCREL=9, R_X86_64_PC16=13, R_X86_64_PC8=15,
                    # R_X86_64_PC64=24
                    # ※ 1=R_X86_64_64 は絶対型なので含めない
                    _pc_rel_types_all = {2, 3, 4, 9, 13, 15, 24}

                for lname, abs_w, first_widx, num_words in groups:
                    num_bytes = num_words * bpw_r

                    # === 最優先で .extern の override を取得 ===
                    rtype = 0
                    lentry = self.state.labels.get(lname)
                    if lentry and len(lentry) > 4 and lentry[4] is not None:
                        rtype = lentry[4]          # plt32 → 4 がここで取れるはず
                    else:
                        rtype = _rmap.get(num_bytes, 0)

                    if rtype == 0 or first_widx >= len(objl):
                        continue

                    sec_rel = (self.state.pc + first_widx - sec_start_w) * bpw_r

                    # raw_val (addend計算用)
                    word_mask = (1 << self.state.bts) - 1
                    raw_val = 0
                    if self.state.endian == 'little':
                        for k in range(num_words):
                            widx_k = first_widx + k
                            if widx_k < len(objl):
                                raw_val |= (int(objl[widx_k]) & word_mask) << (self.state.bts * k)
                    else:
                        for k in range(num_words):
                            widx_k = first_widx + k
                            if widx_k < len(objl):
                                raw_val = (raw_val << self.state.bts) | (int(objl[widx_k]) & word_mask)

                    # UNDEFガード
                    if (isinstance(abs_w, float) and not math.isfinite(abs_w)) or \
                       abs_w == UNDEF or (isinstance(abs_w, int) and abs_w >= (1 << 128)):
                        continue

                    # Bug1修正: raw_val をフィールド幅（num_bytes*8 bit）から符号拡張する。
                    # 例: 0xFFFFFFFC は int32 で -4 だが Python int では 4294967292 になり
                    # addend が PLT32/PC32 の許容範囲 [-2^31, 2^31-1] を大幅に超える。
                    _field_bits = num_bytes * 8
                    if 0 < _field_bits < 64 and raw_val >= (1 << (_field_bits - 1)):
                        raw_val -= (1 << _field_bits)

                    # addend の計算:
                    # ELF PC相対リロケーション (PC32/PLT32等) では、リンカが
                    # フィールドに「S + A - P」を書き込む。実行時に CPU は
                    # rip (= P + num_bytes) + field_value を計算するので、
                    # target = rip + field = S + A - P + P + num_bytes = S + A + num_bytes。
                    # target = S にしたいので A = -num_bytes = -4 (4バイトフィールドの場合)。
                    #
                    # これは pattern が *(s-$$-5,%%) でも *(s-$$,%%) でも同じ。
                    # パターン内の補正値は pc_instr_start との差として raw_val に入るが、
                    # addend にとっては関係なく常に -num_bytes。
                    #
                    # 絶対リロケーション (ABS64/ABS32 等) ではリンカが「S + A」を書き込む。
                    # target = S + A = assembled_sym + offset なので A = raw_val - abs_w。
                    # PC相対リロケーション型の集合。
                    # 12=R_X86_64_16 と 14=R_X86_64_8 は「絶対」アドレスリロケーションなので
                    # 含めない。PC相対の 16/8bit は 13=R_X86_64_PC16, 15=R_X86_64_PC8。
                    if rtype in _pc_rel_types_all:
                        addend = -num_bytes
                    else:
                        addend = raw_val - abs_w
                    self.state.relocations.append((sec_name_r, sec_rel, lname, rtype, addend))

            for cnt in range(of):
                self.binary_writer.outbin(self.state.pc + cnt, objl[cnt])
            self.state.pc += of
        else:
            vflag = False
            try:
                vflag = self.vliw_proc.vliwprocess(line, idxs, objl, flag, idx, self.lineassemble2)
            except Exception:
                if self.state.pas == 0 or self.state.pas == 2:
                    print(" error - Some error(s) in vliw definition.")
            return vflag
        
        return True
    
    def lineassemble0(self, line):
        """Assemble line with output"""
        # Fix 10: state.cl は pass2/対話モードのデバッグ表示にのみ使う。
        # pass1 でも更新していたため、pass1 の最後の行が state.cl に残り、
        # 複数回 run() したときに前回の pass1 値が混入する可能性があった。
        # pass2 または対話モードのときだけ更新する。
        #
        # -v オプション対応: ファイルアセンブル時 (pas==2) はリスト出力を
        # verbose フラグで制御する。対話モード (pas==0) は常に出力する。
        cleaned = line.replace('\n', '').replace('\r', '')
        _show = (self.state.pas == 2 and self.state.verbose) or self.state.pas == 0
        if _show:
            self.state.cl = cleaned
            print("%016x " % self.state.pc, end='')
            print(f"{self.state.current_file} {self.state.ln} {self.state.cl} ", end='')
        f = self.lineassemble(cleaned)
        if _show:
            print("")
        self.state.ln += 1
        return f
    
    def setpatsymbols(self, pat):
        """Set pattern symbols.

        Fix 8: 旧実装は state.symbols を破壊的に更新してから
        patsymbols.update(symbols) していたため、パターンファイル内に
        '.setsym A 1' → '.clearsym'（全消去）という順序で書かれていると
        最終的に patsymbols が空になる問題があった。
        さらに、.clearsym の「全消去」が patsymbols を巻き込む前に
        update() が起きるかどうかは出現順次第だった。

        修正: 空の辞書から始めてパターンエントリを順に適用し、
        最後に patsymbols へ代入することで出現順に正しく反映する。
        state.symbols はアセンブリ中の一時状態なので最後に patsymbols と同期する。
        """
        fresh = {}
        for i in pat:
            if i is None:
                continue
            # .setsym
            if len(i) > 0 and i[0] == '.setsym':
                if len(i) >= 2:
                    key = StringUtils.upper(i[1])
                    if len(i) > 2:
                        # Fix 7: expression_pat は state.symbols を参照してシンボルを解決する。
                        # fresh への書き込み途中の状態を反映させるために、評価前に
                        # state.symbols を現時点の fresh に同期してから式を評価する。
                        self.state.symbols = dict(fresh)
                        v, _ = self.expr_eval.expression_pat(i[2], 0)
                    else:
                        v = 0
                    fresh[key] = v
                continue
            # .clearsym
            if len(i) > 0 and i[0] == '.clearsym':
                if len(i) >= 3 and i[2] != '':
                    key = StringUtils.upper(i[2])
                    fresh.pop(key, None)
                else:
                    fresh = {}
                continue
        self.state.patsymbols = fresh
        self.state.symbols = dict(fresh)
    
    def fileassemble(self, fn):
        """Assemble file.

        Fix ⑧: 旧実装では `fn == "stdin"` という判定の意味と到達経路が
        コード上不明瞭だった。明示的に文書化する。

        到達経路:
          - run() のインタラクティブモード (sourcefile is None) では
            fileassemble() を呼ばない。stdin 入力は lineassemble0() で直接処理。
          - run() のファイルモードでは args.sourcefile を渡す。
          - ソース内の .INCLUDE "stdin" ディレクティブが include_asm() 経由で
            "stdin" という文字列リテラルを渡してくる場合に `fn == "stdin"` が True になる。
          - その際は stdin 全体を一時ファイルに書き出してから読み直す。
            リラクゼーション2回目以降は同じ一時ファイルを再利用する。

        stdin_tmp_path は run() の cleanup で削除される。インタラクティブモードでは
        このパスは None のままであり、cleanup コードは None チェックで安全に動作する。
        """
        # Fix ③: 循環インクルード検出。
        # fnstack には現在開いているファイルのパスが積まれている。
        # 同じ絶対パスが既にスタックに存在する場合は循環と判断してエラーを出す。
        # 比較は絶対パスで行い、相対パス表記の違いによる見落としを防ぐ。

        # Fix: 非循環でも深いネストは Python の再帰限界でクラッシュする。
        # 現実的な上限 (100段) を設けてエラーを出す。
        _MAX_INCLUDE_DEPTH = 100
        if len(self.state.fnstack) >= _MAX_INCLUDE_DEPTH:
            print(f" error - .INCLUDE nesting depth exceeds {_MAX_INCLUDE_DEPTH}: '{fn}'")
            return
        try:
            abs_fn = os.path.abspath(fn) if fn not in ("stdin", "") else fn
        except Exception:
            abs_fn = fn
        for already in self.state.fnstack:
            try:
                already_abs = os.path.abspath(already) if already not in ("stdin", "", "(stdin)") else already
            except Exception:
                already_abs = already
            if abs_fn == already_abs:
                print(f" error - circular .INCLUDE detected: '{fn}' is already being assembled.")
                return

        # fnstack と lnstack を必ずペアで push してから try に入る。
        # これにより finally での pop が常に対称になる。
        self.state.fnstack.append(self.state.current_file)
        self.state.lnstack.append(self.state.ln)
        self.state.current_file = fn
        self.state.ln = 1

        try:
            if fn == "stdin":
                # Pass 1 (pas==1): read stdin and write to a per-instance temp file.
                # Pass 2 (pas==2) and relaxation iterations: re-use the same temp file.
                # Using tempfile instead of the fixed name "axx.tmp" prevents races
                # when multiple axx instances run concurrently.
                if self.state.stdin_tmp_path is None:
                    # 初回のみ: 一時ファイルを作成し stdin を読み込む。
                    # リラクゼーション2回目以降は stdin が EOF なので読み直さない。
                    # pas == 1 の条件で毎回読んでいた旧実装のバグを修正。
                    fd, tmp_path = tempfile.mkstemp(prefix="axx_", suffix=".tmp", text=True)
                    os.close(fd)
                    self.state.stdin_tmp_path = tmp_path
                    af = self.file_input_from_stdin()
                    with open(self.state.stdin_tmp_path, "wt") as stdintmp:
                        stdintmp.write(af)
                fn = self.state.stdin_tmp_path
            
            with open(fn, "rt") as f:
                af = f.readlines()
            
            for i in af:
                self.lineassemble0(i)
        finally:
            # push は try の前で必ず成功しているので、無条件で pop する。
            self.state.current_file = self.state.fnstack.pop()
            self.state.ln = self.state.lnstack.pop()
    
    def file_input_from_stdin(self):
        """Read input from stdin until EOF (Ctrl+D / piped end).
        Empty lines within the input are preserved correctly."""
        af = ""
        while True:
            line = sys.stdin.readline()
            if line == '':   # EOF: readline() returns '' only at EOF
                break
            # Normalize line endings but keep the newline so line numbers match
            af += line.replace('\r', '')
        return af
    
    def imp_label(self, l):
        """Import label from exported TSV format (produced by _write_export).

        Line formats (tab-separated):
          section_name  start_hex  size_hex  [flag]   <- section line (≥3 fields, skip)
          label_name    value_hex                     <- label line (2 fields, import)

        旧実装は "section label value" の空白区切り3トークンを仮定していたが、
        _write_export が出力するのはタブ区切り TSV であり、フォーマットが
        根本的に食い違っていた。さらに skipspc() はタブをスキップしないため
        タブ区切りの先頭フィールド解析も常に失敗していた。
        修正後は str.split('\\t') で TSV を正しく分割し、フィールド数で行種別を
        判定する。セクション行は self._imp_sections に記録し、後続のラベル行が
        セクション名を逆引きできるようにする。
        """
        l = l.rstrip('\r\n')
        if not l:
            return False

        fields = l.split('\t')

        if len(fields) >= 3:
            # Section line: record for later label→section mapping.
            sname = fields[0]
            try:
                start = int(fields[1], 16)
                size  = int(fields[2], 16)
            except ValueError:
                return False
            self._imp_sections[sname] = (start, size)
            return True

        if len(fields) == 2:
            label = fields[0]
            if not label:
                return False
            try:
                v = int(fields[1], 16)
            except ValueError:
                return False
            # Determine section by range lookup in previously parsed section table.
            section = '.text'
            for sname, (start, size) in self._imp_sections.items():
                if size > 0 and start <= v < start + size:
                    section = sname
                    break
                if size == 0 and v == start:
                    section = sname
                    break
            # Fix 7: put_value() は pas 状態に応じて二重定義チェックや
            # 「pass1未定義」エラーを出す。インポートラベルは pas に
            # 関係なく直接 labels に書き込む（上書き可）。
            # Fix 13: is_imported=True を第4フィールドとして記録し、
            # write_elf_obj() がこれを外部シンボル参照（UND）として扱えるようにする。
            # Bugfix: is_equ は False が正しい。インポートラベルはアドレスラベルであり、
            # 定数ラベル（.equ）ではない。True にすると _write_export() でバイト変換が
            # スキップされ、ELF 出力でも SHN_ABS 扱いになって誤ったシンボルになる。
            self.state.labels[label] = [v, section, False, True]  # [val, sec, is_equ, is_imported]
            return True

        return False
    
    def printaddr(self, pc):
        """Print address"""
        print("%016x: " % pc, end='')

    def write_elf_obj(self, path: str, machine: int = 62) -> None:
        """Write a FreeBSD ELF64 relocatable object file (.o).

        File layout:
          ELF header (64 bytes)
          Content section data  (16-byte aligned each)
          .symtab               (8-byte aligned, 24 bytes/entry)
          .strtab
          .shstrtab
          Section header table  (8-byte aligned, 64 bytes/entry)

        Section header indices:
          0          NULL
          1 … N      Content sections in SECTION-directive order
          N+1        .symtab
          N+2        .strtab
          N+3        .shstrtab  (e_shstrndx)
        """
        import struct as _struct

        bpw = max(1, (self.state.bts + 7) // 8)
        buf = self.binary_writer._buffer   # {word_pos: word_val}

        # ------------------------------------------------------------------ #
        # Helper: pack ELF structures                                          #
        # エンディアンは state.endian から決定する。                           #
        #   little → EI_DATA=1 (ELFDATA2LSB), struct prefix '<'              #
        #   big    → EI_DATA=2 (ELFDATA2MSB), struct prefix '>'              #
        # ------------------------------------------------------------------ #
        _is_le    = (self.state.endian != 'big')
        _ei_data  = 1 if _is_le else 2          # EI_DATA byte in e_ident
        _pk       = '<' if _is_le else '>'      # struct.pack prefix

        def _pack_ehdr(e_type, e_machine, e_shoff, e_shnum, e_shstrndx):
            ident = (b'\x7fELF'
                     + bytes([2, _ei_data, 1, self.state.osabi])  # class64, EI_DATA, ver1, ELFOSABI
                     + b'\x00' * 8)
            return ident + _struct.pack(f'{_pk}HHIQQQIHHHHHH',
                e_type, e_machine,
                1,       # e_version
                0,       # e_entry
                0,       # e_phoff
                e_shoff,
                0,       # e_flags
                64,      # e_ehsize
                0, 0,    # phentsize, phnum
                64,      # e_shentsize
                e_shnum,
                e_shstrndx)

        def _pack_shdr(sh_name, sh_type, sh_flags, sh_addr, sh_offset,
                       sh_size, sh_link, sh_info, sh_addralign, sh_entsize):
            return _struct.pack(f'{_pk}IIQQQQIIQQ',
                sh_name, sh_type, sh_flags, sh_addr, sh_offset,
                sh_size, sh_link, sh_info, sh_addralign, sh_entsize)

        def _pack_sym(st_name, st_info, st_other, st_shndx, st_value, st_size):
            return _struct.pack(f'{_pk}IBBHQQ',
                st_name, st_info, st_other, st_shndx, st_value, st_size)

        def _align_up(x, a):
            return (x + a - 1) & ~(a - 1)

        # ------------------------------------------------------------------ #
        # 1. Collect content sections                                          #
        # ------------------------------------------------------------------ #
        def _extract(w_start, w_count):
            """Return bytes for word range [w_start, w_start+w_count)."""
            n = w_count * bpw
            if n == 0:
                return b''
            # Fix K/P: flush() と同じ高速方式で padding を初期化する。
            # 旧実装は Python ループだったが bytes*N の方が大幅に速い。
            pad = int(self.state.padding) & ((1 << self.state.bts) - 1)
            if pad:
                tmp = pad
                if self.state.endian == 'little':
                    pad_bytes = bytes([(tmp >> (8 * j)) & 0xff for j in range(bpw)])
                else:
                    pad_bytes = bytes([(tmp >> (8 * (bpw - 1 - j))) & 0xff for j in range(bpw)])
                data = bytearray(pad_bytes * w_count)
            else:
                data = bytearray(n)
            for pos, val in buf.items():
                if pos < w_start or pos >= w_start + w_count:
                    continue
                off = (pos - w_start) * bpw
                tmp = val
                if self.state.endian == 'little':
                    for j in range(bpw):
                        if off + j < n: data[off + j] = tmp & 0xff
                        tmp >>= 8
                else:
                    for j in range(bpw - 1, -1, -1):
                        if off + j < n: data[off + j] = tmp & 0xff
                        tmp >>= 8
            return bytes(data)

        class _CSec:
            __slots__ = ('name', 'byte_start', 'data', 'byte_size', 'flags')
            def __init__(self, name, byte_start, data, flags):
                self.name       = name
                self.byte_start = byte_start
                self.data       = data
                self.byte_size  = len(data)
                self.flags      = flags

        csecs = []
        max_w = max(buf.keys(), default=-1)

        if not self.state.sections:
            # No SECTION directives → everything into .text
            w_count = max_w + 1 if max_w >= 0 else 0
            csecs.append(_CSec('.text', 0, _extract(0, w_count), 0x2 | 0x4))
        else:
            sec_names = list(self.state.sections.keys())
            for i, sname in enumerate(sec_names):
                # Bugfix: sections entry は [word_start, word_count, entry_pc, confirmed(opt)]
                # の3〜4要素リストなので、2変数へのアンパックは ValueError になる。
                # インデックス参照に変更する。
                w0 = self.state.sections[sname][0]
                wn = self.state.sections[sname][1]
                if wn == 0:
                    if i + 1 < len(sec_names):
                        w1 = self.state.sections[sec_names[i + 1]][0]
                        wn = max(0, w1 - w0)
                    else:
                        wn = max(0, max_w + 1 - w0) if max_w >= w0 else 0
                byte_start = w0 * bpw
                data = _extract(w0, wn)
                uname = sname.upper()
                if   uname.startswith('.TEXT'):   flags = 0x2 | 0x4
                elif uname.startswith('.DATA'):   flags = 0x2 | 0x1
                elif uname.startswith('.RODATA'): flags = 0x2
                elif uname.startswith('.BSS'):    flags = 0x2 | 0x1
                else:                             flags = 0x2
                csecs.append(_CSec(sname, byte_start, data, flags))

        ncs = len(csecs)

        # ------------------------------------------------------------------ #
        # 2. Collect relocations per content section                           #
        # ------------------------------------------------------------------ #
        # Build section-name → section-index (1-based) map
        sec_name_to_idx = {s.name: i + 1 for i, s in enumerate(csecs)}

        # Group relocations: {content_sec_index(1-based): [(offset, sym_name, type, addend)]}
        from collections import defaultdict as _defaultdict
        rela_entries = _defaultdict(list)   # sec_idx → list of (off, sym_name, rtype, addend)
        for (sname, off, sym_name, rtype, addend) in self.state.relocations:
            sidx = sec_name_to_idx.get(sname, 0)
            if sidx:
                rela_entries[sidx].append((off, sym_name, rtype, addend))

        # Content sections that have at least one relocation → need .rela.X section
        rela_sec_order = [i + 1 for i, s in enumerate(csecs) if (i + 1) in rela_entries]
        nrela = len(rela_sec_order)


        shstrtab = bytearray(b'\x00')
        sec_name_offs = []
        for s in csecs:
            sec_name_offs.append(len(shstrtab))
            shstrtab += s.name.encode() + b'\x00'
        # .rela.X セクション名を追加
        rela_name_offs = []
        for sidx in rela_sec_order:
            rela_name_offs.append(len(shstrtab))
            shstrtab += ('.rela' + csecs[sidx - 1].name).encode() + b'\x00'
        symtab_name_off   = len(shstrtab); shstrtab += b'.symtab\x00'
        strtab_name_off   = len(shstrtab); shstrtab += b'.strtab\x00'
        shstrtab_name_off = len(shstrtab); shstrtab += b'.shstrtab\x00'
        shstrtab = bytes(shstrtab)

        # ------------------------------------------------------------------ #
        # 3. Build symbol table (.symtab) and string table (.strtab)          #
        # ------------------------------------------------------------------ #
        def _find_shndx(byte_addr):
            """Return (elf_section_1based, value_within_section).

            Fix 7 (new): byte_addr == 0 のとき、すべてのセクションが
            byte_start > 0 であると範囲外になり SHN_ABS(0xfff1) が返っていた。
            アドレス 0 のラベルは先頭セクションの先頭に属するとみなすのが正しい。
            また byte_size == 0 のセクションが複数あるケースでも
            byte_addr == byte_start の最初の一致を返す。
            """
            # まず通常の範囲チェック（byte_size > 0 のセクションを優先）
            for i, s in enumerate(csecs):
                if s.byte_size > 0 and s.byte_start <= byte_addr < s.byte_start + s.byte_size:
                    return i + 1, byte_addr - s.byte_start
            # サイズ 0 セクションの先頭一致
            for i, s in enumerate(csecs):
                if s.byte_size == 0 and byte_addr == s.byte_start:
                    return i + 1, 0
            # Fix 7: 範囲外の場合、最もアドレスが近い（かつ byte_addr 以下の）
            # セクションに帰属させる。これにより byte_addr==0 でも先頭セクションに
            # 正しく帰属し、SHN_ABS への誤フォールバックを防ぐ。
            if csecs:
                best_i = 0
                best_start = csecs[0].byte_start
                for i, s in enumerate(csecs):
                    if s.byte_start <= byte_addr and s.byte_start >= best_start:
                        best_i = i
                        best_start = s.byte_start
                # Bugfix: byte_addr が全セクションの開始アドレスより小さいとき、
                # ループ内の条件 s.byte_start <= byte_addr が一度も成立せず
                # best_i=0, best_start=csecs[0].byte_start のまま残る。
                # この場合 byte_addr - csecs[best_i].byte_start が負になり、
                # _pack_sym の struct.pack('Q', negative) で struct.error が発生する。
                # 修正: sym_val は 0 以上を保証する。負になる場合は先頭セクションの
                # 先頭（オフセット 0）に帰属させる（アドレス解決は最善努力）。
                sym_val = byte_addr - csecs[best_i].byte_start
                if sym_val < 0:
                    sym_val = 0
                return best_i + 1, sym_val
            return 0xfff1, byte_addr   # SHN_ABS（セクションが一切ない場合のみ）

        strtab = bytearray(b'\x00')
        syms   = []

        # null symbol
        syms.append(_pack_sym(0, 0, 0, 0, 0, 0))

        # section symbols (STB_LOCAL | STT_SECTION = 0x03)
        for i in range(ncs):
            syms.append(_pack_sym(0, 0x03, 0, i + 1, 0, 0))

        # Fix 13: ELF規格では STB_LOCAL シンボルは全て STB_GLOBAL より先でなければ
        # ならない（symtab の sh_info = first_global_index）。
        # インポートラベル（is_imported=True）は STB_GLOBAL なので、
        # ローカル→インポート→エクスポートの順で出力する。
        export_keys = set(self.state.export_labels.keys())

        # ── (1) ローカルシンボル（STB_LOCAL=0x00）────────────────────
        for name, *_lentry in sorted(self.state.labels.items()):
            val         = _lentry[0][0]
            is_equ      = len(_lentry[0]) > 2 and _lentry[0][2]
            is_imported = len(_lentry[0]) > 3 and _lentry[0][3]
            if name in export_keys or is_imported:
                continue
            if is_equ:
                shndx, sym_val = 0xfff1, val
            else:
                byte_addr = val * bpw
                shndx, sym_val = _find_shndx(byte_addr)
            # struct.pack('Q') は [0, 2^64-1] のみ受け付ける。
            # val が負値や 2^64 超の Python int になり得るため uint64 にマスクする。
            sym_val = int(sym_val) & 0xFFFFFFFFFFFFFFFF
            name_off = len(strtab); strtab += name.encode() + b'\x00'
            syms.append(_pack_sym(name_off, 0x00, 0, shndx, sym_val, 0))

        # ── first_global マーク ───────────────────────────────────────
        first_global = len(syms)

        # ── (2) インポートシンボル（STB_GLOBAL=0x10, SHN_UNDEF=0）────
        # -i でインポートした外部ラベル。リンカが外部参照として解決する。
        for name, *_lentry in sorted(self.state.labels.items()):
            is_imported = len(_lentry[0]) > 3 and _lentry[0][3]
            if not is_imported or name in export_keys:
                continue
            name_off = len(strtab); strtab += name.encode() + b'\x00'
            syms.append(_pack_sym(name_off, 0x10, 0, 0, 0, 0))

        # ── (3) エクスポートシンボル（STB_GLOBAL=0x10）───────────────
        for name, *_eentry in sorted(self.state.export_labels.items()):
            val, _sec = _eentry[0][0], _eentry[0][1]
            is_equ = len(_eentry[0]) > 2 and _eentry[0][2]
            if is_equ:
                shndx, sym_val = 0xfff1, val
            else:
                byte_addr = val * bpw
                shndx, sym_val = _find_shndx(byte_addr)
            # struct.pack('Q') は [0, 2^64-1] のみ受け付ける。uint64 にマスクする。
            sym_val = int(sym_val) & 0xFFFFFFFFFFFFFFFF
            name_off = len(strtab); strtab += name.encode() + b'\x00'
            syms.append(_pack_sym(name_off, 0x10, 0, shndx, sym_val, 0))

        symtab = b''.join(syms)
        strtab = bytes(strtab)

        # ------------------------------------------------------------------ #
        # シンボル名 → シンボルテーブルインデックスのマッピングを構築          #
        # syms の出力順 (1)ローカル→(2)インポート→(3)エクスポート に合わせる  #
        #                                                                      #
        # Fix 3: 同名ラベルが labels（ローカル/インポート）と export_labels    #
        # の両方に存在する場合、(3)エクスポートの登録が(1)ローカルを上書きして  #
        # しまい、ELFリロケーションが誤ったシンボルインデックスを参照する問題。  #
        # 修正: 既に登録済みのキーはエクスポート側からは上書きしない。         #
        # ELFの規則上、同名の場合はグローバル（エクスポート）側のインデックスを  #
        # リロケーションに使う方が正しいため、順序を逆転して(3)を先に登録し、   #
        # (1)(2)では export_keys に含まれる名前をスキップする（既存の動作と    #
        # 同一）。これにより重複時は常にエクスポート側のインデックスが使われる。  #
        # ------------------------------------------------------------------ #
        sym_name_to_idx = {}
        _si = 1 + ncs   # null(0) + section syms(1..ncs) を飛ばした位置

        # (1) ローカル（export_keys / imported は除外 → すでに除外済み）
        for name, *_lentry in sorted(self.state.labels.items()):
            is_imported = len(_lentry[0]) > 3 and _lentry[0][3]
            if name in export_keys or is_imported:
                continue
            sym_name_to_idx[name] = _si
            _si += 1

        # (2) インポート
        for name, *_lentry in sorted(self.state.labels.items()):
            is_imported = len(_lentry[0]) > 3 and _lentry[0][3]
            if not is_imported or name in export_keys:
                continue
            sym_name_to_idx[name] = _si
            _si += 1

        # (3) エクスポート
        # Fix 3: エクスポートは必ず登録する（上書き可）。
        # labels にも同名がある場合、リロケーションにはグローバルシンボルを使うべき。
        for name, *_eentry in sorted(self.state.export_labels.items()):
            sym_name_to_idx[name] = _si   # 同名ローカルがあっても上書きして正しいインデックスを指す
            _si += 1

        # ------------------------------------------------------------------ #
        # .rela セクションデータを構築 (Elf64_Rela: offset/info/addend 各8B)  #
        # ------------------------------------------------------------------ #
        def _pack_rela(r_offset, r_sym, r_type, r_addend):
            r_info = (r_sym << 32) | (r_type & 0xffffffff)
            # Bugfix: r_addend は Elf64_Sxword（符号付き64bit）なので
            # struct.pack('q', ...) に渡せる範囲は -2^63 〜 2^63-1。
            # addend = raw_val - abs_w の計算でこの範囲を超えると struct.error が発生する。
            # 修正: 64bit符号付き整数に丸めてからパックする。
            _S64_MAX =  (1 << 63) - 1
            _S64_MIN = -(1 << 63)
            if r_addend > _S64_MAX:
                r_addend = _S64_MAX
            elif r_addend < _S64_MIN:
                r_addend = _S64_MIN
            return _struct.pack(f'{_pk}QQq', r_offset, r_info, r_addend)

        rela_datas = []   # rela_sec_order と同順
        for sidx in rela_sec_order:
            entries = rela_entries[sidx]
            data = b''.join(
                _pack_rela(off, sym_name_to_idx.get(sn, 0), rtype, addend)
                for (off, sn, rtype, addend) in entries
            )
            rela_datas.append(data)

        # ------------------------------------------------------------------ #
        # 4. Compute file offsets                                              #
        # ------------------------------------------------------------------ #
        offset = 64   # after ELF header
        sec_offsets = []
        for s in csecs:
            offset = _align_up(offset, 16)
            sec_offsets.append(offset)
            offset += s.byte_size

        # .rela セクションのファイルオフセット
        rela_offsets = []
        for rd in rela_datas:
            offset = _align_up(offset, 8)
            rela_offsets.append(offset)
            offset += len(rd)

        symtab_off  = _align_up(offset, 8); offset = symtab_off + len(symtab)
        strtab_off  = offset;               offset += len(strtab)
        shstrtab_off = offset;              offset += len(shstrtab)
        shdr_off    = _align_up(offset, 8)

        # セクションヘッダ数: null + content + rela + symtab + strtab + shstrtab
        total_shdrs = 1 + ncs + nrela + 3
        shstrndx    = ncs + nrela + 3
        symtab_shidx = ncs + nrela + 1     # .symtab section index
        strtab_shidx = ncs + nrela + 2     # .strtab section index (= symtab_link)
        symtab_link = strtab_shidx

        # ------------------------------------------------------------------ #
        # 5. Write ELF file                                                    #
        # ------------------------------------------------------------------ #
        with open(path, 'wb') as f:
            # ELF header
            f.write(_pack_ehdr(1, machine, shdr_off, total_shdrs, shstrndx))

            # Content section data
            for i, s in enumerate(csecs):
                cur = f.tell()
                f.write(b'\x00' * (sec_offsets[i] - cur))
                f.write(s.data)

            # .rela.X セクションデータ
            for i, rd in enumerate(rela_datas):
                cur = f.tell()
                f.write(b'\x00' * (rela_offsets[i] - cur))
                f.write(rd)

            # .symtab
            cur = f.tell(); f.write(b'\x00' * (symtab_off - cur))
            f.write(symtab)

            # .strtab
            f.write(strtab)

            # .shstrtab
            f.write(shstrtab)

            # Section header table
            cur = f.tell(); f.write(b'\x00' * (shdr_off - cur))

            f.write(_pack_shdr(0, 0, 0, 0, 0, 0, 0, 0, 0, 0))  # [0] NULL

            for i, s in enumerate(csecs):                        # [1..ncs] content
                f.write(_pack_shdr(
                    sec_name_offs[i], 1, s.flags, 0,
                    sec_offsets[i], s.byte_size, 0, 0, 16, 0))

            for ri, sidx in enumerate(rela_sec_order):           # .rela.X
                # sh_flags: SHF_INFO_LINK=0x40
                f.write(_pack_shdr(
                    rela_name_offs[ri], 4, 0x40, 0,
                    rela_offsets[ri], len(rela_datas[ri]),
                    symtab_shidx, sidx, 8, 24))

            f.write(_pack_shdr(                                   # .symtab
                symtab_name_off, 2, 0, 0,
                symtab_off, len(symtab),
                symtab_link, first_global, 8, 24))

            f.write(_pack_shdr(                                   # .strtab
                strtab_name_off, 3, 0, 0,
                strtab_off, len(strtab), 0, 0, 1, 0))

            f.write(_pack_shdr(                                   # .shstrtab
                shstrtab_name_off, 3, 0, 0,
                shstrtab_off, len(shstrtab), 0, 0, 1, 0))

        print(f"elf: wrote {path} ({ncs} section(s), {nrela} rela section(s), {len(syms)} symbol(s))",
              file=sys.stderr)

    def _build_arg_parser(self):
        """Build and return the argparse.ArgumentParser for axx."""
        import argparse
        ap = argparse.ArgumentParser(
            prog='axx',
            description='axx general assembler programmed and designed by Taisuke Maekawa',
            formatter_class=argparse.RawDescriptionHelpFormatter,
        )
        ap.add_argument('patternfile',
                        help='Pattern definition file (.axx)')
        ap.add_argument('sourcefile', nargs='?', default=None,
                        help='Assembly source file (.s). Omit for interactive mode.')
        ap.add_argument('--osabi', dest='elf_osabi', type=str, default='FreeBSD',
                        choices=['FreeBSD', 'Linux'],
                        help='ELF OSABI value (default: FreeBSD)')
        ap.add_argument('-b', dest='outfile', default='',
                        metavar='OUTFILE',
                        help='Output binary file')
        ap.add_argument('-e', dest='expfile', default='',
                        metavar='EXPORT_TSV',
                        help='Export labels to TSV file (plain format)')
        ap.add_argument('-E', dest='expfile_elf', default='',
                        metavar='EXPORT_ELF_TSV',
                        help='Export labels to TSV file (ELF section flags format)')
        ap.add_argument('-i', dest='impfile', default='',
                        metavar='IMPORT_TSV',
                        help='Import labels from TSV file')
        ap.add_argument('-o', dest='elf_objfile', default='',
                        metavar='OBJ_FILE',
                        help='Write ELF64 relocatable object file (.o)')
        ap.add_argument('-m', dest='elf_machine', type=int, default=62,
                        metavar='MACHINE',
                        help='ELF e_machine value (default 62=EM_X86_64; '
                             '183=AArch64, 243=RISC-V, 3=i386, 20=PPC, 40=ARM)')
        ap.add_argument('-v', '--verbose', dest='verbose', action='store_true',
                        default=False,
                        help='Verbose: print assembly listing to stdout (default: silent)')
        ap.add_argument('-d', '--debug', dest='debug', action='store_true',
                        default=False,
                        help='Enable debug output (forward-ref fallback, relaxation log, etc.)')
        return ap

    def run(self):
        """Main assembly process"""
        ap = self._build_arg_parser()

        # argparse prints help and exits when no arguments are given,
        # but we want a custom usage message and a clean return instead.
        if len(sys.argv) == 1:
            ap.print_help()
            return

        args = ap.parse_args()

        # make osabi table
        osabitbl = {'Linux':0,'FreeBSD':9}

        # --- Apply parsed options to assembler state ---
        self.state.outfile      = args.outfile
        self.state.expfile      = args.expfile
        self.state.expfile_elf  = args.expfile_elf
        self.state.impfile      = args.impfile
        self.state.elf_objfile  = args.elf_objfile
        self.state.elf_machine  = args.elf_machine
        # Fix 1: use .get() so unknown OSABI strings never raise KeyError.
        # argparse choices= already guards this, but the table and the
        # choices list could drift independently. Default to FreeBSD (9).
        if args.elf_osabi not in osabitbl:
            print(f"warning: unknown --osabi value '{args.elf_osabi}'; "
                  f"valid choices are {list(osabitbl.keys())}. Using 'FreeBSD'.",
                  file=sys.stderr)
        self.state.osabi        = osabitbl.get(args.elf_osabi, 9)
        self.state.verbose      = args.verbose
        self.state.debug        = args.debug

        # Fix 5 (original) + Fix 8 (new): run() 全体を try/finally で囲む。
        # Fix 8: readpat や impfile open もここに含めることで、パターンファイルや
        # インポートファイルの読み込み中に例外が起きた場合も finally が確実に実行される。
        try:
            # Load pattern file
            self.state.pat = self.pattern_reader.readpat(args.patternfile)
            self.setpatsymbols(self.state.pat)

            # Import labels
            if self.state.impfile:
                # Bugfix: 旧実装は imp_label() を1行ずつ逐次呼び出していたため、
                # TSVファイルでセクション行（3フィールド以上）がラベル行より後に
                # 来るとき _imp_sections がまだ空で、ラベルが全て '.text' に
                # 帰属されてしまっていた。
                # 修正: 2パス読み込みを行う。
                #   パス1: セクション行だけを処理して _imp_sections を構築する。
                #   パス2: ラベル行を処理する（_imp_sections が完成している状態）。
                with open(self.state.impfile, 'rt') as label_file:
                    raw_lines = label_file.readlines()
                # Pass 1: section lines (3+ fields)
                for l in raw_lines:
                    fields = l.rstrip('\r\n').split('\t')
                    if len(fields) >= 3:
                        self.imp_label(l)
                # Pass 2: label lines (2 fields)
                for l in raw_lines:
                    fields = l.rstrip('\r\n').split('\t')
                    if len(fields) == 2:
                        self.imp_label(l)

            # Remove stale output file before writing
            if self.state.outfile:
                try:
                    os.remove(self.state.outfile)
                except OSError:
                    pass

            # --- Assemble ---
            if args.sourcefile is None:
                # Interactive / stdin mode (single pass)
                self.state.pc = 0
                self.state.pas = 0
                self.state.ln = 1
                self.state.current_file = "(stdin)"
                while True:
                    self.printaddr(self.state.pc)
                    try:
                        line = input(">> ")
                        line = line.replace("\\\\", "\\")
                    except EOFError:
                        break
                    line = line.strip()
                    if line == "":
                        continue
                    if line == "?":
                        self.label_manager.printlabels()
                        continue
                    self.lineassemble0(line)
            else:
                # Two-pass file assembly with pass1 relaxation.
                #
                # 可変長命令アーキテクチャでは、forward参照ラベルを 0 と仮定した
                # pass1 のサイズ推定が間違い、pass2 でアドレスがずれることがある。
                # 対策: pass1 を最大 MAX_RELAX 回繰り返し、全ラベルの PC が
                # 前回と一致したら収束とみなして pass2 に進む（リラクゼーション法）。
                # 修正⑤: 旧実装は _pass1_prev_label_pcs = None で初期化し、
                # 初回イテレーション後の比較が「dict == None」→ 常に False となっていた。
                # ラベルが1回目で既に安定していても必ず2回目のパスが走る無駄があった。
                # 修正後: 初期値を「空の dict に絶対マッチしない番兵」として
                # object() を使う。これにより初回に収束したケースも正しく break できる。
                # （空ソースや全ラベルが .equ のみのケースで1パス節約できる）
                MAX_RELAX = 8
                # Fix 7: _SENTINEL をモジュールレベル定数に変更。
                # ローカルの object() では run() を複数回呼び出したとき
                # 前回の state._pass1_prev_label_pcs と比較できなくなる。
                self.state._pass1_prev_label_pcs = _RELAXATION_SENTINEL

                # Fix 5: リラクゼーションループの先頭で labels = {} にリセットすると
                # -i オプションでインポートしたラベルも消えてしまう。
                # インポート済みラベルをスナップショットして毎イテレーション先頭で復元する。
                _imported_labels = dict(self.state.labels)

                # 修正⑧: vars（a-z 変数）もリラクゼーションループ先頭でリセットする。
                # 各命令の先頭でも per-instruction リセットが入るため実害は少ないが、
                # 最後の命令後に残った値がパス間で持ち越されないよう明示的にクリアする。
                _initial_vars = list(self.state.vars)

                for relax_iter in range(MAX_RELAX):
                    self.state.pc = 0
                    self.state.pas = 1
                    self.state.ln = 1
                    # インポートラベルを保持しつつ、前回イテレーションのアドレスラベルをリセット
                    self.state.labels = dict(_imported_labels)
                    self.state.sections = {}
                    self.state.export_labels = {}
                    # Bug修正: current_section をリセットしないと、前イテレーション末尾の
                    # セクション (例: '.data') が次イテレーション先頭の old_sec になり、
                    # section .text 処理時に '.data' が pc=0 で誤登録される。
                    self.state.current_section = '.text'
                    # ソース内の .setsym / .clearsym が前回イテレーションで
                    # symbols を変化させている可能性があるため、
                    # パターンファイル読み込み直後の状態（patsymbols）に毎回リセットする。
                    self.state.symbols = dict(self.state.patsymbols)
                    # 修正⑧: vars をリラクゼーション開始時の状態に戻す
                    self.state.vars = list(_initial_vars)
                    self.fileassemble(args.sourcefile)

                    # Bug修正: pass1でも最終セクションのサイズを確定する。
                    # section_processing は切り替え時のみ旧セクションを更新するため
                    # ファイル末尾のセクションが size=0 になる。
                    _last_sec1 = self.state.current_section
                    if _last_sec1 in self.state.sections:
                        _e1 = self.state.sections[_last_sec1]
                        if not (len(_e1) > 3 and _e1[3]):
                            _ep1 = _e1[2] if len(_e1) > 2 else _e1[0]
                            _blk1 = self.state.pc - _ep1
                            if _blk1 > 0:
                                _e1[1] += _blk1

                    # Fix ⑥-2: 収束スナップショットに PC 値だけでなくセクション帰属も含める。
                    # 旧実装は {label: pc} のみを比較していたため、.section ディレクティブの
                    # 動的切り替えによってラベルのセクション帰属が変動し続けるケースで
                    # PC が安定した時点で収束と誤判定していた。
                    # (pc, section) のペアで比較することで両方が安定して初めて収束と判定する。
                    current_pcs = {k: (v[0], v[1]) for k, v in self.state.labels.items()}
                    # Fix ⑤: UNDEF (= 0xff...ff) が PC 値として混入している場合、
                    # 前後のパスで同じ UNDEF ならば「収束」と誤判定されてしまう。
                    # 実際にはアドレスが確定していないので収束していない。
                    # UNDEF を含むラベルがひとつでも存在するなら収束とみなさない。
                    #
                    # Fix ⑮ (新規): UNDEF に加減算したような UNDEF 由来の値も検出する。
                    # UNDEF = 2^256 - 1 なので、現実のアセンブラで PC が 2^128 を
                    # 超えることはない。2^128 以上の値をすべて「UNDEF 由来」として扱い、
                    # 誤収束を防ぐ。
                    #
                    # Bugfix: is_equ=True の定数ラベル（.equ で定義された整数定数）は
                    # PC 値ではなく任意精度の整数値を保持する。
                    # qad{} や 0x10000...（128bit超）のような大きな定数を .equ で定義すると
                    # UNDEF_THRESHOLD を超えて has_undef=True になり、毎回収束しなくなる。
                    # 修正: アドレスラベル（is_equ=False）の値のみを UNDEF チェックする。
                    _UNDEF_THRESHOLD = 1 << 128
                    has_undef = any(
                        pc == UNDEF or (isinstance(pc, int) and pc >= _UNDEF_THRESHOLD)
                        for k, (pc, _sec) in current_pcs.items()
                        # is_equ=True の定数ラベルは除外（任意の大きさの整数値を持てる）
                        if not (len(self.state.labels[k]) > 2 and self.state.labels[k][2])
                    )
                    # 修正⑤: _RELAXATION_SENTINEL との比較は必ず False なので初回は無条件続行。
                    # 2回目以降は前回と一致しかつ UNDEF がなければ収束と判定できる。
                    if (not has_undef
                            and self.state._pass1_prev_label_pcs is not _RELAXATION_SENTINEL
                            and current_pcs == self.state._pass1_prev_label_pcs):
                        if self.state.debug:
                            print(f"Pass1 relaxation converged after {relax_iter + 1} iteration(s)", file=sys.stderr)
                        break   # 収束
                    self.state._pass1_prev_label_pcs = current_pcs
                else:
                    # 収束しなかった場合の詳細情報
                    print("WARNING: Pass1 relaxation did not converge after {0} iterations.".format(MAX_RELAX), 
                          file=sys.stderr)
                    print("         Generated code may have incorrect addresses for", file=sys.stderr)
                    print("         variable-length instructions with forward references.", file=sys.stderr)
                    if self.state.debug and isinstance(self.state._pass1_prev_label_pcs, dict):
                        # デバッグモードでは変化したラベルを表示
                        changed = []
                        for k in current_pcs:
                            if k in self.state._pass1_prev_label_pcs:
                                if current_pcs[k] != self.state._pass1_prev_label_pcs[k]:
                                    changed.append(k)
                        if changed:
                            print(f"         Labels still changing: {', '.join(changed[:10])}", file=sys.stderr)

                self.state.pc = 0
                self.state.pas = 2
                self.state.ln = 1
                self.state.relocations = []   # pass2 でリロケーションを新規収集
                # Fix 5 (new): pass1 リラクゼーション中に section_processing の
                # 暫定サイズ（Fix 3）や ENDSECTION 確定サイズ（Fix 2）が残ったまま
                # pass2 に入ると、section 再宣言時の保護ロジックが誤って古いサイズを
                # 保持することがある。pass2 先頭で sections をリセットして
                # 確定的に再構築させる。labels・patsymbols はリセット不要。
                self.state.sections = {}
                self.state.current_section = '.text'  # Bug修正: pass2前にリセット
                self.fileassemble(args.sourcefile)

                # Bug修正: section_processing は「セクション切り替え時」に
                # 旧セクションのサイズを更新する。ファイル末尾の最終セクションは
                # 切り替えが発生しないため size=0 のままになる。
                # fileassemble 完了後に current_section を明示的に確定する。
                _last_sec = self.state.current_section
                if _last_sec in self.state.sections:
                    _e = self.state.sections[_last_sec]
                    _confirmed = len(_e) > 3 and _e[3]
                    if not _confirmed:
                        _entry_pc = _e[2] if len(_e) > 2 else _e[0]
                        _block = self.state.pc - _entry_pc
                        if _block > 0:
                            _e[1] += _block

            self.binary_writer.flush()

            # --- ELF relocatable object file ---
            if self.state.elf_objfile:
                self.write_elf_obj(self.state.elf_objfile, self.state.elf_machine)

            # --- Export labels ---
            # -e と -E が同時に指定された場合は警告を出し、両方を別々に出力する。
            # 以前は -E が -e をサイレントに上書きしていた。
            if self.state.expfile_elf and self.state.expfile:
                print(f"warning: both -e '{self.state.expfile}' and -E '{self.state.expfile_elf}' specified; "
                      f"exporting plain format to -e and ELF format to -E separately.",
                      file=sys.stderr)

            def _write_export(path, elf):
                h   = list(self.state.export_labels.items())
                key = list(self.state.sections.keys())
                _bpw_export = max(1, (self.state.bts + 7) // 8)
                with open(path, 'wt') as label_file:
                    for i in key:
                        if i == '.text' and elf == 1:
                            flag = 'AX'
                        elif i == '.data' and elf == 1:
                            flag = 'WA'
                        else:
                            flag = ''
                        w_start = self.state.sections[i][0]
                        w_count = self.state.sections[i][1]
                        try:
                            byte_start = int(w_start) * _bpw_export
                            byte_size  = int(w_count) * _bpw_export
                        except (OverflowError, ValueError, TypeError):
                            byte_start = 0
                            byte_size  = 0
                        label_file.write(
                            f"{i}\t{byte_start:#x}\t{byte_size:#x}\t{flag}\n"
                        )
                    for i in h:
                        lbl_is_equ = len(i[1]) > 2 and i[1][2]
                        lbl_addr_raw = i[1][0] if lbl_is_equ else i[1][0] * _bpw_export
                        try:
                            lbl_addr = int(lbl_addr_raw)
                        except (OverflowError, ValueError, TypeError):
                            lbl_addr = 0
                        
                        # Fix: reloc_type_override を出力に含める
                        reloc_type_str = ''
                        lentry = self.state.labels.get(i[0], [])
                        if len(lentry) > 4 and lentry[4] is not None:
                            # Reverse lookup: rtype value → name
                            _RTYPE_REVERSE = {
                                # 絶対リロケーション
                                1:  'abs64',   # R_X86_64_64
                                10: 'abs32',   # R_X86_64_32
                                11: 'abs32s',  # R_X86_64_32S
                                12: 'abs16',   # R_X86_64_16
                                14: 'abs8',    # R_X86_64_8
                                # PC相対リロケーション
                                2:  'pc32',    # R_X86_64_PC32
                                4:  'plt32',   # R_X86_64_PLT32
                                13: 'pc16',    # R_X86_64_PC16
                                15: 'pc8',     # R_X86_64_PC8
                                24: 'pc64',    # R_X86_64_PC64
                                # GOT相対リロケーション
                                3:  'got32',   # R_X86_64_GOT32
                                9:  'gotpcrel', # R_X86_64_GOTPCREL
                                27: 'got64',   # R_X86_64_GOT64
                            }
                            reloc_type_str = _RTYPE_REVERSE.get(lentry[4], '')
                            if reloc_type_str:
                                reloc_type_str = f'::{reloc_type_str}'
                        
                        label_file.write(f"{i[0]}{reloc_type_str}\t{lbl_addr:#x}\n")
                

            if self.state.expfile:
                _write_export(self.state.expfile, elf=0)
            if self.state.expfile_elf:
                _write_export(self.state.expfile_elf, elf=1)

        finally:
            # Fix 5: KeyboardInterrupt や未捕捉例外でも一時ファイルを確実に削除する。
            if self.state.stdin_tmp_path and os.path.exists(self.state.stdin_tmp_path):
                try:
                    os.remove(self.state.stdin_tmp_path)
                except OSError:
                    pass
                self.state.stdin_tmp_path = None


def main():
    """Main entry point"""
    assembler = Assembler()
    assembler.run()


if __name__ == '__main__':
    main()
    exit(0)