nyar_assembler/program/

instructions.rs

use gaia_binary::{BinaryReader, BinaryWriter, Leb128};
use gaia_types::GaiaError;
use serde::{Deserialize, Serialize};
use std::io::Cursor;

/// 上值引用
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct NyarUpvalueRef {
    /// 是否为局部变量
    pub is_local: bool,
    /// 索引
    pub index: u8,
}

/// Nyar 指令枚举
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum NyarInstruction {
    /// 无操作
    Nop,
    /// 入栈常量，参数为常量池索引
    Push(u16),
    /// 入栈空值
    PushNone,
    /// 栈顶出栈
    Pop,
    /// 复制栈顶元素，参数为相对于栈顶的深度
    Dup(u8),
    /// 交换栈顶两个元素，参数为相对于栈顶的深度
    Swap(u8),
    /// 加载局部变量，参数为局部变量索引
    LoadLocal(u8),
    /// 存储局部变量，参数为局部变量索引
    StoreLocal(u8),
    /// 加载全局变量，参数为全局变量名索引
    LoadGlobal(u16),
    /// 存储全局变量，参数为全局变量名索引
    StoreGlobal(u16),
    /// 加载上值，参数为上值索引
    LoadUpvalue(u8),
    /// 存储上值，参数为上值索引
    StoreUpvalue(u8),
    /// 关闭所有开启的上值
    CloseUpvalues,
    /// 无条件跳转，参数为相对偏移量
    Jump(i16),
    /// 如果栈顶为假则跳转
    JumpIfFalse(i16),
    /// 如果栈顶为真则跳转
    JumpIfTrue(i16),
    /// 如果栈顶为空则跳转
    JumpIfNull(i16),
    /// 函数返回
    Return,
    /// 创建闭包，参数为函数体索引和上值引用列表
    MakeClosure(u16, Vec<NyarUpvalueRef>),
    /// 尾递归调用，参数为函数名索引和参数数量
    TailCall(u16, u8),
    /// 闭包尾递归调用，参数为参数数量
    TailCallClosure(u8),
    /// 函数调用，参数为函数名索引和参数数量
    Call(u16, u8),
    /// 虚函数调用，参数为函数名索引和参数数量
    CallVirtual(u16, u8),
    /// 动态调用，参数为函数名索引和参数数量
    CallDynamic(u16, u8),
    /// 闭包调用，参数为参数数量
    CallClosure(u8),
    /// 方法调用，参数为函数名索引和参数数量
    InvokeMethod(u16, u8),
    /// 符号调用，参数为符号名索引和参数数量
    CallSymbol(u16, u8),
    /// 获取对象字段，参数为字段名索引
    GetField(u16),
    /// 设置对象字段，参数为字段名索引
    SetField(u16),
    /// 创建新对象，参数为类型名索引
    NewObject(u16),
    /// 创建新数组，参数为长度
    NewArray(u16),
    /// 获取容器元素
    GetElement,
    /// 设置容器元素
    SetElement,
    /// 创建动态对象
    NewDynObject,
    /// 移除容器中的键
    RemoveKey,
    /// 初始化对象
    Initiate(u8),
    /// 终止对象生命周期
    Finalize,
    /// 创建新列表
    NewList(u16),
    /// 元素入队左侧
    PushElementLeft,
    /// 元素出队左侧
    PopElementLeft,
    /// 元素入队右侧
    PushElementRight,
    /// 元素出队右侧
    PopElementRight,
    /// 创建元组，参数为元素数量
    MakeTuple(u8),
    /// Check if key exists
    HasKey,
    /// Match enum variant
    MatchVariant(u16),
    /// Get container size
    SizeOf,
    /// Get element type
    TypeOf,
    /// Check if value is instance of type
    InstanceOf(u16),
    /// Check type cast validity
    CheckCast(u16),
    /// Perform type cast
    Cast(u16),
    /// Perform side effect
    Perform(u16, u8),
    /// Register side effect handler
    WithHandler(u16),
    /// Resume continuation
    ResumeWith,
    /// Capture continuation
    CaptureCont,
    /// Await async operation
    Await,
    /// Blocking await async operation
    BlockOn,
    /// Match side effect result
    MatchEffect(u16),
    /// Get vtable index
    GetWitnessTable(u16, u16),
    /// Call vtable method
    WitnessMethod(u16),
    /// Open existential type
    OpenExistential,
    /// Close existential type
    CloseExistential,
    /// Reference LIR code block
    Quote(u32),
    /// Splice LIR expression
    Splice,
    /// Evaluate LIR expression
    Eval(u8),
    /// Expand macro
    ExpandMacro(u16, u8),
    /// FFI call
    FFICall(u16, u8),
    /// Halt execution
    Halt,

    // --- Arithmetic and Logic Extensions ---
    /// I32 constant
    I32Const(i32),
    /// I32 addition
    I32Add,
    /// I32 subtraction
    I32Sub,
    /// I32 multiplication
    I32Mul,
    /// I32 signed division
    I32DivS,
    /// I32 unsigned division
    I32DivU,
    /// I32 signed remainder
    I32RemS,
    /// I32 unsigned remainder
    I32RemU,
    /// I32 bitwise AND
    I32And,
    /// I32 bitwise OR
    I32Or,
    /// I32 bitwise XOR
    I32Xor,
    /// I32 left shift
    I32Shl,
    /// I32 signed right shift
    I32ShrS,
    /// I32 unsigned right shift
    I32ShrU,
    /// I32 bitwise NOT
    I32Not,
    /// I32 negate
    I32Neg,
    /// I32 equal
    I32Eq,
    /// I32 not equal
    I32Ne,
    /// I32 signed less than
    I32LtS,
    /// I32 unsigned less than
    I32LtU,
    /// I32 signed less than or equal
    I32LeS,
    /// I32 unsigned less than or equal
    I32LeU,
    /// I32 signed greater than
    I32GtS,
    /// I32 unsigned greater than
    I32GtU,
    /// I32 signed greater than or equal
    I32GeS,
    /// I32 unsigned greater than or equal
    I32GeU,
    /// I32 to F32 (signed)
    I32ToF32S,
    /// I32 to F32 (unsigned)
    I32ToF32U,
    /// I32 to F64 (signed)
    I32ToF64S,
    /// I32 to F64 (unsigned)
    I32ToF64U,
    /// I32 addition (saturated signed)
    I32AddSatS,
    /// I32 addition (saturated unsigned)
    I32AddSatU,
    /// I32 subtraction (saturated signed)
    I32SubSatS,
    /// I32 subtraction (saturated unsigned)
    I32SubSatU,
    /// I32 sign extend to I64
    I32Extend64S,
    /// I32 zero extend to I64
    I32Extend64U,
    /// I32 truncate I64 (low)
    I32Trunc64SLow,
    /// I32 truncate I64 (signed)
    I32Trunc64S,
    /// I32 truncate I64 (unsigned)
    I32Trunc64U,

    /// I64 常量
    I64Const(i64),
    /// I64 加法
    I64Add,
    /// I64 减法
    I64Sub,
    /// I64 乘法
    I64Mul,
    /// I64 有符号除法
    I64DivS,
    /// I64 无符号除法
    I64DivU,
    /// I64 有符号取模
    I64RemS,
    /// I64 无符号取模
    I64RemU,
    /// I64 按位与
    I64And,
    /// I64 按位或
    I64Or,
    /// I64 按位异或
    I64Xor,
    /// I64 左移
    I64Shl,
    /// I64 有符号右移
    I64ShrS,
    /// I64 无符号右移
    I64ShrU,
    /// I64 按位取反
    I64Not,
    /// I64 取负
    I64Neg,
    /// I64 等于
    I64Eq,
    /// I64 不等于
    I64Ne,
    /// I64 有符号小于
    I64LtS,
    /// I64 无符号小于
    I64LtU,
    /// I64 有符号小于等于
    I64LeS,
    /// I64 无符号小于等于
    I64LeU,
    /// I64 有符号大于
    I64GtS,
    /// I64 无符号大于
    I64GtU,
    /// I64 有符号大于等于
    I64GeS,
    /// I64 无符号大于等于
    I64GeU,
    /// I64 转 F32 (有符号)
    I64ToF32S,
    /// I64 转 F32 (无符号)
    I64ToF32U,
    /// I64 转 F64 (有符号)
    I64ToF64S,
    /// I64 转 F64 (无符号)
    I64ToF64U,
    /// I64 加法 (饱和有符号)
    I64AddSatS,
    /// I64 加法 (饱和无符号)
    I64AddSatU,

    /// F32 常量
    F32Const(f32),
    /// F32 加法
    F32Add,
    /// F32 减法
    F32Sub,
    /// F32 乘法
    F32Mul,
    /// F32 除法
    F32Div,
    /// F32 取负
    F32Neg,
    /// F32 等于
    F32Eq,
    /// F32 不等于
    F32Ne,
    /// F32 小于
    F32Lt,
    /// F32 小于等于
    F32Le,
    /// F32 大于
    F32Gt,
    /// F32 大于等于
    F32Ge,
    /// F32 转 I32 (有符号)
    F32ToI32S,
    /// F32 转 I32 (无符号)
    F32ToI32U,
    /// F32 转 I64 (有符号)
    F32ToI64S,
    /// F32 转 I64 (无符号)
    F32ToI64U,
    /// F32 转 F64
    F32ToF64,

    /// F64 常量
    F64Const(f64),
    /// F64 加法
    F64Add,
    /// F64 减法
    F64Sub,
    /// F64 乘法
    F64Mul,
    /// F64 除法
    F64Div,
    /// F64 取负
    F64Neg,
    /// F64 等于
    F64Eq,
    /// F64 不等于
    F64Ne,
    /// F64 小于
    F64Lt,
    /// F64 小于等于
    F64Le,
    /// F64 大于
    F64Gt,
    /// F64 大于等于
    F64Ge,
    /// F64 转 I32 (有符号)
    F64ToI32S,
    /// F64 转 I32 (无符号)
    F64ToI32U,
    /// F64 转 I64 (有符号)
    F64ToI64S,
    /// F64 转 I64 (无符号)
    F64ToI64U,
    /// F64 转 F32
    F64ToF32,

    /// 大整数常量
    BigIntConst {
        /// 符号 (0: 正, 1: 负)
        sign: u8,
        /// 原始字节数据
        bytes: Vec<u8>,
    },
    /// 大整数加法
    BigIntAdd,
    /// 大整数减法
    BigIntSub,
    /// 大整数乘法
    BigIntMul,
    /// 大整数除法
    BigIntDiv,
    /// 大整数取模
    BigIntMod,
    /// 大整数取负
    BigIntNeg,
    /// 大整数等于
    BigIntEq,
    /// 大整数不等于
    BigIntNe,
    /// 大整数小于
    BigIntLt,
    /// 大整数小于等于
    BigIntLe,
    /// 大整数大于
    BigIntGt,
    /// 大整数大于等于
    BigIntGe,
    /// 大整数转 I64
    BigIntToI64,
    /// I64 转 大整数
    BigIntFromI64,
    /// 大整数转字符串
    BigIntToString,

    /// 字符串常量
    StringConst(String),
    /// 字符串拼接
    StringConcat,
    /// 字符串长度 (字节)
    StringLenBytes,
    /// 字符串长度 (字符)
    StringLenChars,
    /// 字符串等于
    StringEq,
    /// 字符串不等于
    StringNe,
    /// 字符串小于
    StringLt,
    /// 字符串小于等于
    StringLe,
    /// 字符串大于
    StringGt,
    /// 字符串大于等于
    StringGe,
    /// 字符串截取
    StringSubstr,

    /// 新建通道
    NewChannel(u16),
    /// 发送通道消息
    SendChannel,
    /// 接收通道消息
    RecvChannel,
    /// 选择通道
    SelectChannel(u8),
    /// 新建查询
    NewQuery(u16),
    /// 执行查询
    QueryExec,
    /// 新建时钟
    NewClock,
    /// 时钟等待
    ClockWait,
}

/// Nyar 操作码枚举
#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum NyarOpcode {
    /// 无操作
    Nop = 0x00,
    /// 入栈
    Push = 0x01,
    /// 出栈
    Pop = 0x02,
    /// 复制栈顶
    Dup = 0x03,
    /// 交换栈顶
    Swap = 0x04,
    /// 加载局部变量
    LoadLocal = 0x05,
    /// 存储局部变量
    StoreLocal = 0x06,
    /// 加载全局变量
    LoadGlobal = 0x07,
    /// 存储全局变量
    StoreGlobal = 0x08,
    /// 加载上值 (Upvalue)
    LoadUpvalue = 0x09,
    /// 存储上值 (Upvalue)
    StoreUpvalue = 0x0A,
    /// 关闭上值
    CloseUpvalues = 0x0B,
    /// 无条件跳转
    Jump = 0x0C,
    /// 为假时跳转
    JumpIfFalse = 0x0D,
    /// 为真时跳转
    JumpIfTrue = 0x0E,
    /// 为空时跳转
    JumpIfNull = 0x0F,
    /// 入栈空值
    PushNone = 0x10,
    /// 返回
    Return = 0x13,
    /// 创建闭包
    MakeClosure = 0x15,

    /// 函数调用
    Call = 0x20,
    /// 虚函数调用
    CallVirtual = 0x21,
    /// 动态调用
    CallDynamic = 0x22,
    /// 闭包调用
    CallClosure = 0x23,
    /// 方法调用
    InvokeMethod = 0x24,
    /// 符号调用
    CallSymbol = 0x25,
    /// FFI 调用
    FFICall = 0xF0,
    /// 尾调用
    TailCall = 0x14,
    /// 闭包尾调用
    TailCallClosure = 0x16,

    /// 获取字段
    GetField = 0x30,
    /// 设置字段
    SetField = 0x31,
    /// 创建对象
    NewObject = 0x32,
    /// 创建数组
    NewArray = 0x33,
    /// 获取元素
    GetElement = 0x34,
    /// 设置元素
    SetElement = 0x35,
    /// 创建元组
    MakeTuple = 0x36,
    /// 是否存在键
    HasKey = 0x37,
    /// 匹配变体
    MatchVariant = 0x38,
    /// 获取大小
    SizeOf = 0x39,
    /// 创建动态对象
    NewDynObject = 0x3A,
    /// 移除键
    RemoveKey = 0x3B,
    /// 创建列表
    NewList = 0x3C,
    /// 左侧入队
    PushElementLeft = 0x3D,
    /// 左侧出队
    PopElementLeft = 0x3E,
    /// 元素入队右侧
    PushElementRight = 0x3F,
    /// 元素出队右侧
    PopElementRight = 0x40,
    /// 获取类型
    TypeOf = 0x41,
    /// 类型实例判断
    InstanceOf = 0x42,
    /// 检查转换
    CheckCast = 0x43,
    /// 类型转换
    Cast = 0x44,
    /// 初始化
    Initiate = 0x45,
    /// 终止
    Finalize = 0x46,
    /// 执行副作用 (Effect)
    Perform = 0x50,
    /// 注册副作用处理器
    WithHandler = 0x51,
    /// 继续副作用执行
    ResumeWith = 0x52,
    /// 捕获延续 (Continuation)
    CaptureCont = 0x53,
    /// 等待 (Await)
    Await = 0x54,
    /// 阻塞等待 (BlockOn)
    BlockOn = 0x55,
    /// 匹配副作用
    MatchEffect = 0x56,
    /// 获取虚表
    GetWitnessTable = 0x60,
    /// 虚表方法调用
    WitnessMethod = 0x61,
    /// 打开存在类型
    OpenExistential = 0x62,
    /// 关闭存在类型
    CloseExistential = 0x63,
    /// 引用 (Quote)
    Quote = 0x70,
    /// 拼接 (Splice)
    Splice = 0x71,
    /// 求值 (Eval)
    Eval = 0x72,
    /// 宏展开
    ExpandMacro = 0x73,

    /// 新建通道
    NewChannel = 0x57,
    /// 发送通道消息
    SendChannel = 0x58,
    /// 接收通道消息
    RecvChannel = 0x59,
    /// 选择通道
    SelectChannel = 0x5A,
    /// 新建查询
    NewQuery = 0x5B,
    /// 执行查询
    QueryExec = 0x5C,
    /// 新建时钟
    NewClock = 0x5D,
    /// 时钟等待
    ClockWait = 0x5E,

    /// I32 扩展指令
    I32Ext = 0xC1,
    /// I64 扩展指令
    I64Ext = 0xC2,
    /// F32 扩展指令
    F32Ext = 0xC3,
    /// F64 扩展指令
    F64Ext = 0xC4,
    /// 大整数扩展指令
    BigIntExt = 0xC5,
    /// 字符串扩展指令
    StringExt = 0xC6,

    /// 停机
    Halt = 0xFF,
}

/// Codec trait for Nyar instructions
pub trait NyarCodec: Sized {
    /// Encode to binary stream
    fn encode(&self, writer: &mut BinaryWriter<Vec<u8>, Leb128>) -> Result<(), GaiaError>;
    /// Decode from binary stream
    fn decode(reader: &mut BinaryReader<Cursor<&[u8]>, Leb128>) -> Result<Self, GaiaError>;
}

impl NyarCodec for NyarInstruction {
    fn encode(&self, writer: &mut BinaryWriter<Vec<u8>, Leb128>) -> Result<(), GaiaError> {
        match self {
            Self::Nop => writer.write_u8(NyarOpcode::Nop as u8)?,
            Self::Push(v) => {
                writer.write_u8(NyarOpcode::Push as u8)?;
                writer.write_u16(*v)?;
            }
            Self::PushNone => writer.write_u8(NyarOpcode::PushNone as u8)?,
            Self::Pop => writer.write_u8(NyarOpcode::Pop as u8)?,
            Self::Dup(v) => {
                writer.write_u8(NyarOpcode::Dup as u8)?;
                writer.write_u8(*v)?;
            }
            Self::Swap(v) => {
                writer.write_u8(NyarOpcode::Swap as u8)?;
                writer.write_u8(*v)?;
            }
            Self::LoadLocal(v) => {
                writer.write_u8(NyarOpcode::LoadLocal as u8)?;
                writer.write_u8(*v)?;
            }
            Self::StoreLocal(v) => {
                writer.write_u8(NyarOpcode::StoreLocal as u8)?;
                writer.write_u8(*v)?;
            }
            Self::LoadGlobal(v) => {
                writer.write_u8(NyarOpcode::LoadGlobal as u8)?;
                writer.write_u16(*v)?;
            }
            Self::StoreGlobal(v) => {
                writer.write_u8(NyarOpcode::StoreGlobal as u8)?;
                writer.write_u16(*v)?;
            }
            Self::LoadUpvalue(v) => {
                writer.write_u8(NyarOpcode::LoadUpvalue as u8)?;
                writer.write_u8(*v)?;
            }
            Self::StoreUpvalue(v) => {
                writer.write_u8(NyarOpcode::StoreUpvalue as u8)?;
                writer.write_u8(*v)?;
            }
            Self::CloseUpvalues => writer.write_u8(NyarOpcode::CloseUpvalues as u8)?,
            Self::Jump(v) => {
                writer.write_u8(NyarOpcode::Jump as u8)?;
                writer.write_i16(*v)?;
            }
            Self::JumpIfFalse(v) => {
                writer.write_u8(NyarOpcode::JumpIfFalse as u8)?;
                writer.write_i16(*v)?;
            }
            Self::JumpIfTrue(v) => {
                writer.write_u8(NyarOpcode::JumpIfTrue as u8)?;
                writer.write_i16(*v)?;
            }
            Self::JumpIfNull(v) => {
                writer.write_u8(NyarOpcode::JumpIfNull as u8)?;
                writer.write_i16(*v)?;
            }
            Self::Return => writer.write_u8(NyarOpcode::Return as u8)?,
            Self::MakeClosure(idx, ups) => {
                writer.write_u8(NyarOpcode::MakeClosure as u8)?;
                writer.write_u16(*idx)?;
                writer.write_u8(ups.len() as u8)?;
                for up in ups {
                    writer.write_u8(if up.is_local { 1 } else { 0 })?;
                    writer.write_u8(up.index)?;
                }
            }
            Self::TailCall(idx, argc) => {
                writer.write_u8(NyarOpcode::TailCall as u8)?;
                writer.write_u16(*idx)?;
                writer.write_u8(*argc)?;
            }
            Self::TailCallClosure(argc) => {
                writer.write_u8(NyarOpcode::TailCallClosure as u8)?;
                writer.write_u8(*argc)?;
            }
            Self::Call(idx, argc) => {
                writer.write_u8(NyarOpcode::Call as u8)?;
                writer.write_u16(*idx)?;
                writer.write_u8(*argc)?;
            }
            Self::CallVirtual(idx, argc) => {
                writer.write_u8(NyarOpcode::CallVirtual as u8)?;
                writer.write_u16(*idx)?;
                writer.write_u8(*argc)?;
            }
            Self::CallDynamic(idx, argc) => {
                writer.write_u8(NyarOpcode::CallDynamic as u8)?;
                writer.write_u16(*idx)?;
                writer.write_u8(*argc)?;
            }
            Self::CallClosure(argc) => {
                writer.write_u8(NyarOpcode::CallClosure as u8)?;
                writer.write_u8(*argc)?;
            }
            Self::InvokeMethod(idx, argc) => {
                writer.write_u8(NyarOpcode::InvokeMethod as u8)?;
                writer.write_u16(*idx)?;
                writer.write_u8(*argc)?;
            }
            Self::CallSymbol(idx, argc) => {
                writer.write_u8(NyarOpcode::CallSymbol as u8)?;
                writer.write_u16(*idx)?;
                writer.write_u8(*argc)?;
            }
            Self::GetField(idx) => {
                writer.write_u8(NyarOpcode::GetField as u8)?;
                writer.write_u16(*idx)?;
            }
            Self::SetField(idx) => {
                writer.write_u8(NyarOpcode::SetField as u8)?;
                writer.write_u16(*idx)?;
            }
            Self::NewObject(idx) => {
                writer.write_u8(NyarOpcode::NewObject as u8)?;
                writer.write_u16(*idx)?;
            }
            Self::NewArray(len) => {
                writer.write_u8(NyarOpcode::NewArray as u8)?;
                writer.write_u16(*len)?;
            }
            Self::GetElement => writer.write_u8(NyarOpcode::GetElement as u8)?,
            Self::SetElement => writer.write_u8(NyarOpcode::SetElement as u8)?,
            Self::NewDynObject => writer.write_u8(NyarOpcode::NewDynObject as u8)?,
            Self::RemoveKey => writer.write_u8(NyarOpcode::RemoveKey as u8)?,
            Self::Initiate(v) => {
                writer.write_u8(NyarOpcode::Initiate as u8)?;
                writer.write_u8(*v)?;
            }
            Self::Finalize => writer.write_u8(NyarOpcode::Finalize as u8)?,
            Self::NewList(len) => {
                writer.write_u8(NyarOpcode::NewList as u8)?;
                writer.write_u16(*len)?;
            }
            Self::PushElementLeft => writer.write_u8(NyarOpcode::PushElementLeft as u8)?,
            Self::PopElementLeft => writer.write_u8(NyarOpcode::PopElementLeft as u8)?,
            Self::PushElementRight => writer.write_u8(NyarOpcode::PushElementRight as u8)?,
            Self::PopElementRight => writer.write_u8(NyarOpcode::PopElementRight as u8)?,
            Self::MakeTuple(v) => {
                writer.write_u8(NyarOpcode::MakeTuple as u8)?;
                writer.write_u8(*v)?;
            }
            Self::HasKey => writer.write_u8(NyarOpcode::HasKey as u8)?,
            Self::MatchVariant(v) => {
                writer.write_u8(NyarOpcode::MatchVariant as u8)?;
                writer.write_u16(*v)?;
            }
            Self::SizeOf => writer.write_u8(NyarOpcode::SizeOf as u8)?,
            Self::TypeOf => writer.write_u8(NyarOpcode::TypeOf as u8)?,
            Self::InstanceOf(idx) => {
                writer.write_u8(NyarOpcode::InstanceOf as u8)?;
                writer.write_u16(*idx)?;
            }
            Self::CheckCast(idx) => {
                writer.write_u8(NyarOpcode::CheckCast as u8)?;
                writer.write_u16(*idx)?;
            }
            Self::Cast(idx) => {
                writer.write_u8(NyarOpcode::Cast as u8)?;
                writer.write_u16(*idx)?;
            }
            Self::Perform(idx, argc) => {
                writer.write_u8(NyarOpcode::Perform as u8)?;
                writer.write_u16(*idx)?;
                writer.write_u8(*argc)?;
            }
            Self::WithHandler(idx) => {
                writer.write_u8(NyarOpcode::WithHandler as u8)?;
                writer.write_u16(*idx)?;
            }
            Self::ResumeWith => writer.write_u8(NyarOpcode::ResumeWith as u8)?,
            Self::CaptureCont => writer.write_u8(NyarOpcode::CaptureCont as u8)?,
            Self::Await => writer.write_u8(NyarOpcode::Await as u8)?,
            Self::BlockOn => writer.write_u8(NyarOpcode::BlockOn as u8)?,
            Self::MatchEffect(idx) => {
                writer.write_u8(NyarOpcode::MatchEffect as u8)?;
                writer.write_u16(*idx)?;
            }
            Self::GetWitnessTable(v1, v2) => {
                writer.write_u8(NyarOpcode::GetWitnessTable as u8)?;
                writer.write_u16(*v1)?;
                writer.write_u16(*v2)?;
            }
            Self::WitnessMethod(v) => {
                writer.write_u8(NyarOpcode::WitnessMethod as u8)?;
                writer.write_u16(*v)?;
            }
            Self::OpenExistential => writer.write_u8(NyarOpcode::OpenExistential as u8)?,
            Self::CloseExistential => writer.write_u8(NyarOpcode::CloseExistential as u8)?,
            Self::Quote(v) => {
                writer.write_u8(NyarOpcode::Quote as u8)?;
                writer.write_u32(*v)?;
            }
            Self::Splice => writer.write_u8(NyarOpcode::Splice as u8)?,
            Self::Eval(v) => {
                writer.write_u8(NyarOpcode::Eval as u8)?;
                writer.write_u8(*v)?;
            }
            Self::ExpandMacro(idx, argc) => {
                writer.write_u8(NyarOpcode::ExpandMacro as u8)?;
                writer.write_u16(*idx)?;
                writer.write_u8(*argc)?;
            }
            Self::FFICall(idx, argc) => {
                writer.write_u8(NyarOpcode::FFICall as u8)?;
                writer.write_u16(*idx)?;
                writer.write_u8(*argc)?;
            }
            Self::Halt => writer.write_u8(NyarOpcode::Halt as u8)?,

            // --- I32 Extensions ---
            Self::I32Const(v) => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x00)?;
                writer.write_i32(*v)?;
            }
            Self::I32Add => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x01)?;
            }
            Self::I32Sub => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x02)?;
            }
            Self::I32Mul => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x03)?;
            }
            Self::I32DivS => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x04)?;
            }
            Self::I32DivU => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x05)?;
            }
            Self::I32RemS => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x06)?;
            }
            Self::I32RemU => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x07)?;
            }
            Self::I32Neg => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x08)?;
            }
            Self::I32And => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x09)?;
            }
            Self::I32Or => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x0A)?;
            }
            Self::I32Xor => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x0B)?;
            }
            Self::I32Shl => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x0C)?;
            }
            Self::I32ShrS => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x0D)?;
            }
            Self::I32ShrU => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x0E)?;
            }
            Self::I32Not => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x0F)?;
            }
            Self::I32Eq => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x10)?;
            }
            Self::I32Ne => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x11)?;
            }
            Self::I32LtS => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x12)?;
            }
            Self::I32LtU => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x13)?;
            }
            Self::I32LeS => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x14)?;
            }
            Self::I32LeU => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x15)?;
            }
            Self::I32GtS => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x16)?;
            }
            Self::I32GtU => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x17)?;
            }
            Self::I32GeS => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x18)?;
            }
            Self::I32GeU => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x19)?;
            }
            Self::I32Extend64S => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x1A)?;
            }
            Self::I32Extend64U => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x1B)?;
            }
            Self::I32Trunc64SLow => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x1C)?;
            }
            Self::I32Trunc64S => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x1D)?;
            }
            Self::I32Trunc64U => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x1E)?;
            }
            Self::I32ToF32S => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x1F)?;
            }
            Self::I32ToF32U => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x20)?;
            }
            Self::I32ToF64S => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x21)?;
            }
            Self::I32ToF64U => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x22)?;
            }
            Self::I32AddSatS => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x23)?;
            }
            Self::I32AddSatU => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x24)?;
            }
            Self::I32SubSatS => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x25)?;
            }
            Self::I32SubSatU => {
                writer.write_u8(NyarOpcode::I32Ext as u8)?;
                writer.write_u8(0x26)?;
            }

            // --- I64 Extensions ---
            Self::I64Const(v) => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x00)?;
                writer.write_i64(*v)?;
            }
            Self::I64Add => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x01)?;
            }
            Self::I64Sub => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x02)?;
            }
            Self::I64Mul => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x03)?;
            }
            Self::I64DivS => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x04)?;
            }
            Self::I64DivU => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x05)?;
            }
            Self::I64RemS => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x06)?;
            }
            Self::I64RemU => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x07)?;
            }
            Self::I64Neg => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x08)?;
            }
            Self::I64And => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x09)?;
            }
            Self::I64Or => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x0A)?;
            }
            Self::I64Xor => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x0B)?;
            }
            Self::I64Shl => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x0C)?;
            }
            Self::I64ShrS => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x0D)?;
            }
            Self::I64ShrU => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x0E)?;
            }
            Self::I64Not => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x0F)?;
            }
            Self::I64Eq => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x10)?;
            }
            Self::I64Ne => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x11)?;
            }
            Self::I64LtS => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x12)?;
            }
            Self::I64LtU => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x13)?;
            }
            Self::I64LeS => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x14)?;
            }
            Self::I64LeU => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x15)?;
            }
            Self::I64GtS => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x16)?;
            }
            Self::I64GtU => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x17)?;
            }
            Self::I64GeS => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x18)?;
            }
            Self::I64GeU => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x19)?;
            }
            Self::I64ToF32S => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x1A)?;
            }
            Self::I64ToF32U => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x1B)?;
            }
            Self::I64ToF64S => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x1C)?;
            }
            Self::I64ToF64U => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x1D)?;
            }
            Self::I64AddSatS => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x1E)?;
            }
            Self::I64AddSatU => {
                writer.write_u8(NyarOpcode::I64Ext as u8)?;
                writer.write_u8(0x1F)?;
            }

            // --- F32 Extensions ---
            Self::F32Const(v) => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x00)?;
                writer.write_f32(*v)?;
            }
            Self::F32Add => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x01)?;
            }
            Self::F32Sub => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x02)?;
            }
            Self::F32Mul => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x03)?;
            }
            Self::F32Div => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x04)?;
            }
            Self::F32Neg => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x08)?;
            }
            Self::F32Eq => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x10)?;
            }
            Self::F32Ne => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x11)?;
            }
            Self::F32Lt => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x12)?;
            }
            Self::F32Le => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x14)?;
            }
            Self::F32Gt => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x16)?;
            }
            Self::F32Ge => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x18)?;
            }
            Self::F32ToI32S => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x1A)?;
            }
            Self::F32ToI32U => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x1B)?;
            }
            Self::F32ToI64S => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x1C)?;
            }
            Self::F32ToI64U => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x1D)?;
            }
            Self::F32ToF64 => {
                writer.write_u8(NyarOpcode::F32Ext as u8)?;
                writer.write_u8(0x1E)?;
            }

            // --- F64 Extensions ---
            Self::F64Const(v) => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x00)?;
                writer.write_f64(*v)?;
            }
            Self::F64Add => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x01)?;
            }
            Self::F64Sub => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x02)?;
            }
            Self::F64Mul => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x03)?;
            }
            Self::F64Div => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x04)?;
            }
            Self::F64Neg => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x08)?;
            }
            Self::F64Eq => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x10)?;
            }
            Self::F64Ne => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x11)?;
            }
            Self::F64Lt => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x12)?;
            }
            Self::F64Le => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x14)?;
            }
            Self::F64Gt => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x16)?;
            }
            Self::F64Ge => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x18)?;
            }
            Self::F64ToI32S => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x1A)?;
            }
            Self::F64ToI32U => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x1B)?;
            }
            Self::F64ToI64S => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x1C)?;
            }
            Self::F64ToI64U => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x1D)?;
            }
            Self::F64ToF32 => {
                writer.write_u8(NyarOpcode::F64Ext as u8)?;
                writer.write_u8(0x1E)?;
            }

            // --- BigInt Extensions ---
            Self::BigIntConst { sign, bytes } => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x00)?;
                writer.write_u8(*sign)?;
                writer.write_u32(bytes.len() as u32)?;
                writer.write_bytes(bytes)?;
            }
            Self::BigIntAdd => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x01)?;
            }
            Self::BigIntSub => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x02)?;
            }
            Self::BigIntMul => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x03)?;
            }
            Self::BigIntDiv => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x04)?;
            }
            Self::BigIntMod => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x05)?;
            }
            Self::BigIntNeg => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x08)?;
            }
            Self::BigIntEq => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x10)?;
            }
            Self::BigIntNe => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x11)?;
            }
            Self::BigIntLt => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x12)?;
            }
            Self::BigIntLe => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x14)?;
            }
            Self::BigIntGt => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x16)?;
            }
            Self::BigIntGe => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x18)?;
            }
            Self::BigIntToI64 => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x1A)?;
            }
            Self::BigIntFromI64 => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x1B)?;
            }
            Self::BigIntToString => {
                writer.write_u8(NyarOpcode::BigIntExt as u8)?;
                writer.write_u8(0x1C)?;
            }

            // --- String Extensions ---
            Self::StringConst(s) => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x00)?;
                let bytes = s.as_bytes();
                writer.write_u32(bytes.len() as u32)?;
                writer.write_bytes(bytes)?;
            }
            Self::StringConcat => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x01)?;
            }
            Self::StringLenBytes => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x02)?;
            }
            Self::StringLenChars => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x0A)?;
            }
            Self::StringEq => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x04)?;
            }
            Self::StringNe => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x05)?;
            }
            Self::StringLt => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x06)?;
            }
            Self::StringLe => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x07)?;
            }
            Self::StringGt => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x08)?;
            }
            Self::StringGe => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x09)?;
            }
            Self::StringSubstr => {
                writer.write_u8(NyarOpcode::StringExt as u8)?;
                writer.write_u8(0x03)?;
            }

            // --- Channel Extensions ---
            Self::NewChannel(v) => {
                writer.write_u8(0x57)?;
                writer.write_u16(*v)?;
            }
            Self::SendChannel => {
                writer.write_u8(0x58)?;
            }
            Self::RecvChannel => {
                writer.write_u8(0x59)?;
            }
            Self::SelectChannel(v) => {
                writer.write_u8(0x5A)?;
                writer.write_u8(*v)?;
            }

            // --- Query Extensions ---
            Self::NewQuery(v) => {
                writer.write_u8(0x5B)?;
                writer.write_u16(*v)?;
            }
            Self::QueryExec => {
                writer.write_u8(0x5C)?;
            }

            // --- Clock Extensions ---
            Self::NewClock => {
                writer.write_u8(0x5D)?;
            }
            Self::ClockWait => {
                writer.write_u8(0x5E)?;
            }
        }
        Ok(())
    }

    fn decode(reader: &mut BinaryReader<Cursor<&[u8]>, Leb128>) -> Result<Self, GaiaError> {
        let opcode_u8 = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
        let opcode = match opcode_u8 {
            0x00 => NyarOpcode::Nop,
            0x01 => NyarOpcode::Push,
            0x10 => NyarOpcode::PushNone,
            0x02 => NyarOpcode::Pop,
            0x03 => NyarOpcode::Dup,
            0x04 => NyarOpcode::Swap,
            0x05 => NyarOpcode::LoadLocal,
            0x06 => NyarOpcode::StoreLocal,
            0x07 => NyarOpcode::LoadGlobal,
            0x08 => NyarOpcode::StoreGlobal,
            0x09 => NyarOpcode::LoadUpvalue,
            0x0A => NyarOpcode::StoreUpvalue,
            0x0B => NyarOpcode::CloseUpvalues,
            0x0C => NyarOpcode::Jump,
            0x0D => NyarOpcode::JumpIfFalse,
            0x0E => NyarOpcode::JumpIfTrue,
            0x0F => NyarOpcode::JumpIfNull,
            0x13 => NyarOpcode::Return,
            0x15 => NyarOpcode::MakeClosure,
            0x20 => NyarOpcode::Call,
            0x21 => NyarOpcode::CallVirtual,
            0x22 => NyarOpcode::CallDynamic,
            0x23 => NyarOpcode::CallClosure,
            0x24 => NyarOpcode::InvokeMethod,
            0x25 => NyarOpcode::CallSymbol,
            0x30 => NyarOpcode::GetField,
            0x31 => NyarOpcode::SetField,
            0x32 => NyarOpcode::NewObject,
            0x33 => NyarOpcode::NewArray,
            0x34 => NyarOpcode::GetElement,
            0x35 => NyarOpcode::SetElement,
            0x36 => NyarOpcode::MakeTuple,
            0x37 => NyarOpcode::HasKey,
            0x38 => NyarOpcode::MatchVariant,
            0x39 => NyarOpcode::SizeOf,
            0x3A => NyarOpcode::NewDynObject,
            0x3B => NyarOpcode::RemoveKey,
            0x3C => NyarOpcode::NewList,
            0x3D => NyarOpcode::PushElementLeft,
            0x3E => NyarOpcode::PopElementLeft,
            0x3F => NyarOpcode::PushElementRight,
            0x40 => NyarOpcode::PopElementRight,
            0x41 => NyarOpcode::TypeOf,
            0x42 => NyarOpcode::InstanceOf,
            0x43 => NyarOpcode::CheckCast,
            0x44 => NyarOpcode::Cast,
            0x45 => NyarOpcode::Initiate,
            0x46 => NyarOpcode::Finalize,
            0x50 => NyarOpcode::Perform,
            0x51 => NyarOpcode::WithHandler,
            0x52 => NyarOpcode::ResumeWith,
            0x53 => NyarOpcode::CaptureCont,
            0x54 => NyarOpcode::Await,
            0x55 => NyarOpcode::BlockOn,
            0x56 => NyarOpcode::MatchEffect,
            0x60 => NyarOpcode::GetWitnessTable,
            0x61 => NyarOpcode::WitnessMethod,
            0x62 => NyarOpcode::OpenExistential,
            0x63 => NyarOpcode::CloseExistential,
            0x70 => NyarOpcode::Quote,
            0x71 => NyarOpcode::Splice,
            0x72 => NyarOpcode::Eval,
            0x73 => NyarOpcode::ExpandMacro,
            0xC1 => NyarOpcode::I32Ext,
            0xC2 => NyarOpcode::I64Ext,
            0xC3 => NyarOpcode::F32Ext,
            0xC4 => NyarOpcode::F64Ext,
            0xC5 => NyarOpcode::BigIntExt,
            0xC6 => NyarOpcode::StringExt,
            0xF0 => NyarOpcode::FFICall,
            0x14 => NyarOpcode::TailCall,
            0x16 => NyarOpcode::TailCallClosure,
            0xFF => NyarOpcode::Halt,
            0x57 => return Ok(Self::NewChannel(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            0x58 => return Ok(Self::SendChannel),
            0x59 => return Ok(Self::RecvChannel),
            0x5A => return Ok(Self::SelectChannel(reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            0x5B => return Ok(Self::NewQuery(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            0x5C => return Ok(Self::QueryExec),
            0x5D => return Ok(Self::NewClock),
            0x5E => return Ok(Self::ClockWait),
            _ => return Err(GaiaError::invalid_data(opcode_u8)),
        };

        match opcode {
            NyarOpcode::Nop => Ok(Self::Nop),
            NyarOpcode::Push => Ok(Self::Push(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            NyarOpcode::PushNone => Ok(Self::PushNone),
            NyarOpcode::Pop => Ok(Self::Pop),
            NyarOpcode::Dup => Ok(Self::Dup(reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            NyarOpcode::Swap => Ok(Self::Swap(reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            NyarOpcode::LoadLocal => {
                Ok(Self::LoadLocal(reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::StoreLocal => {
                Ok(Self::StoreLocal(reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::LoadGlobal => {
                Ok(Self::LoadGlobal(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::StoreGlobal => {
                Ok(Self::StoreGlobal(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::LoadUpvalue => {
                Ok(Self::LoadUpvalue(reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::StoreUpvalue => {
                Ok(Self::StoreUpvalue(reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::CloseUpvalues => Ok(Self::CloseUpvalues),
            NyarOpcode::Jump => Ok(Self::Jump(reader.read_i16().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            NyarOpcode::JumpIfFalse => {
                Ok(Self::JumpIfFalse(reader.read_i16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::JumpIfTrue => {
                Ok(Self::JumpIfTrue(reader.read_i16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::JumpIfNull => {
                Ok(Self::JumpIfNull(reader.read_i16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::Return => Ok(Self::Return),
            NyarOpcode::MakeClosure => {
                let idx = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let count = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))? as usize;
                let mut ups = Vec::with_capacity(count);
                for _ in 0..count {
                    let is_local = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))? != 0;
                    let index = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                    ups.push(NyarUpvalueRef { is_local, index });
                }
                Ok(Self::MakeClosure(idx, ups))
            }
            NyarOpcode::TailCall => {
                let idx = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::TailCall(idx, argc))
            }
            NyarOpcode::TailCallClosure => {
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::TailCallClosure(argc))
            }
            NyarOpcode::Call => {
                let idx = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::Call(idx, argc))
            }
            NyarOpcode::CallVirtual => {
                let idx = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::CallVirtual(idx, argc))
            }
            NyarOpcode::CallDynamic => {
                let idx = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::CallDynamic(idx, argc))
            }
            NyarOpcode::CallClosure => {
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::CallClosure(argc))
            }
            NyarOpcode::InvokeMethod => {
                let idx = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::InvokeMethod(idx, argc))
            }
            NyarOpcode::CallSymbol => {
                let idx = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::CallSymbol(idx, argc))
            }
            NyarOpcode::GetField => {
                Ok(Self::GetField(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::SetField => {
                Ok(Self::SetField(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::NewObject => {
                Ok(Self::NewObject(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::NewArray => {
                Ok(Self::NewArray(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::GetElement => Ok(Self::GetElement),
            NyarOpcode::SetElement => Ok(Self::SetElement),
            NyarOpcode::NewDynObject => Ok(Self::NewDynObject),
            NyarOpcode::RemoveKey => Ok(Self::RemoveKey),
            NyarOpcode::Initiate => {
                Ok(Self::Initiate(reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::Finalize => Ok(Self::Finalize),
            NyarOpcode::NewList => Ok(Self::NewList(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            NyarOpcode::PushElementLeft => Ok(Self::PushElementLeft),
            NyarOpcode::PopElementLeft => Ok(Self::PopElementLeft),
            NyarOpcode::PushElementRight => Ok(Self::PushElementRight),
            NyarOpcode::PopElementRight => Ok(Self::PopElementRight),
            NyarOpcode::MakeTuple => {
                Ok(Self::MakeTuple(reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::HasKey => Ok(Self::HasKey),
            NyarOpcode::MatchVariant => {
                Ok(Self::MatchVariant(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::SizeOf => Ok(Self::SizeOf),
            NyarOpcode::TypeOf => Ok(Self::TypeOf),
            NyarOpcode::InstanceOf => {
                Ok(Self::InstanceOf(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::CheckCast => {
                Ok(Self::CheckCast(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::Cast => Ok(Self::Cast(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            NyarOpcode::Perform => {
                let idx = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::Perform(idx, argc))
            }
            NyarOpcode::WithHandler => {
                Ok(Self::WithHandler(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::ResumeWith => Ok(Self::ResumeWith),
            NyarOpcode::CaptureCont => Ok(Self::CaptureCont),
            NyarOpcode::Await => Ok(Self::Await),
            NyarOpcode::BlockOn => Ok(Self::BlockOn),
            NyarOpcode::MatchEffect => {
                Ok(Self::MatchEffect(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::GetWitnessTable => {
                let v1 = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let v2 = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::GetWitnessTable(v1, v2))
            }
            NyarOpcode::WitnessMethod => {
                Ok(Self::WitnessMethod(reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?))
            }
            NyarOpcode::OpenExistential => Ok(Self::OpenExistential),
            NyarOpcode::CloseExistential => Ok(Self::CloseExistential),
            NyarOpcode::Quote => Ok(Self::Quote(reader.read_u32().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            NyarOpcode::Splice => Ok(Self::Splice),
            NyarOpcode::Eval => Ok(Self::Eval(reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
            NyarOpcode::ExpandMacro => {
                let idx = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::ExpandMacro(idx, argc))
            }
            NyarOpcode::FFICall => {
                let idx = reader.read_u16().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                let argc = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                Ok(Self::FFICall(idx, argc))
            }
            NyarOpcode::Halt => Ok(Self::Halt),
            NyarOpcode::I32Ext => {
                let ext = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                match ext {
                    0x00 => Ok(Self::I32Const(reader.read_i32().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
                    0x01 => Ok(Self::I32Add),
                    0x02 => Ok(Self::I32Sub),
                    0x03 => Ok(Self::I32Mul),
                    0x04 => Ok(Self::I32DivS),
                    0x05 => Ok(Self::I32DivU),
                    0x06 => Ok(Self::I32RemS),
                    0x07 => Ok(Self::I32RemU),
                    0x08 => Ok(Self::I32Neg),
                    0x09 => Ok(Self::I32And),
                    0x0A => Ok(Self::I32Or),
                    0x0B => Ok(Self::I32Xor),
                    0x0C => Ok(Self::I32Shl),
                    0x0D => Ok(Self::I32ShrS),
                    0x0E => Ok(Self::I32ShrU),
                    0x0F => Ok(Self::I32Not),
                    0x10 => Ok(Self::I32Eq),
                    0x11 => Ok(Self::I32Ne),
                    0x12 => Ok(Self::I32LtS),
                    0x13 => Ok(Self::I32LtU),
                    0x14 => Ok(Self::I32LeS),
                    0x15 => Ok(Self::I32LeU),
                    0x16 => Ok(Self::I32GtS),
                    0x17 => Ok(Self::I32GtU),
                    0x18 => Ok(Self::I32GeS),
                    0x19 => Ok(Self::I32GeU),
                    0x1F => Ok(Self::I32ToF32S),
                    0x20 => Ok(Self::I32ToF32U),
                    0x21 => Ok(Self::I32ToF64S),
                    0x22 => Ok(Self::I32ToF64U),
                    0x23 => Ok(Self::I32AddSatS),
                    0x24 => Ok(Self::I32AddSatU),
                    0x25 => Ok(Self::I32SubSatS),
                    0x26 => Ok(Self::I32SubSatU),
                    0x1A => Ok(Self::I32Extend64S),
                    0x1B => Ok(Self::I32Extend64U),
                    0x1C => Ok(Self::I32Trunc64SLow),
                    0x1D => Ok(Self::I32Trunc64S),
                    0x1E => Ok(Self::I32Trunc64U),
                    _ => Err(GaiaError::invalid_data(ext)),
                }
            }
            NyarOpcode::I64Ext => {
                let ext = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                match ext {
                    0x00 => Ok(Self::I64Const(reader.read_i64().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
                    0x01 => Ok(Self::I64Add),
                    0x02 => Ok(Self::I64Sub),
                    0x03 => Ok(Self::I64Mul),
                    0x04 => Ok(Self::I64DivS),
                    0x05 => Ok(Self::I64DivU),
                    0x06 => Ok(Self::I64RemS),
                    0x07 => Ok(Self::I64RemU),
                    0x08 => Ok(Self::I64Neg),
                    0x09 => Ok(Self::I64And),
                    0x0A => Ok(Self::I64Or),
                    0x0B => Ok(Self::I64Xor),
                    0x0C => Ok(Self::I64Shl),
                    0x0D => Ok(Self::I64ShrS),
                    0x0E => Ok(Self::I64ShrU),
                    0x0F => Ok(Self::I64Not),
                    0x10 => Ok(Self::I64Eq),
                    0x11 => Ok(Self::I64Ne),
                    0x12 => Ok(Self::I64LtS),
                    0x13 => Ok(Self::I64LtU),
                    0x14 => Ok(Self::I64LeS),
                    0x15 => Ok(Self::I64LeU),
                    0x16 => Ok(Self::I64GtS),
                    0x17 => Ok(Self::I64GtU),
                    0x18 => Ok(Self::I64GeS),
                    0x19 => Ok(Self::I64GeU),
                    0x1A => Ok(Self::I64ToF32S),
                    0x1B => Ok(Self::I64ToF32U),
                    0x1C => Ok(Self::I64ToF64S),
                    0x1D => Ok(Self::I64ToF64U),
                    0x1E => Ok(Self::I64AddSatS),
                    0x1F => Ok(Self::I64AddSatU),
                    _ => Err(GaiaError::invalid_data(ext)),
                }
            }
            NyarOpcode::F32Ext => {
                let ext = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                match ext {
                    0x00 => Ok(Self::F32Const(reader.read_f32().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
                    0x01 => Ok(Self::F32Add),
                    0x02 => Ok(Self::F32Sub),
                    0x03 => Ok(Self::F32Mul),
                    0x04 => Ok(Self::F32Div),
                    0x08 => Ok(Self::F32Neg),
                    0x10 => Ok(Self::F32Eq),
                    0x11 => Ok(Self::F32Ne),
                    0x12 => Ok(Self::F32Lt),
                    0x14 => Ok(Self::F32Le),
                    0x16 => Ok(Self::F32Gt),
                    0x18 => Ok(Self::F32Ge),
                    0x1A => Ok(Self::F32ToI32S),
                    0x1B => Ok(Self::F32ToI32U),
                    0x1C => Ok(Self::F32ToI64S),
                    0x1D => Ok(Self::F32ToI64U),
                    0x1E => Ok(Self::F32ToF64),
                    _ => Err(GaiaError::invalid_data(ext)),
                }
            }
            NyarOpcode::F64Ext => {
                let ext = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                match ext {
                    0x00 => Ok(Self::F64Const(reader.read_f64().map_err(|_| GaiaError::invalid_data("Data truncated"))?)),
                    0x01 => Ok(Self::F64Add),
                    0x02 => Ok(Self::F64Sub),
                    0x03 => Ok(Self::F64Mul),
                    0x04 => Ok(Self::F64Div),
                    0x08 => Ok(Self::F64Neg),
                    0x10 => Ok(Self::F64Eq),
                    0x11 => Ok(Self::F64Ne),
                    0x12 => Ok(Self::F64Lt),
                    0x14 => Ok(Self::F64Le),
                    0x16 => Ok(Self::F64Gt),
                    0x18 => Ok(Self::F64Ge),
                    0x1A => Ok(Self::F64ToI32S),
                    0x1B => Ok(Self::F64ToI32U),
                    0x1C => Ok(Self::F64ToI64S),
                    0x1D => Ok(Self::F64ToI64U),
                    0x1E => Ok(Self::F64ToF32),
                    _ => Err(GaiaError::invalid_data(ext)),
                }
            }
            NyarOpcode::BigIntExt => {
                let ext = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                match ext {
                    0x00 => {
                        let sign = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                        let len = reader.read_u32().map_err(|_| GaiaError::invalid_data("Data truncated"))? as usize;
                        let mut bytes = vec![0u8; len];
                        for i in 0..len {
                            bytes[i] = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                        }
                        Ok(Self::BigIntConst { sign, bytes })
                    }
                    0x01 => Ok(Self::BigIntAdd),
                    0x02 => Ok(Self::BigIntSub),
                    0x03 => Ok(Self::BigIntMul),
                    0x04 => Ok(Self::BigIntDiv),
                    0x05 => Ok(Self::BigIntMod),
                    0x08 => Ok(Self::BigIntNeg),
                    0x10 => Ok(Self::BigIntEq),
                    0x11 => Ok(Self::BigIntNe),
                    0x12 => Ok(Self::BigIntLt),
                    0x14 => Ok(Self::BigIntLe),
                    0x16 => Ok(Self::BigIntGt),
                    0x18 => Ok(Self::BigIntGe),
                    0x1A => Ok(Self::BigIntToI64),
                    0x1B => Ok(Self::BigIntFromI64),
                    0x1C => Ok(Self::BigIntToString),
                    _ => Err(GaiaError::invalid_data(ext)),
                }
            }
            NyarOpcode::StringExt => {
                let ext = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                match ext {
                    0x00 => {
                        let len = reader.read_u32().map_err(|_| GaiaError::invalid_data("Data truncated"))? as usize;
                        let mut bytes = vec![0u8; len];
                        for i in 0..len {
                            bytes[i] = reader.read_u8().map_err(|_| GaiaError::invalid_data("Data truncated"))?;
                        }
                        let s = String::from_utf8(bytes).map_err(|_| GaiaError::invalid_data("Text parse error"))?;
                        Ok(Self::StringConst(s))
                    }
                    0x01 => Ok(Self::StringConcat),
                    0x02 => Ok(Self::StringLenBytes),
                    0x03 => Ok(Self::StringSubstr),
                    0x04 => Ok(Self::StringEq),
                    0x05 => Ok(Self::StringNe),
                    0x06 => Ok(Self::StringLt),
                    0x07 => Ok(Self::StringLe),
                    0x08 => Ok(Self::StringGt),
                    0x09 => Ok(Self::StringGe),
                    0x0A => Ok(Self::StringLenChars),
                    _ => Err(GaiaError::invalid_data(ext)),
                }
            }
            _ => Err(GaiaError::invalid_data(opcode_u8)),
        }
    }
}