mediapipe-nightly 0.10.10.post20240225__cp38-cp38-macosx_11_0_universal2.whl → 0.10.11.post20240302__cp38-cp38-macosx_11_0_universal2.whl

mediapipe/tasks/metadata/schema_py_generated.py

@@ -228,6 +228,50 @@ class BuiltinOperator(object):
     BITCAST = 159
     BITWISE_XOR = 160
     RIGHT_SHIFT = 161
+    STABLEHLO_LOGISTIC = 162
+    STABLEHLO_ADD = 163
+    STABLEHLO_DIVIDE = 164
+    STABLEHLO_MULTIPLY = 165
+    STABLEHLO_MAXIMUM = 166
+    STABLEHLO_RESHAPE = 167
+    STABLEHLO_CLAMP = 168
+    STABLEHLO_CONCATENATE = 169
+    STABLEHLO_BROADCAST_IN_DIM = 170
+    STABLEHLO_CONVOLUTION = 171
+    STABLEHLO_SLICE = 172
+    STABLEHLO_CUSTOM_CALL = 173
+    STABLEHLO_REDUCE = 174
+    STABLEHLO_ABS = 175
+    STABLEHLO_AND = 176
+    STABLEHLO_COSINE = 177
+    STABLEHLO_EXPONENTIAL = 178
+    STABLEHLO_FLOOR = 179
+    STABLEHLO_LOG = 180
+    STABLEHLO_MINIMUM = 181
+    STABLEHLO_NEGATE = 182
+    STABLEHLO_OR = 183
+    STABLEHLO_POWER = 184
+    STABLEHLO_REMAINDER = 185
+    STABLEHLO_RSQRT = 186
+    STABLEHLO_SELECT = 187
+    STABLEHLO_SUBTRACT = 188
+    STABLEHLO_TANH = 189
+    STABLEHLO_SCATTER = 190
+    STABLEHLO_COMPARE = 191
+    STABLEHLO_CONVERT = 192
+    STABLEHLO_DYNAMIC_SLICE = 193
+    STABLEHLO_DYNAMIC_UPDATE_SLICE = 194
+    STABLEHLO_PAD = 195
+    STABLEHLO_IOTA = 196
+    STABLEHLO_DOT_GENERAL = 197
+    STABLEHLO_REDUCE_WINDOW = 198
+    STABLEHLO_SORT = 199
+    STABLEHLO_WHILE = 200
+    STABLEHLO_GATHER = 201
+    STABLEHLO_TRANSPOSE = 202
+    DILATE = 203
+    STABLEHLO_RNG_BIT_GENERATOR = 204
+    REDUCE_WINDOW = 205
 
 
 class BuiltinOptions(object):
@@ -618,6 +662,105 @@ def BuiltinOptionsCreator(unionType, table):
     return None
 
 
+class BuiltinOptions2(object):
+    NONE = 0
+    StablehloConcatenateOptions = 1
+    StablehloBroadcastInDimOptions = 2
+    StablehloSliceOptions = 3
+    StablehloConvolutionOptions = 4
+    StablehloCustomCallOptions = 5
+    StablehloReduceOptions = 6
+    StablehloScatterOptions = 7
+    StablehloCompareOptions = 8
+    StablehloDynamicSliceOptions = 9
+    StablehloPadOptions = 10
+    StablehloIotaOptions = 11
+    StablehloDotGeneralOptions = 12
+    StablehloReduceWindowOptions = 13
+    StablehloSortOptions = 14
+    StablehloWhileOptions = 15
+    StablehloGatherOptions = 16
+    StablehloTransposeOptions = 17
+    DilateOptions = 18
+    StablehloRngBitGeneratorOptions = 19
+    ReduceWindowOptions = 20
+
+def BuiltinOptions2Creator(unionType, table):
+    from flatbuffers.table import Table
+    if not isinstance(table, Table):
+        return None
+    if unionType == BuiltinOptions2().StablehloConcatenateOptions:
+        return StablehloConcatenateOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloBroadcastInDimOptions:
+        return StablehloBroadcastInDimOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloSliceOptions:
+        return StablehloSliceOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloConvolutionOptions:
+        return StablehloConvolutionOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloCustomCallOptions:
+        return StablehloCustomCallOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloReduceOptions:
+        return StablehloReduceOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloScatterOptions:
+        return StablehloScatterOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloCompareOptions:
+        return StablehloCompareOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloDynamicSliceOptions:
+        return StablehloDynamicSliceOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloPadOptions:
+        return StablehloPadOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloIotaOptions:
+        return StablehloIotaOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloDotGeneralOptions:
+        return StablehloDotGeneralOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloReduceWindowOptions:
+        return StablehloReduceWindowOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloSortOptions:
+        return StablehloSortOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloWhileOptions:
+        return StablehloWhileOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloGatherOptions:
+        return StablehloGatherOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloTransposeOptions:
+        return StablehloTransposeOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().DilateOptions:
+        return DilateOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().StablehloRngBitGeneratorOptions:
+        return StablehloRngBitGeneratorOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == BuiltinOptions2().ReduceWindowOptions:
+        return ReduceWindowOptionsT.InitFromBuf(table.Bytes, table.Pos)
+    return None
+
+
+class StablehloPrecisionConfig(object):
+    DEFAULT = 0
+    HIGH = 1
+    HIGHEST = 2
+
+
+class StablehloComparisonDirection(object):
+    STABLEHLO_COMPARISON_DIRECTION_EQ = 0
+    STABLEHLO_COMPARISON_DIRECTION_NE = 1
+    STABLEHLO_COMPARISON_DIRECTION_GE = 2
+    STABLEHLO_COMPARISON_DIRECTION_GT = 3
+    STABLEHLO_COMPARISON_DIRECTION_LE = 4
+    STABLEHLO_COMPARISON_DIRECTION_LT = 5
+
+
+class StablehloComparisonType(object):
+    STABLEHLO_COMPARISON_TYPE_NOTYPE = 0
+    STABLEHLO_COMPARISON_TYPE_FLOAT = 1
+    STABLEHLO_COMPARISON_TYPE_FLOAT_TOTAL_ORDER = 2
+    STABLEHLO_COMPARISON_TYPE_SIGNED = 3
+    STABLEHLO_COMPARISON_TYPE_UNSIGNED = 4
+
+
+class RngAlgorithm(object):
+    DEFAULT = 0
+    PHILOX = 1
+    THREEFRY = 2
+
+
 class Padding(object):
     SAME = 0
     VALID = 1
@@ -659,6 +802,16 @@ class MirrorPadMode(object):
     SYMMETRIC = 1
 
 
+class ReduceWindowFunction(object):
+    UNSUPPORTED = 0
+    ADD = 1
+    MUL = 2
+    MINIMUM = 3
+    MAXIMUM = 4
+    ALL = 5
+    ANY = 6
+
+
 class CustomOptionsFormat(object):
     FLEXBUFFERS = 0
 
@@ -2163,47 +2316,3656 @@ def TensorAddSparsity(builder, sparsity):
 def TensorAddShapeSignature(builder, shapeSignature):
     builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(shapeSignature), 0)
 
-def TensorStartShapeSignatureVector(builder, numElems):
-    return builder.StartVector(4, numElems, 4)
+def TensorStartShapeSignatureVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def TensorAddHasRank(builder, hasRank):
+    builder.PrependBoolSlot(8, hasRank, 0)
+
+def TensorAddVariantTensors(builder, variantTensors):
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(variantTensors), 0)
+
+def TensorStartVariantTensorsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def TensorEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List, Optional
+except:
+    pass
+
+class TensorT(object):
+
+    # TensorT
+    def __init__(self):
+        self.shape = None  # type: List[int]
+        self.type = 0  # type: int
+        self.buffer = 0  # type: int
+        self.name = None  # type: str
+        self.quantization = None  # type: Optional[QuantizationParametersT]
+        self.isVariable = False  # type: bool
+        self.sparsity = None  # type: Optional[SparsityParametersT]
+        self.shapeSignature = None  # type: List[int]
+        self.hasRank = False  # type: bool
+        self.variantTensors = None  # type: List[VariantSubTypeT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        tensor = Tensor()
+        tensor.Init(buf, pos)
+        return cls.InitFromObj(tensor)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, tensor):
+        x = TensorT()
+        x._UnPack(tensor)
+        return x
+
+    # TensorT
+    def _UnPack(self, tensor):
+        if tensor is None:
+            return
+        if not tensor.ShapeIsNone():
+            if np is None:
+                self.shape = []
+                for i in range(tensor.ShapeLength()):
+                    self.shape.append(tensor.Shape(i))
+            else:
+                self.shape = tensor.ShapeAsNumpy()
+        self.type = tensor.Type()
+        self.buffer = tensor.Buffer()
+        self.name = tensor.Name()
+        if tensor.Quantization() is not None:
+            self.quantization = QuantizationParametersT.InitFromObj(tensor.Quantization())
+        self.isVariable = tensor.IsVariable()
+        if tensor.Sparsity() is not None:
+            self.sparsity = SparsityParametersT.InitFromObj(tensor.Sparsity())
+        if not tensor.ShapeSignatureIsNone():
+            if np is None:
+                self.shapeSignature = []
+                for i in range(tensor.ShapeSignatureLength()):
+                    self.shapeSignature.append(tensor.ShapeSignature(i))
+            else:
+                self.shapeSignature = tensor.ShapeSignatureAsNumpy()
+        self.hasRank = tensor.HasRank()
+        if not tensor.VariantTensorsIsNone():
+            self.variantTensors = []
+            for i in range(tensor.VariantTensorsLength()):
+                if tensor.VariantTensors(i) is None:
+                    self.variantTensors.append(None)
+                else:
+                    variantSubType_ = VariantSubTypeT.InitFromObj(tensor.VariantTensors(i))
+                    self.variantTensors.append(variantSubType_)
+
+    # TensorT
+    def Pack(self, builder):
+        if self.shape is not None:
+            if np is not None and type(self.shape) is np.ndarray:
+                shape = builder.CreateNumpyVector(self.shape)
+            else:
+                TensorStartShapeVector(builder, len(self.shape))
+                for i in reversed(range(len(self.shape))):
+                    builder.PrependInt32(self.shape[i])
+                shape = builder.EndVector()
+        if self.name is not None:
+            name = builder.CreateString(self.name)
+        if self.quantization is not None:
+            quantization = self.quantization.Pack(builder)
+        if self.sparsity is not None:
+            sparsity = self.sparsity.Pack(builder)
+        if self.shapeSignature is not None:
+            if np is not None and type(self.shapeSignature) is np.ndarray:
+                shapeSignature = builder.CreateNumpyVector(self.shapeSignature)
+            else:
+                TensorStartShapeSignatureVector(builder, len(self.shapeSignature))
+                for i in reversed(range(len(self.shapeSignature))):
+                    builder.PrependInt32(self.shapeSignature[i])
+                shapeSignature = builder.EndVector()
+        if self.variantTensors is not None:
+            variantTensorslist = []
+            for i in range(len(self.variantTensors)):
+                variantTensorslist.append(self.variantTensors[i].Pack(builder))
+            TensorStartVariantTensorsVector(builder, len(self.variantTensors))
+            for i in reversed(range(len(self.variantTensors))):
+                builder.PrependUOffsetTRelative(variantTensorslist[i])
+            variantTensors = builder.EndVector()
+        TensorStart(builder)
+        if self.shape is not None:
+            TensorAddShape(builder, shape)
+        TensorAddType(builder, self.type)
+        TensorAddBuffer(builder, self.buffer)
+        if self.name is not None:
+            TensorAddName(builder, name)
+        if self.quantization is not None:
+            TensorAddQuantization(builder, quantization)
+        TensorAddIsVariable(builder, self.isVariable)
+        if self.sparsity is not None:
+            TensorAddSparsity(builder, sparsity)
+        if self.shapeSignature is not None:
+            TensorAddShapeSignature(builder, shapeSignature)
+        TensorAddHasRank(builder, self.hasRank)
+        if self.variantTensors is not None:
+            TensorAddVariantTensors(builder, variantTensors)
+        tensor = TensorEnd(builder)
+        return tensor
+
+
+class StablehloGatherOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloGatherOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloGatherOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloGatherOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloGatherOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloGatherOptions
+    def OffsetDims(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloGatherOptions
+    def OffsetDimsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloGatherOptions
+    def OffsetDimsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloGatherOptions
+    def OffsetDimsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # StablehloGatherOptions
+    def CollapsedSliceDims(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloGatherOptions
+    def CollapsedSliceDimsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloGatherOptions
+    def CollapsedSliceDimsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloGatherOptions
+    def CollapsedSliceDimsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # StablehloGatherOptions
+    def StartIndexMap(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloGatherOptions
+    def StartIndexMapAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloGatherOptions
+    def StartIndexMapLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloGatherOptions
+    def StartIndexMapIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # StablehloGatherOptions
+    def IndexVectorDim(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloGatherOptions
+    def SliceSizes(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloGatherOptions
+    def SliceSizesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloGatherOptions
+    def SliceSizesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloGatherOptions
+    def SliceSizesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # StablehloGatherOptions
+    def IndicesAreSorted(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def StablehloGatherOptionsStart(builder):
+    builder.StartObject(6)
+
+def StablehloGatherOptionsAddOffsetDims(builder, offsetDims):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(offsetDims), 0)
+
+def StablehloGatherOptionsStartOffsetDimsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloGatherOptionsAddCollapsedSliceDims(builder, collapsedSliceDims):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(collapsedSliceDims), 0)
+
+def StablehloGatherOptionsStartCollapsedSliceDimsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloGatherOptionsAddStartIndexMap(builder, startIndexMap):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(startIndexMap), 0)
+
+def StablehloGatherOptionsStartStartIndexMapVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloGatherOptionsAddIndexVectorDim(builder, indexVectorDim):
+    builder.PrependInt64Slot(3, indexVectorDim, 0)
+
+def StablehloGatherOptionsAddSliceSizes(builder, sliceSizes):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(sliceSizes), 0)
+
+def StablehloGatherOptionsStartSliceSizesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloGatherOptionsAddIndicesAreSorted(builder, indicesAreSorted):
+    builder.PrependBoolSlot(5, indicesAreSorted, 0)
+
+def StablehloGatherOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloGatherOptionsT(object):
+
+    # StablehloGatherOptionsT
+    def __init__(self):
+        self.offsetDims = None  # type: List[int]
+        self.collapsedSliceDims = None  # type: List[int]
+        self.startIndexMap = None  # type: List[int]
+        self.indexVectorDim = 0  # type: int
+        self.sliceSizes = None  # type: List[int]
+        self.indicesAreSorted = False  # type: bool
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloGatherOptions = StablehloGatherOptions()
+        stablehloGatherOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloGatherOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloGatherOptions):
+        x = StablehloGatherOptionsT()
+        x._UnPack(stablehloGatherOptions)
+        return x
+
+    # StablehloGatherOptionsT
+    def _UnPack(self, stablehloGatherOptions):
+        if stablehloGatherOptions is None:
+            return
+        if not stablehloGatherOptions.OffsetDimsIsNone():
+            if np is None:
+                self.offsetDims = []
+                for i in range(stablehloGatherOptions.OffsetDimsLength()):
+                    self.offsetDims.append(stablehloGatherOptions.OffsetDims(i))
+            else:
+                self.offsetDims = stablehloGatherOptions.OffsetDimsAsNumpy()
+        if not stablehloGatherOptions.CollapsedSliceDimsIsNone():
+            if np is None:
+                self.collapsedSliceDims = []
+                for i in range(stablehloGatherOptions.CollapsedSliceDimsLength()):
+                    self.collapsedSliceDims.append(stablehloGatherOptions.CollapsedSliceDims(i))
+            else:
+                self.collapsedSliceDims = stablehloGatherOptions.CollapsedSliceDimsAsNumpy()
+        if not stablehloGatherOptions.StartIndexMapIsNone():
+            if np is None:
+                self.startIndexMap = []
+                for i in range(stablehloGatherOptions.StartIndexMapLength()):
+                    self.startIndexMap.append(stablehloGatherOptions.StartIndexMap(i))
+            else:
+                self.startIndexMap = stablehloGatherOptions.StartIndexMapAsNumpy()
+        self.indexVectorDim = stablehloGatherOptions.IndexVectorDim()
+        if not stablehloGatherOptions.SliceSizesIsNone():
+            if np is None:
+                self.sliceSizes = []
+                for i in range(stablehloGatherOptions.SliceSizesLength()):
+                    self.sliceSizes.append(stablehloGatherOptions.SliceSizes(i))
+            else:
+                self.sliceSizes = stablehloGatherOptions.SliceSizesAsNumpy()
+        self.indicesAreSorted = stablehloGatherOptions.IndicesAreSorted()
+
+    # StablehloGatherOptionsT
+    def Pack(self, builder):
+        if self.offsetDims is not None:
+            if np is not None and type(self.offsetDims) is np.ndarray:
+                offsetDims = builder.CreateNumpyVector(self.offsetDims)
+            else:
+                StablehloGatherOptionsStartOffsetDimsVector(builder, len(self.offsetDims))
+                for i in reversed(range(len(self.offsetDims))):
+                    builder.PrependInt64(self.offsetDims[i])
+                offsetDims = builder.EndVector()
+        if self.collapsedSliceDims is not None:
+            if np is not None and type(self.collapsedSliceDims) is np.ndarray:
+                collapsedSliceDims = builder.CreateNumpyVector(self.collapsedSliceDims)
+            else:
+                StablehloGatherOptionsStartCollapsedSliceDimsVector(builder, len(self.collapsedSliceDims))
+                for i in reversed(range(len(self.collapsedSliceDims))):
+                    builder.PrependInt64(self.collapsedSliceDims[i])
+                collapsedSliceDims = builder.EndVector()
+        if self.startIndexMap is not None:
+            if np is not None and type(self.startIndexMap) is np.ndarray:
+                startIndexMap = builder.CreateNumpyVector(self.startIndexMap)
+            else:
+                StablehloGatherOptionsStartStartIndexMapVector(builder, len(self.startIndexMap))
+                for i in reversed(range(len(self.startIndexMap))):
+                    builder.PrependInt64(self.startIndexMap[i])
+                startIndexMap = builder.EndVector()
+        if self.sliceSizes is not None:
+            if np is not None and type(self.sliceSizes) is np.ndarray:
+                sliceSizes = builder.CreateNumpyVector(self.sliceSizes)
+            else:
+                StablehloGatherOptionsStartSliceSizesVector(builder, len(self.sliceSizes))
+                for i in reversed(range(len(self.sliceSizes))):
+                    builder.PrependInt64(self.sliceSizes[i])
+                sliceSizes = builder.EndVector()
+        StablehloGatherOptionsStart(builder)
+        if self.offsetDims is not None:
+            StablehloGatherOptionsAddOffsetDims(builder, offsetDims)
+        if self.collapsedSliceDims is not None:
+            StablehloGatherOptionsAddCollapsedSliceDims(builder, collapsedSliceDims)
+        if self.startIndexMap is not None:
+            StablehloGatherOptionsAddStartIndexMap(builder, startIndexMap)
+        StablehloGatherOptionsAddIndexVectorDim(builder, self.indexVectorDim)
+        if self.sliceSizes is not None:
+            StablehloGatherOptionsAddSliceSizes(builder, sliceSizes)
+        StablehloGatherOptionsAddIndicesAreSorted(builder, self.indicesAreSorted)
+        stablehloGatherOptions = StablehloGatherOptionsEnd(builder)
+        return stablehloGatherOptions
+
+
+class StablehloTransposeOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloTransposeOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloTransposeOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloTransposeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloTransposeOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloTransposeOptions
+    def Permutation(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloTransposeOptions
+    def PermutationAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloTransposeOptions
+    def PermutationLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloTransposeOptions
+    def PermutationIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+def StablehloTransposeOptionsStart(builder):
+    builder.StartObject(1)
+
+def StablehloTransposeOptionsAddPermutation(builder, permutation):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(permutation), 0)
+
+def StablehloTransposeOptionsStartPermutationVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloTransposeOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloTransposeOptionsT(object):
+
+    # StablehloTransposeOptionsT
+    def __init__(self):
+        self.permutation = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloTransposeOptions = StablehloTransposeOptions()
+        stablehloTransposeOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloTransposeOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloTransposeOptions):
+        x = StablehloTransposeOptionsT()
+        x._UnPack(stablehloTransposeOptions)
+        return x
+
+    # StablehloTransposeOptionsT
+    def _UnPack(self, stablehloTransposeOptions):
+        if stablehloTransposeOptions is None:
+            return
+        if not stablehloTransposeOptions.PermutationIsNone():
+            if np is None:
+                self.permutation = []
+                for i in range(stablehloTransposeOptions.PermutationLength()):
+                    self.permutation.append(stablehloTransposeOptions.Permutation(i))
+            else:
+                self.permutation = stablehloTransposeOptions.PermutationAsNumpy()
+
+    # StablehloTransposeOptionsT
+    def Pack(self, builder):
+        if self.permutation is not None:
+            if np is not None and type(self.permutation) is np.ndarray:
+                permutation = builder.CreateNumpyVector(self.permutation)
+            else:
+                StablehloTransposeOptionsStartPermutationVector(builder, len(self.permutation))
+                for i in reversed(range(len(self.permutation))):
+                    builder.PrependInt64(self.permutation[i])
+                permutation = builder.EndVector()
+        StablehloTransposeOptionsStart(builder)
+        if self.permutation is not None:
+            StablehloTransposeOptionsAddPermutation(builder, permutation)
+        stablehloTransposeOptions = StablehloTransposeOptionsEnd(builder)
+        return stablehloTransposeOptions
+
+
+class StablehloDotGeneralOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloDotGeneralOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloDotGeneralOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloDotGeneralOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloDotGeneralOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloDotGeneralOptions
+    def LhsBatchingDimensions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloDotGeneralOptions
+    def LhsBatchingDimensionsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloDotGeneralOptions
+    def LhsBatchingDimensionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloDotGeneralOptions
+    def LhsBatchingDimensionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # StablehloDotGeneralOptions
+    def RhsBatchingDimensions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloDotGeneralOptions
+    def RhsBatchingDimensionsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloDotGeneralOptions
+    def RhsBatchingDimensionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloDotGeneralOptions
+    def RhsBatchingDimensionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # StablehloDotGeneralOptions
+    def LhsContractingDimensions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloDotGeneralOptions
+    def LhsContractingDimensionsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloDotGeneralOptions
+    def LhsContractingDimensionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloDotGeneralOptions
+    def LhsContractingDimensionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # StablehloDotGeneralOptions
+    def RhsContractingDimensions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloDotGeneralOptions
+    def RhsContractingDimensionsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloDotGeneralOptions
+    def RhsContractingDimensionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloDotGeneralOptions
+    def RhsContractingDimensionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # StablehloDotGeneralOptions
+    def PrecisionConfig(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # StablehloDotGeneralOptions
+    def PrecisionConfigAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint32Flags, o)
+        return 0
+
+    # StablehloDotGeneralOptions
+    def PrecisionConfigLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloDotGeneralOptions
+    def PrecisionConfigIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+def StablehloDotGeneralOptionsStart(builder):
+    builder.StartObject(5)
+
+def StablehloDotGeneralOptionsAddLhsBatchingDimensions(builder, lhsBatchingDimensions):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(lhsBatchingDimensions), 0)
+
+def StablehloDotGeneralOptionsStartLhsBatchingDimensionsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloDotGeneralOptionsAddRhsBatchingDimensions(builder, rhsBatchingDimensions):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(rhsBatchingDimensions), 0)
+
+def StablehloDotGeneralOptionsStartRhsBatchingDimensionsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloDotGeneralOptionsAddLhsContractingDimensions(builder, lhsContractingDimensions):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(lhsContractingDimensions), 0)
+
+def StablehloDotGeneralOptionsStartLhsContractingDimensionsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloDotGeneralOptionsAddRhsContractingDimensions(builder, rhsContractingDimensions):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(rhsContractingDimensions), 0)
+
+def StablehloDotGeneralOptionsStartRhsContractingDimensionsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloDotGeneralOptionsAddPrecisionConfig(builder, precisionConfig):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(precisionConfig), 0)
+
+def StablehloDotGeneralOptionsStartPrecisionConfigVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StablehloDotGeneralOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloDotGeneralOptionsT(object):
+
+    # StablehloDotGeneralOptionsT
+    def __init__(self):
+        self.lhsBatchingDimensions = None  # type: List[int]
+        self.rhsBatchingDimensions = None  # type: List[int]
+        self.lhsContractingDimensions = None  # type: List[int]
+        self.rhsContractingDimensions = None  # type: List[int]
+        self.precisionConfig = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloDotGeneralOptions = StablehloDotGeneralOptions()
+        stablehloDotGeneralOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloDotGeneralOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloDotGeneralOptions):
+        x = StablehloDotGeneralOptionsT()
+        x._UnPack(stablehloDotGeneralOptions)
+        return x
+
+    # StablehloDotGeneralOptionsT
+    def _UnPack(self, stablehloDotGeneralOptions):
+        if stablehloDotGeneralOptions is None:
+            return
+        if not stablehloDotGeneralOptions.LhsBatchingDimensionsIsNone():
+            if np is None:
+                self.lhsBatchingDimensions = []
+                for i in range(stablehloDotGeneralOptions.LhsBatchingDimensionsLength()):
+                    self.lhsBatchingDimensions.append(stablehloDotGeneralOptions.LhsBatchingDimensions(i))
+            else:
+                self.lhsBatchingDimensions = stablehloDotGeneralOptions.LhsBatchingDimensionsAsNumpy()
+        if not stablehloDotGeneralOptions.RhsBatchingDimensionsIsNone():
+            if np is None:
+                self.rhsBatchingDimensions = []
+                for i in range(stablehloDotGeneralOptions.RhsBatchingDimensionsLength()):
+                    self.rhsBatchingDimensions.append(stablehloDotGeneralOptions.RhsBatchingDimensions(i))
+            else:
+                self.rhsBatchingDimensions = stablehloDotGeneralOptions.RhsBatchingDimensionsAsNumpy()
+        if not stablehloDotGeneralOptions.LhsContractingDimensionsIsNone():
+            if np is None:
+                self.lhsContractingDimensions = []
+                for i in range(stablehloDotGeneralOptions.LhsContractingDimensionsLength()):
+                    self.lhsContractingDimensions.append(stablehloDotGeneralOptions.LhsContractingDimensions(i))
+            else:
+                self.lhsContractingDimensions = stablehloDotGeneralOptions.LhsContractingDimensionsAsNumpy()
+        if not stablehloDotGeneralOptions.RhsContractingDimensionsIsNone():
+            if np is None:
+                self.rhsContractingDimensions = []
+                for i in range(stablehloDotGeneralOptions.RhsContractingDimensionsLength()):
+                    self.rhsContractingDimensions.append(stablehloDotGeneralOptions.RhsContractingDimensions(i))
+            else:
+                self.rhsContractingDimensions = stablehloDotGeneralOptions.RhsContractingDimensionsAsNumpy()
+        if not stablehloDotGeneralOptions.PrecisionConfigIsNone():
+            if np is None:
+                self.precisionConfig = []
+                for i in range(stablehloDotGeneralOptions.PrecisionConfigLength()):
+                    self.precisionConfig.append(stablehloDotGeneralOptions.PrecisionConfig(i))
+            else:
+                self.precisionConfig = stablehloDotGeneralOptions.PrecisionConfigAsNumpy()
+
+    # StablehloDotGeneralOptionsT
+    def Pack(self, builder):
+        if self.lhsBatchingDimensions is not None:
+            if np is not None and type(self.lhsBatchingDimensions) is np.ndarray:
+                lhsBatchingDimensions = builder.CreateNumpyVector(self.lhsBatchingDimensions)
+            else:
+                StablehloDotGeneralOptionsStartLhsBatchingDimensionsVector(builder, len(self.lhsBatchingDimensions))
+                for i in reversed(range(len(self.lhsBatchingDimensions))):
+                    builder.PrependInt64(self.lhsBatchingDimensions[i])
+                lhsBatchingDimensions = builder.EndVector()
+        if self.rhsBatchingDimensions is not None:
+            if np is not None and type(self.rhsBatchingDimensions) is np.ndarray:
+                rhsBatchingDimensions = builder.CreateNumpyVector(self.rhsBatchingDimensions)
+            else:
+                StablehloDotGeneralOptionsStartRhsBatchingDimensionsVector(builder, len(self.rhsBatchingDimensions))
+                for i in reversed(range(len(self.rhsBatchingDimensions))):
+                    builder.PrependInt64(self.rhsBatchingDimensions[i])
+                rhsBatchingDimensions = builder.EndVector()
+        if self.lhsContractingDimensions is not None:
+            if np is not None and type(self.lhsContractingDimensions) is np.ndarray:
+                lhsContractingDimensions = builder.CreateNumpyVector(self.lhsContractingDimensions)
+            else:
+                StablehloDotGeneralOptionsStartLhsContractingDimensionsVector(builder, len(self.lhsContractingDimensions))
+                for i in reversed(range(len(self.lhsContractingDimensions))):
+                    builder.PrependInt64(self.lhsContractingDimensions[i])
+                lhsContractingDimensions = builder.EndVector()
+        if self.rhsContractingDimensions is not None:
+            if np is not None and type(self.rhsContractingDimensions) is np.ndarray:
+                rhsContractingDimensions = builder.CreateNumpyVector(self.rhsContractingDimensions)
+            else:
+                StablehloDotGeneralOptionsStartRhsContractingDimensionsVector(builder, len(self.rhsContractingDimensions))
+                for i in reversed(range(len(self.rhsContractingDimensions))):
+                    builder.PrependInt64(self.rhsContractingDimensions[i])
+                rhsContractingDimensions = builder.EndVector()
+        if self.precisionConfig is not None:
+            if np is not None and type(self.precisionConfig) is np.ndarray:
+                precisionConfig = builder.CreateNumpyVector(self.precisionConfig)
+            else:
+                StablehloDotGeneralOptionsStartPrecisionConfigVector(builder, len(self.precisionConfig))
+                for i in reversed(range(len(self.precisionConfig))):
+                    builder.PrependUint32(self.precisionConfig[i])
+                precisionConfig = builder.EndVector()
+        StablehloDotGeneralOptionsStart(builder)
+        if self.lhsBatchingDimensions is not None:
+            StablehloDotGeneralOptionsAddLhsBatchingDimensions(builder, lhsBatchingDimensions)
+        if self.rhsBatchingDimensions is not None:
+            StablehloDotGeneralOptionsAddRhsBatchingDimensions(builder, rhsBatchingDimensions)
+        if self.lhsContractingDimensions is not None:
+            StablehloDotGeneralOptionsAddLhsContractingDimensions(builder, lhsContractingDimensions)
+        if self.rhsContractingDimensions is not None:
+            StablehloDotGeneralOptionsAddRhsContractingDimensions(builder, rhsContractingDimensions)
+        if self.precisionConfig is not None:
+            StablehloDotGeneralOptionsAddPrecisionConfig(builder, precisionConfig)
+        stablehloDotGeneralOptions = StablehloDotGeneralOptionsEnd(builder)
+        return stablehloDotGeneralOptions
+
+
+class StablehloReduceWindowOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloReduceWindowOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloReduceWindowOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloReduceWindowOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloReduceWindowOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloReduceWindowOptions
+    def WindowDimensions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloReduceWindowOptions
+    def WindowDimensionsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloReduceWindowOptions
+    def WindowDimensionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloReduceWindowOptions
+    def WindowDimensionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # StablehloReduceWindowOptions
+    def WindowStrides(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloReduceWindowOptions
+    def WindowStridesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloReduceWindowOptions
+    def WindowStridesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloReduceWindowOptions
+    def WindowStridesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # StablehloReduceWindowOptions
+    def BaseDilations(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloReduceWindowOptions
+    def BaseDilationsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloReduceWindowOptions
+    def BaseDilationsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloReduceWindowOptions
+    def BaseDilationsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # StablehloReduceWindowOptions
+    def WindowDilations(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloReduceWindowOptions
+    def WindowDilationsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloReduceWindowOptions
+    def WindowDilationsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloReduceWindowOptions
+    def WindowDilationsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # StablehloReduceWindowOptions
+    def Padding(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloReduceWindowOptions
+    def PaddingAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloReduceWindowOptions
+    def PaddingLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloReduceWindowOptions
+    def PaddingIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # StablehloReduceWindowOptions
+    def BodySubgraphIndex(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def StablehloReduceWindowOptionsStart(builder):
+    builder.StartObject(6)
+
+def StablehloReduceWindowOptionsAddWindowDimensions(builder, windowDimensions):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(windowDimensions), 0)
+
+def StablehloReduceWindowOptionsStartWindowDimensionsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloReduceWindowOptionsAddWindowStrides(builder, windowStrides):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(windowStrides), 0)
+
+def StablehloReduceWindowOptionsStartWindowStridesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloReduceWindowOptionsAddBaseDilations(builder, baseDilations):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(baseDilations), 0)
+
+def StablehloReduceWindowOptionsStartBaseDilationsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloReduceWindowOptionsAddWindowDilations(builder, windowDilations):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(windowDilations), 0)
+
+def StablehloReduceWindowOptionsStartWindowDilationsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloReduceWindowOptionsAddPadding(builder, padding):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0)
+
+def StablehloReduceWindowOptionsStartPaddingVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloReduceWindowOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex):
+    builder.PrependInt32Slot(5, bodySubgraphIndex, 0)
+
+def StablehloReduceWindowOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloReduceWindowOptionsT(object):
+
+    # StablehloReduceWindowOptionsT
+    def __init__(self):
+        self.windowDimensions = None  # type: List[int]
+        self.windowStrides = None  # type: List[int]
+        self.baseDilations = None  # type: List[int]
+        self.windowDilations = None  # type: List[int]
+        self.padding = None  # type: List[int]
+        self.bodySubgraphIndex = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloReduceWindowOptions = StablehloReduceWindowOptions()
+        stablehloReduceWindowOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloReduceWindowOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloReduceWindowOptions):
+        x = StablehloReduceWindowOptionsT()
+        x._UnPack(stablehloReduceWindowOptions)
+        return x
+
+    # StablehloReduceWindowOptionsT
+    def _UnPack(self, stablehloReduceWindowOptions):
+        if stablehloReduceWindowOptions is None:
+            return
+        if not stablehloReduceWindowOptions.WindowDimensionsIsNone():
+            if np is None:
+                self.windowDimensions = []
+                for i in range(stablehloReduceWindowOptions.WindowDimensionsLength()):
+                    self.windowDimensions.append(stablehloReduceWindowOptions.WindowDimensions(i))
+            else:
+                self.windowDimensions = stablehloReduceWindowOptions.WindowDimensionsAsNumpy()
+        if not stablehloReduceWindowOptions.WindowStridesIsNone():
+            if np is None:
+                self.windowStrides = []
+                for i in range(stablehloReduceWindowOptions.WindowStridesLength()):
+                    self.windowStrides.append(stablehloReduceWindowOptions.WindowStrides(i))
+            else:
+                self.windowStrides = stablehloReduceWindowOptions.WindowStridesAsNumpy()
+        if not stablehloReduceWindowOptions.BaseDilationsIsNone():
+            if np is None:
+                self.baseDilations = []
+                for i in range(stablehloReduceWindowOptions.BaseDilationsLength()):
+                    self.baseDilations.append(stablehloReduceWindowOptions.BaseDilations(i))
+            else:
+                self.baseDilations = stablehloReduceWindowOptions.BaseDilationsAsNumpy()
+        if not stablehloReduceWindowOptions.WindowDilationsIsNone():
+            if np is None:
+                self.windowDilations = []
+                for i in range(stablehloReduceWindowOptions.WindowDilationsLength()):
+                    self.windowDilations.append(stablehloReduceWindowOptions.WindowDilations(i))
+            else:
+                self.windowDilations = stablehloReduceWindowOptions.WindowDilationsAsNumpy()
+        if not stablehloReduceWindowOptions.PaddingIsNone():
+            if np is None:
+                self.padding = []
+                for i in range(stablehloReduceWindowOptions.PaddingLength()):
+                    self.padding.append(stablehloReduceWindowOptions.Padding(i))
+            else:
+                self.padding = stablehloReduceWindowOptions.PaddingAsNumpy()
+        self.bodySubgraphIndex = stablehloReduceWindowOptions.BodySubgraphIndex()
+
+    # StablehloReduceWindowOptionsT
+    def Pack(self, builder):
+        if self.windowDimensions is not None:
+            if np is not None and type(self.windowDimensions) is np.ndarray:
+                windowDimensions = builder.CreateNumpyVector(self.windowDimensions)
+            else:
+                StablehloReduceWindowOptionsStartWindowDimensionsVector(builder, len(self.windowDimensions))
+                for i in reversed(range(len(self.windowDimensions))):
+                    builder.PrependInt64(self.windowDimensions[i])
+                windowDimensions = builder.EndVector()
+        if self.windowStrides is not None:
+            if np is not None and type(self.windowStrides) is np.ndarray:
+                windowStrides = builder.CreateNumpyVector(self.windowStrides)
+            else:
+                StablehloReduceWindowOptionsStartWindowStridesVector(builder, len(self.windowStrides))
+                for i in reversed(range(len(self.windowStrides))):
+                    builder.PrependInt64(self.windowStrides[i])
+                windowStrides = builder.EndVector()
+        if self.baseDilations is not None:
+            if np is not None and type(self.baseDilations) is np.ndarray:
+                baseDilations = builder.CreateNumpyVector(self.baseDilations)
+            else:
+                StablehloReduceWindowOptionsStartBaseDilationsVector(builder, len(self.baseDilations))
+                for i in reversed(range(len(self.baseDilations))):
+                    builder.PrependInt64(self.baseDilations[i])
+                baseDilations = builder.EndVector()
+        if self.windowDilations is not None:
+            if np is not None and type(self.windowDilations) is np.ndarray:
+                windowDilations = builder.CreateNumpyVector(self.windowDilations)
+            else:
+                StablehloReduceWindowOptionsStartWindowDilationsVector(builder, len(self.windowDilations))
+                for i in reversed(range(len(self.windowDilations))):
+                    builder.PrependInt64(self.windowDilations[i])
+                windowDilations = builder.EndVector()
+        if self.padding is not None:
+            if np is not None and type(self.padding) is np.ndarray:
+                padding = builder.CreateNumpyVector(self.padding)
+            else:
+                StablehloReduceWindowOptionsStartPaddingVector(builder, len(self.padding))
+                for i in reversed(range(len(self.padding))):
+                    builder.PrependInt64(self.padding[i])
+                padding = builder.EndVector()
+        StablehloReduceWindowOptionsStart(builder)
+        if self.windowDimensions is not None:
+            StablehloReduceWindowOptionsAddWindowDimensions(builder, windowDimensions)
+        if self.windowStrides is not None:
+            StablehloReduceWindowOptionsAddWindowStrides(builder, windowStrides)
+        if self.baseDilations is not None:
+            StablehloReduceWindowOptionsAddBaseDilations(builder, baseDilations)
+        if self.windowDilations is not None:
+            StablehloReduceWindowOptionsAddWindowDilations(builder, windowDilations)
+        if self.padding is not None:
+            StablehloReduceWindowOptionsAddPadding(builder, padding)
+        StablehloReduceWindowOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex)
+        stablehloReduceWindowOptions = StablehloReduceWindowOptionsEnd(builder)
+        return stablehloReduceWindowOptions
+
+
+class StablehloWhileOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloWhileOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloWhileOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloWhileOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloWhileOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloWhileOptions
+    def CondSubgraphIndex(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloWhileOptions
+    def BodySubgraphIndex(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def StablehloWhileOptionsStart(builder):
+    builder.StartObject(2)
+
+def StablehloWhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex):
+    builder.PrependInt32Slot(0, condSubgraphIndex, 0)
+
+def StablehloWhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex):
+    builder.PrependInt32Slot(1, bodySubgraphIndex, 0)
+
+def StablehloWhileOptionsEnd(builder):
+    return builder.EndObject()
+
+
+
+class StablehloWhileOptionsT(object):
+
+    # StablehloWhileOptionsT
+    def __init__(self):
+        self.condSubgraphIndex = 0  # type: int
+        self.bodySubgraphIndex = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloWhileOptions = StablehloWhileOptions()
+        stablehloWhileOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloWhileOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloWhileOptions):
+        x = StablehloWhileOptionsT()
+        x._UnPack(stablehloWhileOptions)
+        return x
+
+    # StablehloWhileOptionsT
+    def _UnPack(self, stablehloWhileOptions):
+        if stablehloWhileOptions is None:
+            return
+        self.condSubgraphIndex = stablehloWhileOptions.CondSubgraphIndex()
+        self.bodySubgraphIndex = stablehloWhileOptions.BodySubgraphIndex()
+
+    # StablehloWhileOptionsT
+    def Pack(self, builder):
+        StablehloWhileOptionsStart(builder)
+        StablehloWhileOptionsAddCondSubgraphIndex(builder, self.condSubgraphIndex)
+        StablehloWhileOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex)
+        stablehloWhileOptions = StablehloWhileOptionsEnd(builder)
+        return stablehloWhileOptions
+
+
+class StablehloSortOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloSortOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloSortOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloSortOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloSortOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloSortOptions
+    def Dimension(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloSortOptions
+    def IsStable(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # StablehloSortOptions
+    def ComparatorSubgraphIndex(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def StablehloSortOptionsStart(builder):
+    builder.StartObject(3)
+
+def StablehloSortOptionsAddDimension(builder, dimension):
+    builder.PrependInt64Slot(0, dimension, 0)
+
+def StablehloSortOptionsAddIsStable(builder, isStable):
+    builder.PrependBoolSlot(1, isStable, 0)
+
+def StablehloSortOptionsAddComparatorSubgraphIndex(builder, comparatorSubgraphIndex):
+    builder.PrependInt32Slot(2, comparatorSubgraphIndex, 0)
+
+def StablehloSortOptionsEnd(builder):
+    return builder.EndObject()
+
+
+
+class StablehloSortOptionsT(object):
+
+    # StablehloSortOptionsT
+    def __init__(self):
+        self.dimension = 0  # type: int
+        self.isStable = False  # type: bool
+        self.comparatorSubgraphIndex = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloSortOptions = StablehloSortOptions()
+        stablehloSortOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloSortOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloSortOptions):
+        x = StablehloSortOptionsT()
+        x._UnPack(stablehloSortOptions)
+        return x
+
+    # StablehloSortOptionsT
+    def _UnPack(self, stablehloSortOptions):
+        if stablehloSortOptions is None:
+            return
+        self.dimension = stablehloSortOptions.Dimension()
+        self.isStable = stablehloSortOptions.IsStable()
+        self.comparatorSubgraphIndex = stablehloSortOptions.ComparatorSubgraphIndex()
+
+    # StablehloSortOptionsT
+    def Pack(self, builder):
+        StablehloSortOptionsStart(builder)
+        StablehloSortOptionsAddDimension(builder, self.dimension)
+        StablehloSortOptionsAddIsStable(builder, self.isStable)
+        StablehloSortOptionsAddComparatorSubgraphIndex(builder, self.comparatorSubgraphIndex)
+        stablehloSortOptions = StablehloSortOptionsEnd(builder)
+        return stablehloSortOptions
+
+
+class StablehloConcatenateOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloConcatenateOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloConcatenateOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloConcatenateOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloConcatenateOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloConcatenateOptions
+    def Dimension(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+def StablehloConcatenateOptionsStart(builder):
+    builder.StartObject(1)
+
+def StablehloConcatenateOptionsAddDimension(builder, dimension):
+    builder.PrependInt64Slot(0, dimension, 0)
+
+def StablehloConcatenateOptionsEnd(builder):
+    return builder.EndObject()
+
+
+
+class StablehloConcatenateOptionsT(object):
+
+    # StablehloConcatenateOptionsT
+    def __init__(self):
+        self.dimension = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloConcatenateOptions = StablehloConcatenateOptions()
+        stablehloConcatenateOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloConcatenateOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloConcatenateOptions):
+        x = StablehloConcatenateOptionsT()
+        x._UnPack(stablehloConcatenateOptions)
+        return x
+
+    # StablehloConcatenateOptionsT
+    def _UnPack(self, stablehloConcatenateOptions):
+        if stablehloConcatenateOptions is None:
+            return
+        self.dimension = stablehloConcatenateOptions.Dimension()
+
+    # StablehloConcatenateOptionsT
+    def Pack(self, builder):
+        StablehloConcatenateOptionsStart(builder)
+        StablehloConcatenateOptionsAddDimension(builder, self.dimension)
+        stablehloConcatenateOptions = StablehloConcatenateOptionsEnd(builder)
+        return stablehloConcatenateOptions
+
+
+class StablehloBroadcastInDimOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloBroadcastInDimOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloBroadcastInDimOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloBroadcastInDimOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloBroadcastInDimOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloBroadcastInDimOptions
+    def BroadcastDimensions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloBroadcastInDimOptions
+    def BroadcastDimensionsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloBroadcastInDimOptions
+    def BroadcastDimensionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloBroadcastInDimOptions
+    def BroadcastDimensionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+def StablehloBroadcastInDimOptionsStart(builder):
+    builder.StartObject(1)
+
+def StablehloBroadcastInDimOptionsAddBroadcastDimensions(builder, broadcastDimensions):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(broadcastDimensions), 0)
+
+def StablehloBroadcastInDimOptionsStartBroadcastDimensionsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloBroadcastInDimOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloBroadcastInDimOptionsT(object):
+
+    # StablehloBroadcastInDimOptionsT
+    def __init__(self):
+        self.broadcastDimensions = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloBroadcastInDimOptions = StablehloBroadcastInDimOptions()
+        stablehloBroadcastInDimOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloBroadcastInDimOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloBroadcastInDimOptions):
+        x = StablehloBroadcastInDimOptionsT()
+        x._UnPack(stablehloBroadcastInDimOptions)
+        return x
+
+    # StablehloBroadcastInDimOptionsT
+    def _UnPack(self, stablehloBroadcastInDimOptions):
+        if stablehloBroadcastInDimOptions is None:
+            return
+        if not stablehloBroadcastInDimOptions.BroadcastDimensionsIsNone():
+            if np is None:
+                self.broadcastDimensions = []
+                for i in range(stablehloBroadcastInDimOptions.BroadcastDimensionsLength()):
+                    self.broadcastDimensions.append(stablehloBroadcastInDimOptions.BroadcastDimensions(i))
+            else:
+                self.broadcastDimensions = stablehloBroadcastInDimOptions.BroadcastDimensionsAsNumpy()
+
+    # StablehloBroadcastInDimOptionsT
+    def Pack(self, builder):
+        if self.broadcastDimensions is not None:
+            if np is not None and type(self.broadcastDimensions) is np.ndarray:
+                broadcastDimensions = builder.CreateNumpyVector(self.broadcastDimensions)
+            else:
+                StablehloBroadcastInDimOptionsStartBroadcastDimensionsVector(builder, len(self.broadcastDimensions))
+                for i in reversed(range(len(self.broadcastDimensions))):
+                    builder.PrependInt64(self.broadcastDimensions[i])
+                broadcastDimensions = builder.EndVector()
+        StablehloBroadcastInDimOptionsStart(builder)
+        if self.broadcastDimensions is not None:
+            StablehloBroadcastInDimOptionsAddBroadcastDimensions(builder, broadcastDimensions)
+        stablehloBroadcastInDimOptions = StablehloBroadcastInDimOptionsEnd(builder)
+        return stablehloBroadcastInDimOptions
+
+
+class StablehloCompareOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloCompareOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloCompareOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloCompareOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloCompareOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloCompareOptions
+    def ComparisonDirection(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloCompareOptions
+    def CompareType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+def StablehloCompareOptionsStart(builder):
+    builder.StartObject(2)
+
+def StablehloCompareOptionsAddComparisonDirection(builder, comparisonDirection):
+    builder.PrependUint32Slot(0, comparisonDirection, 0)
+
+def StablehloCompareOptionsAddCompareType(builder, compareType):
+    builder.PrependUint32Slot(1, compareType, 0)
+
+def StablehloCompareOptionsEnd(builder):
+    return builder.EndObject()
+
+
+
+class StablehloCompareOptionsT(object):
+
+    # StablehloCompareOptionsT
+    def __init__(self):
+        self.comparisonDirection = 0  # type: int
+        self.compareType = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloCompareOptions = StablehloCompareOptions()
+        stablehloCompareOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloCompareOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloCompareOptions):
+        x = StablehloCompareOptionsT()
+        x._UnPack(stablehloCompareOptions)
+        return x
+
+    # StablehloCompareOptionsT
+    def _UnPack(self, stablehloCompareOptions):
+        if stablehloCompareOptions is None:
+            return
+        self.comparisonDirection = stablehloCompareOptions.ComparisonDirection()
+        self.compareType = stablehloCompareOptions.CompareType()
+
+    # StablehloCompareOptionsT
+    def Pack(self, builder):
+        StablehloCompareOptionsStart(builder)
+        StablehloCompareOptionsAddComparisonDirection(builder, self.comparisonDirection)
+        StablehloCompareOptionsAddCompareType(builder, self.compareType)
+        stablehloCompareOptions = StablehloCompareOptionsEnd(builder)
+        return stablehloCompareOptions
+
+
+class StablehloDynamicSliceOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloDynamicSliceOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloDynamicSliceOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloDynamicSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloDynamicSliceOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloDynamicSliceOptions
+    def SliceSizes(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloDynamicSliceOptions
+    def SliceSizesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloDynamicSliceOptions
+    def SliceSizesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloDynamicSliceOptions
+    def SliceSizesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+def StablehloDynamicSliceOptionsStart(builder):
+    builder.StartObject(1)
+
+def StablehloDynamicSliceOptionsAddSliceSizes(builder, sliceSizes):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(sliceSizes), 0)
+
+def StablehloDynamicSliceOptionsStartSliceSizesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloDynamicSliceOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloDynamicSliceOptionsT(object):
+
+    # StablehloDynamicSliceOptionsT
+    def __init__(self):
+        self.sliceSizes = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloDynamicSliceOptions = StablehloDynamicSliceOptions()
+        stablehloDynamicSliceOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloDynamicSliceOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloDynamicSliceOptions):
+        x = StablehloDynamicSliceOptionsT()
+        x._UnPack(stablehloDynamicSliceOptions)
+        return x
+
+    # StablehloDynamicSliceOptionsT
+    def _UnPack(self, stablehloDynamicSliceOptions):
+        if stablehloDynamicSliceOptions is None:
+            return
+        if not stablehloDynamicSliceOptions.SliceSizesIsNone():
+            if np is None:
+                self.sliceSizes = []
+                for i in range(stablehloDynamicSliceOptions.SliceSizesLength()):
+                    self.sliceSizes.append(stablehloDynamicSliceOptions.SliceSizes(i))
+            else:
+                self.sliceSizes = stablehloDynamicSliceOptions.SliceSizesAsNumpy()
+
+    # StablehloDynamicSliceOptionsT
+    def Pack(self, builder):
+        if self.sliceSizes is not None:
+            if np is not None and type(self.sliceSizes) is np.ndarray:
+                sliceSizes = builder.CreateNumpyVector(self.sliceSizes)
+            else:
+                StablehloDynamicSliceOptionsStartSliceSizesVector(builder, len(self.sliceSizes))
+                for i in reversed(range(len(self.sliceSizes))):
+                    builder.PrependInt64(self.sliceSizes[i])
+                sliceSizes = builder.EndVector()
+        StablehloDynamicSliceOptionsStart(builder)
+        if self.sliceSizes is not None:
+            StablehloDynamicSliceOptionsAddSliceSizes(builder, sliceSizes)
+        stablehloDynamicSliceOptions = StablehloDynamicSliceOptionsEnd(builder)
+        return stablehloDynamicSliceOptions
+
+
+class StablehloPadOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloPadOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloPadOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloPadOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloPadOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloPadOptions
+    def EdgePaddingLow(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloPadOptions
+    def EdgePaddingLowAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloPadOptions
+    def EdgePaddingLowLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloPadOptions
+    def EdgePaddingLowIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # StablehloPadOptions
+    def EdgePaddingHigh(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloPadOptions
+    def EdgePaddingHighAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloPadOptions
+    def EdgePaddingHighLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloPadOptions
+    def EdgePaddingHighIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # StablehloPadOptions
+    def InteriorPadding(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloPadOptions
+    def InteriorPaddingAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloPadOptions
+    def InteriorPaddingLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloPadOptions
+    def InteriorPaddingIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+def StablehloPadOptionsStart(builder):
+    builder.StartObject(3)
+
+def StablehloPadOptionsAddEdgePaddingLow(builder, edgePaddingLow):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(edgePaddingLow), 0)
+
+def StablehloPadOptionsStartEdgePaddingLowVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloPadOptionsAddEdgePaddingHigh(builder, edgePaddingHigh):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(edgePaddingHigh), 0)
+
+def StablehloPadOptionsStartEdgePaddingHighVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloPadOptionsAddInteriorPadding(builder, interiorPadding):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(interiorPadding), 0)
+
+def StablehloPadOptionsStartInteriorPaddingVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloPadOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloPadOptionsT(object):
+
+    # StablehloPadOptionsT
+    def __init__(self):
+        self.edgePaddingLow = None  # type: List[int]
+        self.edgePaddingHigh = None  # type: List[int]
+        self.interiorPadding = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloPadOptions = StablehloPadOptions()
+        stablehloPadOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloPadOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloPadOptions):
+        x = StablehloPadOptionsT()
+        x._UnPack(stablehloPadOptions)
+        return x
+
+    # StablehloPadOptionsT
+    def _UnPack(self, stablehloPadOptions):
+        if stablehloPadOptions is None:
+            return
+        if not stablehloPadOptions.EdgePaddingLowIsNone():
+            if np is None:
+                self.edgePaddingLow = []
+                for i in range(stablehloPadOptions.EdgePaddingLowLength()):
+                    self.edgePaddingLow.append(stablehloPadOptions.EdgePaddingLow(i))
+            else:
+                self.edgePaddingLow = stablehloPadOptions.EdgePaddingLowAsNumpy()
+        if not stablehloPadOptions.EdgePaddingHighIsNone():
+            if np is None:
+                self.edgePaddingHigh = []
+                for i in range(stablehloPadOptions.EdgePaddingHighLength()):
+                    self.edgePaddingHigh.append(stablehloPadOptions.EdgePaddingHigh(i))
+            else:
+                self.edgePaddingHigh = stablehloPadOptions.EdgePaddingHighAsNumpy()
+        if not stablehloPadOptions.InteriorPaddingIsNone():
+            if np is None:
+                self.interiorPadding = []
+                for i in range(stablehloPadOptions.InteriorPaddingLength()):
+                    self.interiorPadding.append(stablehloPadOptions.InteriorPadding(i))
+            else:
+                self.interiorPadding = stablehloPadOptions.InteriorPaddingAsNumpy()
+
+    # StablehloPadOptionsT
+    def Pack(self, builder):
+        if self.edgePaddingLow is not None:
+            if np is not None and type(self.edgePaddingLow) is np.ndarray:
+                edgePaddingLow = builder.CreateNumpyVector(self.edgePaddingLow)
+            else:
+                StablehloPadOptionsStartEdgePaddingLowVector(builder, len(self.edgePaddingLow))
+                for i in reversed(range(len(self.edgePaddingLow))):
+                    builder.PrependInt64(self.edgePaddingLow[i])
+                edgePaddingLow = builder.EndVector()
+        if self.edgePaddingHigh is not None:
+            if np is not None and type(self.edgePaddingHigh) is np.ndarray:
+                edgePaddingHigh = builder.CreateNumpyVector(self.edgePaddingHigh)
+            else:
+                StablehloPadOptionsStartEdgePaddingHighVector(builder, len(self.edgePaddingHigh))
+                for i in reversed(range(len(self.edgePaddingHigh))):
+                    builder.PrependInt64(self.edgePaddingHigh[i])
+                edgePaddingHigh = builder.EndVector()
+        if self.interiorPadding is not None:
+            if np is not None and type(self.interiorPadding) is np.ndarray:
+                interiorPadding = builder.CreateNumpyVector(self.interiorPadding)
+            else:
+                StablehloPadOptionsStartInteriorPaddingVector(builder, len(self.interiorPadding))
+                for i in reversed(range(len(self.interiorPadding))):
+                    builder.PrependInt64(self.interiorPadding[i])
+                interiorPadding = builder.EndVector()
+        StablehloPadOptionsStart(builder)
+        if self.edgePaddingLow is not None:
+            StablehloPadOptionsAddEdgePaddingLow(builder, edgePaddingLow)
+        if self.edgePaddingHigh is not None:
+            StablehloPadOptionsAddEdgePaddingHigh(builder, edgePaddingHigh)
+        if self.interiorPadding is not None:
+            StablehloPadOptionsAddInteriorPadding(builder, interiorPadding)
+        stablehloPadOptions = StablehloPadOptionsEnd(builder)
+        return stablehloPadOptions
+
+
+class StablehloIotaOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloIotaOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloIotaOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloIotaOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloIotaOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloIotaOptions
+    def IotaDimension(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+def StablehloIotaOptionsStart(builder):
+    builder.StartObject(1)
+
+def StablehloIotaOptionsAddIotaDimension(builder, iotaDimension):
+    builder.PrependInt64Slot(0, iotaDimension, 0)
+
+def StablehloIotaOptionsEnd(builder):
+    return builder.EndObject()
+
+
+
+class StablehloIotaOptionsT(object):
+
+    # StablehloIotaOptionsT
+    def __init__(self):
+        self.iotaDimension = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloIotaOptions = StablehloIotaOptions()
+        stablehloIotaOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloIotaOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloIotaOptions):
+        x = StablehloIotaOptionsT()
+        x._UnPack(stablehloIotaOptions)
+        return x
+
+    # StablehloIotaOptionsT
+    def _UnPack(self, stablehloIotaOptions):
+        if stablehloIotaOptions is None:
+            return
+        self.iotaDimension = stablehloIotaOptions.IotaDimension()
+
+    # StablehloIotaOptionsT
+    def Pack(self, builder):
+        StablehloIotaOptionsStart(builder)
+        StablehloIotaOptionsAddIotaDimension(builder, self.iotaDimension)
+        stablehloIotaOptions = StablehloIotaOptionsEnd(builder)
+        return stablehloIotaOptions
+
+
+class StablehloCustomCallOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloCustomCallOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloCustomCallOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloCustomCallOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloCustomCallOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloCustomCallOptions
+    def CallTargetName(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # StablehloCustomCallOptions
+    def HasSideEffect(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # StablehloCustomCallOptions
+    def BackendConfig(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # StablehloCustomCallOptions
+    def ApiVersion(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloCustomCallOptions
+    def CalledComputations(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # StablehloCustomCallOptions
+    def CalledComputationsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # StablehloCustomCallOptions
+    def CalledComputationsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloCustomCallOptions
+    def CalledComputationsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # StablehloCustomCallOptions
+    def CustomAttributes(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # StablehloCustomCallOptions
+    def CustomAttributesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # StablehloCustomCallOptions
+    def CustomAttributesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloCustomCallOptions
+    def CustomAttributesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+def StablehloCustomCallOptionsStart(builder):
+    builder.StartObject(6)
+
+def StablehloCustomCallOptionsAddCallTargetName(builder, callTargetName):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(callTargetName), 0)
+
+def StablehloCustomCallOptionsAddHasSideEffect(builder, hasSideEffect):
+    builder.PrependBoolSlot(1, hasSideEffect, 0)
+
+def StablehloCustomCallOptionsAddBackendConfig(builder, backendConfig):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(backendConfig), 0)
+
+def StablehloCustomCallOptionsAddApiVersion(builder, apiVersion):
+    builder.PrependInt32Slot(3, apiVersion, 0)
+
+def StablehloCustomCallOptionsAddCalledComputations(builder, calledComputations):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(calledComputations), 0)
+
+def StablehloCustomCallOptionsStartCalledComputationsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StablehloCustomCallOptionsAddCustomAttributes(builder, customAttributes):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(customAttributes), 0)
+
+def StablehloCustomCallOptionsStartCustomAttributesVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def StablehloCustomCallOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloCustomCallOptionsT(object):
+
+    # StablehloCustomCallOptionsT
+    def __init__(self):
+        self.callTargetName = None  # type: str
+        self.hasSideEffect = False  # type: bool
+        self.backendConfig = None  # type: str
+        self.apiVersion = 0  # type: int
+        self.calledComputations = None  # type: List[int]
+        self.customAttributes = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloCustomCallOptions = StablehloCustomCallOptions()
+        stablehloCustomCallOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloCustomCallOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloCustomCallOptions):
+        x = StablehloCustomCallOptionsT()
+        x._UnPack(stablehloCustomCallOptions)
+        return x
+
+    # StablehloCustomCallOptionsT
+    def _UnPack(self, stablehloCustomCallOptions):
+        if stablehloCustomCallOptions is None:
+            return
+        self.callTargetName = stablehloCustomCallOptions.CallTargetName()
+        self.hasSideEffect = stablehloCustomCallOptions.HasSideEffect()
+        self.backendConfig = stablehloCustomCallOptions.BackendConfig()
+        self.apiVersion = stablehloCustomCallOptions.ApiVersion()
+        if not stablehloCustomCallOptions.CalledComputationsIsNone():
+            if np is None:
+                self.calledComputations = []
+                for i in range(stablehloCustomCallOptions.CalledComputationsLength()):
+                    self.calledComputations.append(stablehloCustomCallOptions.CalledComputations(i))
+            else:
+                self.calledComputations = stablehloCustomCallOptions.CalledComputationsAsNumpy()
+        if not stablehloCustomCallOptions.CustomAttributesIsNone():
+            if np is None:
+                self.customAttributes = []
+                for i in range(stablehloCustomCallOptions.CustomAttributesLength()):
+                    self.customAttributes.append(stablehloCustomCallOptions.CustomAttributes(i))
+            else:
+                self.customAttributes = stablehloCustomCallOptions.CustomAttributesAsNumpy()
+
+    # StablehloCustomCallOptionsT
+    def Pack(self, builder):
+        if self.callTargetName is not None:
+            callTargetName = builder.CreateString(self.callTargetName)
+        if self.backendConfig is not None:
+            backendConfig = builder.CreateString(self.backendConfig)
+        if self.calledComputations is not None:
+            if np is not None and type(self.calledComputations) is np.ndarray:
+                calledComputations = builder.CreateNumpyVector(self.calledComputations)
+            else:
+                StablehloCustomCallOptionsStartCalledComputationsVector(builder, len(self.calledComputations))
+                for i in reversed(range(len(self.calledComputations))):
+                    builder.PrependInt32(self.calledComputations[i])
+                calledComputations = builder.EndVector()
+        if self.customAttributes is not None:
+            if np is not None and type(self.customAttributes) is np.ndarray:
+                customAttributes = builder.CreateNumpyVector(self.customAttributes)
+            else:
+                StablehloCustomCallOptionsStartCustomAttributesVector(builder, len(self.customAttributes))
+                for i in reversed(range(len(self.customAttributes))):
+                    builder.PrependUint8(self.customAttributes[i])
+                customAttributes = builder.EndVector()
+        StablehloCustomCallOptionsStart(builder)
+        if self.callTargetName is not None:
+            StablehloCustomCallOptionsAddCallTargetName(builder, callTargetName)
+        StablehloCustomCallOptionsAddHasSideEffect(builder, self.hasSideEffect)
+        if self.backendConfig is not None:
+            StablehloCustomCallOptionsAddBackendConfig(builder, backendConfig)
+        StablehloCustomCallOptionsAddApiVersion(builder, self.apiVersion)
+        if self.calledComputations is not None:
+            StablehloCustomCallOptionsAddCalledComputations(builder, calledComputations)
+        if self.customAttributes is not None:
+            StablehloCustomCallOptionsAddCustomAttributes(builder, customAttributes)
+        stablehloCustomCallOptions = StablehloCustomCallOptionsEnd(builder)
+        return stablehloCustomCallOptions
+
+
+class StablehloReduceOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloReduceOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloReduceOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloReduceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloReduceOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloReduceOptions
+    def Dimensions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloReduceOptions
+    def DimensionsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloReduceOptions
+    def DimensionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloReduceOptions
+    def DimensionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # StablehloReduceOptions
+    def BodySubgraphIndex(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def StablehloReduceOptionsStart(builder):
+    builder.StartObject(2)
+
+def StablehloReduceOptionsAddDimensions(builder, dimensions):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(dimensions), 0)
+
+def StablehloReduceOptionsStartDimensionsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloReduceOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex):
+    builder.PrependInt32Slot(1, bodySubgraphIndex, 0)
+
+def StablehloReduceOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloReduceOptionsT(object):
+
+    # StablehloReduceOptionsT
+    def __init__(self):
+        self.dimensions = None  # type: List[int]
+        self.bodySubgraphIndex = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloReduceOptions = StablehloReduceOptions()
+        stablehloReduceOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloReduceOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloReduceOptions):
+        x = StablehloReduceOptionsT()
+        x._UnPack(stablehloReduceOptions)
+        return x
+
+    # StablehloReduceOptionsT
+    def _UnPack(self, stablehloReduceOptions):
+        if stablehloReduceOptions is None:
+            return
+        if not stablehloReduceOptions.DimensionsIsNone():
+            if np is None:
+                self.dimensions = []
+                for i in range(stablehloReduceOptions.DimensionsLength()):
+                    self.dimensions.append(stablehloReduceOptions.Dimensions(i))
+            else:
+                self.dimensions = stablehloReduceOptions.DimensionsAsNumpy()
+        self.bodySubgraphIndex = stablehloReduceOptions.BodySubgraphIndex()
+
+    # StablehloReduceOptionsT
+    def Pack(self, builder):
+        if self.dimensions is not None:
+            if np is not None and type(self.dimensions) is np.ndarray:
+                dimensions = builder.CreateNumpyVector(self.dimensions)
+            else:
+                StablehloReduceOptionsStartDimensionsVector(builder, len(self.dimensions))
+                for i in reversed(range(len(self.dimensions))):
+                    builder.PrependInt64(self.dimensions[i])
+                dimensions = builder.EndVector()
+        StablehloReduceOptionsStart(builder)
+        if self.dimensions is not None:
+            StablehloReduceOptionsAddDimensions(builder, dimensions)
+        StablehloReduceOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex)
+        stablehloReduceOptions = StablehloReduceOptionsEnd(builder)
+        return stablehloReduceOptions
+
+
+class StablehloSliceOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloSliceOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloSliceOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloSliceOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloSliceOptions
+    def StartIndices(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloSliceOptions
+    def StartIndicesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloSliceOptions
+    def StartIndicesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloSliceOptions
+    def StartIndicesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # StablehloSliceOptions
+    def LimitIndices(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloSliceOptions
+    def LimitIndicesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloSliceOptions
+    def LimitIndicesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloSliceOptions
+    def LimitIndicesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # StablehloSliceOptions
+    def Strides(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloSliceOptions
+    def StridesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloSliceOptions
+    def StridesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloSliceOptions
+    def StridesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+def StablehloSliceOptionsStart(builder):
+    builder.StartObject(3)
+
+def StablehloSliceOptionsAddStartIndices(builder, startIndices):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(startIndices), 0)
+
+def StablehloSliceOptionsStartStartIndicesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloSliceOptionsAddLimitIndices(builder, limitIndices):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(limitIndices), 0)
+
+def StablehloSliceOptionsStartLimitIndicesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloSliceOptionsAddStrides(builder, strides):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(strides), 0)
+
+def StablehloSliceOptionsStartStridesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloSliceOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloSliceOptionsT(object):
+
+    # StablehloSliceOptionsT
+    def __init__(self):
+        self.startIndices = None  # type: List[int]
+        self.limitIndices = None  # type: List[int]
+        self.strides = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloSliceOptions = StablehloSliceOptions()
+        stablehloSliceOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloSliceOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloSliceOptions):
+        x = StablehloSliceOptionsT()
+        x._UnPack(stablehloSliceOptions)
+        return x
+
+    # StablehloSliceOptionsT
+    def _UnPack(self, stablehloSliceOptions):
+        if stablehloSliceOptions is None:
+            return
+        if not stablehloSliceOptions.StartIndicesIsNone():
+            if np is None:
+                self.startIndices = []
+                for i in range(stablehloSliceOptions.StartIndicesLength()):
+                    self.startIndices.append(stablehloSliceOptions.StartIndices(i))
+            else:
+                self.startIndices = stablehloSliceOptions.StartIndicesAsNumpy()
+        if not stablehloSliceOptions.LimitIndicesIsNone():
+            if np is None:
+                self.limitIndices = []
+                for i in range(stablehloSliceOptions.LimitIndicesLength()):
+                    self.limitIndices.append(stablehloSliceOptions.LimitIndices(i))
+            else:
+                self.limitIndices = stablehloSliceOptions.LimitIndicesAsNumpy()
+        if not stablehloSliceOptions.StridesIsNone():
+            if np is None:
+                self.strides = []
+                for i in range(stablehloSliceOptions.StridesLength()):
+                    self.strides.append(stablehloSliceOptions.Strides(i))
+            else:
+                self.strides = stablehloSliceOptions.StridesAsNumpy()
+
+    # StablehloSliceOptionsT
+    def Pack(self, builder):
+        if self.startIndices is not None:
+            if np is not None and type(self.startIndices) is np.ndarray:
+                startIndices = builder.CreateNumpyVector(self.startIndices)
+            else:
+                StablehloSliceOptionsStartStartIndicesVector(builder, len(self.startIndices))
+                for i in reversed(range(len(self.startIndices))):
+                    builder.PrependInt64(self.startIndices[i])
+                startIndices = builder.EndVector()
+        if self.limitIndices is not None:
+            if np is not None and type(self.limitIndices) is np.ndarray:
+                limitIndices = builder.CreateNumpyVector(self.limitIndices)
+            else:
+                StablehloSliceOptionsStartLimitIndicesVector(builder, len(self.limitIndices))
+                for i in reversed(range(len(self.limitIndices))):
+                    builder.PrependInt64(self.limitIndices[i])
+                limitIndices = builder.EndVector()
+        if self.strides is not None:
+            if np is not None and type(self.strides) is np.ndarray:
+                strides = builder.CreateNumpyVector(self.strides)
+            else:
+                StablehloSliceOptionsStartStridesVector(builder, len(self.strides))
+                for i in reversed(range(len(self.strides))):
+                    builder.PrependInt64(self.strides[i])
+                strides = builder.EndVector()
+        StablehloSliceOptionsStart(builder)
+        if self.startIndices is not None:
+            StablehloSliceOptionsAddStartIndices(builder, startIndices)
+        if self.limitIndices is not None:
+            StablehloSliceOptionsAddLimitIndices(builder, limitIndices)
+        if self.strides is not None:
+            StablehloSliceOptionsAddStrides(builder, strides)
+        stablehloSliceOptions = StablehloSliceOptionsEnd(builder)
+        return stablehloSliceOptions
+
+
+class StablehloConvolutionOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloConvolutionOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloConvolutionOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloConvolutionOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloConvolutionOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloConvolutionOptions
+    def WindowStrides(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloConvolutionOptions
+    def WindowStridesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def WindowStridesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def WindowStridesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # StablehloConvolutionOptions
+    def Padding(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloConvolutionOptions
+    def PaddingAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def PaddingLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def PaddingIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # StablehloConvolutionOptions
+    def LhsDilation(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloConvolutionOptions
+    def LhsDilationAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def LhsDilationLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def LhsDilationIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # StablehloConvolutionOptions
+    def RhsDilation(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloConvolutionOptions
+    def RhsDilationAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def RhsDilationLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def RhsDilationIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # StablehloConvolutionOptions
+    def WindowReversal(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # StablehloConvolutionOptions
+    def WindowReversalAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def WindowReversalLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def WindowReversalIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # StablehloConvolutionOptions
+    def InputBatchDimension(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloConvolutionOptions
+    def InputFeatureDimension(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloConvolutionOptions
+    def InputSpatialDimensions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloConvolutionOptions
+    def InputSpatialDimensionsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def InputSpatialDimensionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def InputSpatialDimensionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        return o == 0
+
+    # StablehloConvolutionOptions
+    def KernelInputFeatureDimension(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloConvolutionOptions
+    def KernelOutputFeatureDimension(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloConvolutionOptions
+    def KernelSpatialDimensions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloConvolutionOptions
+    def KernelSpatialDimensionsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def KernelSpatialDimensionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def KernelSpatialDimensionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+    # StablehloConvolutionOptions
+    def OutputBatchDimension(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloConvolutionOptions
+    def OutputFeatureDimension(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloConvolutionOptions
+    def OutputSpatialDimensions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloConvolutionOptions
+    def OutputSpatialDimensionsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def OutputSpatialDimensionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def OutputSpatialDimensionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        return o == 0
+
+    # StablehloConvolutionOptions
+    def FeatureGroupCount(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloConvolutionOptions
+    def BatchGroupCount(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloConvolutionOptions
+    def PrecisionConfig(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # StablehloConvolutionOptions
+    def PrecisionConfigAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint32Flags, o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def PrecisionConfigLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloConvolutionOptions
+    def PrecisionConfigIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        return o == 0
+
+def StablehloConvolutionOptionsStart(builder):
+    builder.StartObject(17)
+
+def StablehloConvolutionOptionsAddWindowStrides(builder, windowStrides):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(windowStrides), 0)
+
+def StablehloConvolutionOptionsStartWindowStridesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddPadding(builder, padding):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0)
+
+def StablehloConvolutionOptionsStartPaddingVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddLhsDilation(builder, lhsDilation):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(lhsDilation), 0)
+
+def StablehloConvolutionOptionsStartLhsDilationVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddRhsDilation(builder, rhsDilation):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(rhsDilation), 0)
+
+def StablehloConvolutionOptionsStartRhsDilationVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddWindowReversal(builder, windowReversal):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(windowReversal), 0)
+
+def StablehloConvolutionOptionsStartWindowReversalVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def StablehloConvolutionOptionsAddInputBatchDimension(builder, inputBatchDimension):
+    builder.PrependInt64Slot(5, inputBatchDimension, 0)
+
+def StablehloConvolutionOptionsAddInputFeatureDimension(builder, inputFeatureDimension):
+    builder.PrependInt64Slot(6, inputFeatureDimension, 0)
+
+def StablehloConvolutionOptionsAddInputSpatialDimensions(builder, inputSpatialDimensions):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(inputSpatialDimensions), 0)
+
+def StablehloConvolutionOptionsStartInputSpatialDimensionsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddKernelInputFeatureDimension(builder, kernelInputFeatureDimension):
+    builder.PrependInt64Slot(8, kernelInputFeatureDimension, 0)
+
+def StablehloConvolutionOptionsAddKernelOutputFeatureDimension(builder, kernelOutputFeatureDimension):
+    builder.PrependInt64Slot(9, kernelOutputFeatureDimension, 0)
+
+def StablehloConvolutionOptionsAddKernelSpatialDimensions(builder, kernelSpatialDimensions):
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(kernelSpatialDimensions), 0)
+
+def StablehloConvolutionOptionsStartKernelSpatialDimensionsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddOutputBatchDimension(builder, outputBatchDimension):
+    builder.PrependInt64Slot(11, outputBatchDimension, 0)
+
+def StablehloConvolutionOptionsAddOutputFeatureDimension(builder, outputFeatureDimension):
+    builder.PrependInt64Slot(12, outputFeatureDimension, 0)
+
+def StablehloConvolutionOptionsAddOutputSpatialDimensions(builder, outputSpatialDimensions):
+    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(outputSpatialDimensions), 0)
+
+def StablehloConvolutionOptionsStartOutputSpatialDimensionsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddFeatureGroupCount(builder, featureGroupCount):
+    builder.PrependInt64Slot(14, featureGroupCount, 0)
+
+def StablehloConvolutionOptionsAddBatchGroupCount(builder, batchGroupCount):
+    builder.PrependInt64Slot(15, batchGroupCount, 0)
+
+def StablehloConvolutionOptionsAddPrecisionConfig(builder, precisionConfig):
+    builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(precisionConfig), 0)
+
+def StablehloConvolutionOptionsStartPrecisionConfigVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StablehloConvolutionOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloConvolutionOptionsT(object):
+
+    # StablehloConvolutionOptionsT
+    def __init__(self):
+        self.windowStrides = None  # type: List[int]
+        self.padding = None  # type: List[int]
+        self.lhsDilation = None  # type: List[int]
+        self.rhsDilation = None  # type: List[int]
+        self.windowReversal = None  # type: List[bool]
+        self.inputBatchDimension = 0  # type: int
+        self.inputFeatureDimension = 0  # type: int
+        self.inputSpatialDimensions = None  # type: List[int]
+        self.kernelInputFeatureDimension = 0  # type: int
+        self.kernelOutputFeatureDimension = 0  # type: int
+        self.kernelSpatialDimensions = None  # type: List[int]
+        self.outputBatchDimension = 0  # type: int
+        self.outputFeatureDimension = 0  # type: int
+        self.outputSpatialDimensions = None  # type: List[int]
+        self.featureGroupCount = 0  # type: int
+        self.batchGroupCount = 0  # type: int
+        self.precisionConfig = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloConvolutionOptions = StablehloConvolutionOptions()
+        stablehloConvolutionOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloConvolutionOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloConvolutionOptions):
+        x = StablehloConvolutionOptionsT()
+        x._UnPack(stablehloConvolutionOptions)
+        return x
+
+    # StablehloConvolutionOptionsT
+    def _UnPack(self, stablehloConvolutionOptions):
+        if stablehloConvolutionOptions is None:
+            return
+        if not stablehloConvolutionOptions.WindowStridesIsNone():
+            if np is None:
+                self.windowStrides = []
+                for i in range(stablehloConvolutionOptions.WindowStridesLength()):
+                    self.windowStrides.append(stablehloConvolutionOptions.WindowStrides(i))
+            else:
+                self.windowStrides = stablehloConvolutionOptions.WindowStridesAsNumpy()
+        if not stablehloConvolutionOptions.PaddingIsNone():
+            if np is None:
+                self.padding = []
+                for i in range(stablehloConvolutionOptions.PaddingLength()):
+                    self.padding.append(stablehloConvolutionOptions.Padding(i))
+            else:
+                self.padding = stablehloConvolutionOptions.PaddingAsNumpy()
+        if not stablehloConvolutionOptions.LhsDilationIsNone():
+            if np is None:
+                self.lhsDilation = []
+                for i in range(stablehloConvolutionOptions.LhsDilationLength()):
+                    self.lhsDilation.append(stablehloConvolutionOptions.LhsDilation(i))
+            else:
+                self.lhsDilation = stablehloConvolutionOptions.LhsDilationAsNumpy()
+        if not stablehloConvolutionOptions.RhsDilationIsNone():
+            if np is None:
+                self.rhsDilation = []
+                for i in range(stablehloConvolutionOptions.RhsDilationLength()):
+                    self.rhsDilation.append(stablehloConvolutionOptions.RhsDilation(i))
+            else:
+                self.rhsDilation = stablehloConvolutionOptions.RhsDilationAsNumpy()
+        if not stablehloConvolutionOptions.WindowReversalIsNone():
+            if np is None:
+                self.windowReversal = []
+                for i in range(stablehloConvolutionOptions.WindowReversalLength()):
+                    self.windowReversal.append(stablehloConvolutionOptions.WindowReversal(i))
+            else:
+                self.windowReversal = stablehloConvolutionOptions.WindowReversalAsNumpy()
+        self.inputBatchDimension = stablehloConvolutionOptions.InputBatchDimension()
+        self.inputFeatureDimension = stablehloConvolutionOptions.InputFeatureDimension()
+        if not stablehloConvolutionOptions.InputSpatialDimensionsIsNone():
+            if np is None:
+                self.inputSpatialDimensions = []
+                for i in range(stablehloConvolutionOptions.InputSpatialDimensionsLength()):
+                    self.inputSpatialDimensions.append(stablehloConvolutionOptions.InputSpatialDimensions(i))
+            else:
+                self.inputSpatialDimensions = stablehloConvolutionOptions.InputSpatialDimensionsAsNumpy()
+        self.kernelInputFeatureDimension = stablehloConvolutionOptions.KernelInputFeatureDimension()
+        self.kernelOutputFeatureDimension = stablehloConvolutionOptions.KernelOutputFeatureDimension()
+        if not stablehloConvolutionOptions.KernelSpatialDimensionsIsNone():
+            if np is None:
+                self.kernelSpatialDimensions = []
+                for i in range(stablehloConvolutionOptions.KernelSpatialDimensionsLength()):
+                    self.kernelSpatialDimensions.append(stablehloConvolutionOptions.KernelSpatialDimensions(i))
+            else:
+                self.kernelSpatialDimensions = stablehloConvolutionOptions.KernelSpatialDimensionsAsNumpy()
+        self.outputBatchDimension = stablehloConvolutionOptions.OutputBatchDimension()
+        self.outputFeatureDimension = stablehloConvolutionOptions.OutputFeatureDimension()
+        if not stablehloConvolutionOptions.OutputSpatialDimensionsIsNone():
+            if np is None:
+                self.outputSpatialDimensions = []
+                for i in range(stablehloConvolutionOptions.OutputSpatialDimensionsLength()):
+                    self.outputSpatialDimensions.append(stablehloConvolutionOptions.OutputSpatialDimensions(i))
+            else:
+                self.outputSpatialDimensions = stablehloConvolutionOptions.OutputSpatialDimensionsAsNumpy()
+        self.featureGroupCount = stablehloConvolutionOptions.FeatureGroupCount()
+        self.batchGroupCount = stablehloConvolutionOptions.BatchGroupCount()
+        if not stablehloConvolutionOptions.PrecisionConfigIsNone():
+            if np is None:
+                self.precisionConfig = []
+                for i in range(stablehloConvolutionOptions.PrecisionConfigLength()):
+                    self.precisionConfig.append(stablehloConvolutionOptions.PrecisionConfig(i))
+            else:
+                self.precisionConfig = stablehloConvolutionOptions.PrecisionConfigAsNumpy()
+
+    # StablehloConvolutionOptionsT
+    def Pack(self, builder):
+        if self.windowStrides is not None:
+            if np is not None and type(self.windowStrides) is np.ndarray:
+                windowStrides = builder.CreateNumpyVector(self.windowStrides)
+            else:
+                StablehloConvolutionOptionsStartWindowStridesVector(builder, len(self.windowStrides))
+                for i in reversed(range(len(self.windowStrides))):
+                    builder.PrependInt64(self.windowStrides[i])
+                windowStrides = builder.EndVector()
+        if self.padding is not None:
+            if np is not None and type(self.padding) is np.ndarray:
+                padding = builder.CreateNumpyVector(self.padding)
+            else:
+                StablehloConvolutionOptionsStartPaddingVector(builder, len(self.padding))
+                for i in reversed(range(len(self.padding))):
+                    builder.PrependInt64(self.padding[i])
+                padding = builder.EndVector()
+        if self.lhsDilation is not None:
+            if np is not None and type(self.lhsDilation) is np.ndarray:
+                lhsDilation = builder.CreateNumpyVector(self.lhsDilation)
+            else:
+                StablehloConvolutionOptionsStartLhsDilationVector(builder, len(self.lhsDilation))
+                for i in reversed(range(len(self.lhsDilation))):
+                    builder.PrependInt64(self.lhsDilation[i])
+                lhsDilation = builder.EndVector()
+        if self.rhsDilation is not None:
+            if np is not None and type(self.rhsDilation) is np.ndarray:
+                rhsDilation = builder.CreateNumpyVector(self.rhsDilation)
+            else:
+                StablehloConvolutionOptionsStartRhsDilationVector(builder, len(self.rhsDilation))
+                for i in reversed(range(len(self.rhsDilation))):
+                    builder.PrependInt64(self.rhsDilation[i])
+                rhsDilation = builder.EndVector()
+        if self.windowReversal is not None:
+            if np is not None and type(self.windowReversal) is np.ndarray:
+                windowReversal = builder.CreateNumpyVector(self.windowReversal)
+            else:
+                StablehloConvolutionOptionsStartWindowReversalVector(builder, len(self.windowReversal))
+                for i in reversed(range(len(self.windowReversal))):
+                    builder.PrependBool(self.windowReversal[i])
+                windowReversal = builder.EndVector()
+        if self.inputSpatialDimensions is not None:
+            if np is not None and type(self.inputSpatialDimensions) is np.ndarray:
+                inputSpatialDimensions = builder.CreateNumpyVector(self.inputSpatialDimensions)
+            else:
+                StablehloConvolutionOptionsStartInputSpatialDimensionsVector(builder, len(self.inputSpatialDimensions))
+                for i in reversed(range(len(self.inputSpatialDimensions))):
+                    builder.PrependInt64(self.inputSpatialDimensions[i])
+                inputSpatialDimensions = builder.EndVector()
+        if self.kernelSpatialDimensions is not None:
+            if np is not None and type(self.kernelSpatialDimensions) is np.ndarray:
+                kernelSpatialDimensions = builder.CreateNumpyVector(self.kernelSpatialDimensions)
+            else:
+                StablehloConvolutionOptionsStartKernelSpatialDimensionsVector(builder, len(self.kernelSpatialDimensions))
+                for i in reversed(range(len(self.kernelSpatialDimensions))):
+                    builder.PrependInt64(self.kernelSpatialDimensions[i])
+                kernelSpatialDimensions = builder.EndVector()
+        if self.outputSpatialDimensions is not None:
+            if np is not None and type(self.outputSpatialDimensions) is np.ndarray:
+                outputSpatialDimensions = builder.CreateNumpyVector(self.outputSpatialDimensions)
+            else:
+                StablehloConvolutionOptionsStartOutputSpatialDimensionsVector(builder, len(self.outputSpatialDimensions))
+                for i in reversed(range(len(self.outputSpatialDimensions))):
+                    builder.PrependInt64(self.outputSpatialDimensions[i])
+                outputSpatialDimensions = builder.EndVector()
+        if self.precisionConfig is not None:
+            if np is not None and type(self.precisionConfig) is np.ndarray:
+                precisionConfig = builder.CreateNumpyVector(self.precisionConfig)
+            else:
+                StablehloConvolutionOptionsStartPrecisionConfigVector(builder, len(self.precisionConfig))
+                for i in reversed(range(len(self.precisionConfig))):
+                    builder.PrependUint32(self.precisionConfig[i])
+                precisionConfig = builder.EndVector()
+        StablehloConvolutionOptionsStart(builder)
+        if self.windowStrides is not None:
+            StablehloConvolutionOptionsAddWindowStrides(builder, windowStrides)
+        if self.padding is not None:
+            StablehloConvolutionOptionsAddPadding(builder, padding)
+        if self.lhsDilation is not None:
+            StablehloConvolutionOptionsAddLhsDilation(builder, lhsDilation)
+        if self.rhsDilation is not None:
+            StablehloConvolutionOptionsAddRhsDilation(builder, rhsDilation)
+        if self.windowReversal is not None:
+            StablehloConvolutionOptionsAddWindowReversal(builder, windowReversal)
+        StablehloConvolutionOptionsAddInputBatchDimension(builder, self.inputBatchDimension)
+        StablehloConvolutionOptionsAddInputFeatureDimension(builder, self.inputFeatureDimension)
+        if self.inputSpatialDimensions is not None:
+            StablehloConvolutionOptionsAddInputSpatialDimensions(builder, inputSpatialDimensions)
+        StablehloConvolutionOptionsAddKernelInputFeatureDimension(builder, self.kernelInputFeatureDimension)
+        StablehloConvolutionOptionsAddKernelOutputFeatureDimension(builder, self.kernelOutputFeatureDimension)
+        if self.kernelSpatialDimensions is not None:
+            StablehloConvolutionOptionsAddKernelSpatialDimensions(builder, kernelSpatialDimensions)
+        StablehloConvolutionOptionsAddOutputBatchDimension(builder, self.outputBatchDimension)
+        StablehloConvolutionOptionsAddOutputFeatureDimension(builder, self.outputFeatureDimension)
+        if self.outputSpatialDimensions is not None:
+            StablehloConvolutionOptionsAddOutputSpatialDimensions(builder, outputSpatialDimensions)
+        StablehloConvolutionOptionsAddFeatureGroupCount(builder, self.featureGroupCount)
+        StablehloConvolutionOptionsAddBatchGroupCount(builder, self.batchGroupCount)
+        if self.precisionConfig is not None:
+            StablehloConvolutionOptionsAddPrecisionConfig(builder, precisionConfig)
+        stablehloConvolutionOptions = StablehloConvolutionOptionsEnd(builder)
+        return stablehloConvolutionOptions
+
+
+class StablehloScatterOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloScatterOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloScatterOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloScatterOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloScatterOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StablehloScatterOptions
+    def IndicesAreSorted(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # StablehloScatterOptions
+    def UpdateWindowDims(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloScatterOptions
+    def UpdateWindowDimsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloScatterOptions
+    def UpdateWindowDimsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloScatterOptions
+    def UpdateWindowDimsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # StablehloScatterOptions
+    def InsertedWindowDims(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloScatterOptions
+    def InsertedWindowDimsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloScatterOptions
+    def InsertedWindowDimsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloScatterOptions
+    def InsertedWindowDimsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # StablehloScatterOptions
+    def ScatterDimsToOperandDims(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # StablehloScatterOptions
+    def ScatterDimsToOperandDimsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+        return 0
+
+    # StablehloScatterOptions
+    def ScatterDimsToOperandDimsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StablehloScatterOptions
+    def ScatterDimsToOperandDimsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # StablehloScatterOptions
+    def IndexVectorDim(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # StablehloScatterOptions
+    def UniqueIndices(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # StablehloScatterOptions
+    def UpdateComputationSubgraphIndex(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def StablehloScatterOptionsStart(builder):
+    builder.StartObject(7)
+
+def StablehloScatterOptionsAddIndicesAreSorted(builder, indicesAreSorted):
+    builder.PrependBoolSlot(0, indicesAreSorted, 0)
+
+def StablehloScatterOptionsAddUpdateWindowDims(builder, updateWindowDims):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(updateWindowDims), 0)
+
+def StablehloScatterOptionsStartUpdateWindowDimsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloScatterOptionsAddInsertedWindowDims(builder, insertedWindowDims):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(insertedWindowDims), 0)
+
+def StablehloScatterOptionsStartInsertedWindowDimsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloScatterOptionsAddScatterDimsToOperandDims(builder, scatterDimsToOperandDims):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(scatterDimsToOperandDims), 0)
+
+def StablehloScatterOptionsStartScatterDimsToOperandDimsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StablehloScatterOptionsAddIndexVectorDim(builder, indexVectorDim):
+    builder.PrependInt64Slot(4, indexVectorDim, 0)
+
+def StablehloScatterOptionsAddUniqueIndices(builder, uniqueIndices):
+    builder.PrependBoolSlot(5, uniqueIndices, 0)
+
+def StablehloScatterOptionsAddUpdateComputationSubgraphIndex(builder, updateComputationSubgraphIndex):
+    builder.PrependInt32Slot(6, updateComputationSubgraphIndex, 0)
+
+def StablehloScatterOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class StablehloScatterOptionsT(object):
+
+    # StablehloScatterOptionsT
+    def __init__(self):
+        self.indicesAreSorted = False  # type: bool
+        self.updateWindowDims = None  # type: List[int]
+        self.insertedWindowDims = None  # type: List[int]
+        self.scatterDimsToOperandDims = None  # type: List[int]
+        self.indexVectorDim = 0  # type: int
+        self.uniqueIndices = False  # type: bool
+        self.updateComputationSubgraphIndex = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stablehloScatterOptions = StablehloScatterOptions()
+        stablehloScatterOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloScatterOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, stablehloScatterOptions):
+        x = StablehloScatterOptionsT()
+        x._UnPack(stablehloScatterOptions)
+        return x
+
+    # StablehloScatterOptionsT
+    def _UnPack(self, stablehloScatterOptions):
+        if stablehloScatterOptions is None:
+            return
+        self.indicesAreSorted = stablehloScatterOptions.IndicesAreSorted()
+        if not stablehloScatterOptions.UpdateWindowDimsIsNone():
+            if np is None:
+                self.updateWindowDims = []
+                for i in range(stablehloScatterOptions.UpdateWindowDimsLength()):
+                    self.updateWindowDims.append(stablehloScatterOptions.UpdateWindowDims(i))
+            else:
+                self.updateWindowDims = stablehloScatterOptions.UpdateWindowDimsAsNumpy()
+        if not stablehloScatterOptions.InsertedWindowDimsIsNone():
+            if np is None:
+                self.insertedWindowDims = []
+                for i in range(stablehloScatterOptions.InsertedWindowDimsLength()):
+                    self.insertedWindowDims.append(stablehloScatterOptions.InsertedWindowDims(i))
+            else:
+                self.insertedWindowDims = stablehloScatterOptions.InsertedWindowDimsAsNumpy()
+        if not stablehloScatterOptions.ScatterDimsToOperandDimsIsNone():
+            if np is None:
+                self.scatterDimsToOperandDims = []
+                for i in range(stablehloScatterOptions.ScatterDimsToOperandDimsLength()):
+                    self.scatterDimsToOperandDims.append(stablehloScatterOptions.ScatterDimsToOperandDims(i))
+            else:
+                self.scatterDimsToOperandDims = stablehloScatterOptions.ScatterDimsToOperandDimsAsNumpy()
+        self.indexVectorDim = stablehloScatterOptions.IndexVectorDim()
+        self.uniqueIndices = stablehloScatterOptions.UniqueIndices()
+        self.updateComputationSubgraphIndex = stablehloScatterOptions.UpdateComputationSubgraphIndex()
+
+    # StablehloScatterOptionsT
+    def Pack(self, builder):
+        if self.updateWindowDims is not None:
+            if np is not None and type(self.updateWindowDims) is np.ndarray:
+                updateWindowDims = builder.CreateNumpyVector(self.updateWindowDims)
+            else:
+                StablehloScatterOptionsStartUpdateWindowDimsVector(builder, len(self.updateWindowDims))
+                for i in reversed(range(len(self.updateWindowDims))):
+                    builder.PrependInt64(self.updateWindowDims[i])
+                updateWindowDims = builder.EndVector()
+        if self.insertedWindowDims is not None:
+            if np is not None and type(self.insertedWindowDims) is np.ndarray:
+                insertedWindowDims = builder.CreateNumpyVector(self.insertedWindowDims)
+            else:
+                StablehloScatterOptionsStartInsertedWindowDimsVector(builder, len(self.insertedWindowDims))
+                for i in reversed(range(len(self.insertedWindowDims))):
+                    builder.PrependInt64(self.insertedWindowDims[i])
+                insertedWindowDims = builder.EndVector()
+        if self.scatterDimsToOperandDims is not None:
+            if np is not None and type(self.scatterDimsToOperandDims) is np.ndarray:
+                scatterDimsToOperandDims = builder.CreateNumpyVector(self.scatterDimsToOperandDims)
+            else:
+                StablehloScatterOptionsStartScatterDimsToOperandDimsVector(builder, len(self.scatterDimsToOperandDims))
+                for i in reversed(range(len(self.scatterDimsToOperandDims))):
+                    builder.PrependInt64(self.scatterDimsToOperandDims[i])
+                scatterDimsToOperandDims = builder.EndVector()
+        StablehloScatterOptionsStart(builder)
+        StablehloScatterOptionsAddIndicesAreSorted(builder, self.indicesAreSorted)
+        if self.updateWindowDims is not None:
+            StablehloScatterOptionsAddUpdateWindowDims(builder, updateWindowDims)
+        if self.insertedWindowDims is not None:
+            StablehloScatterOptionsAddInsertedWindowDims(builder, insertedWindowDims)
+        if self.scatterDimsToOperandDims is not None:
+            StablehloScatterOptionsAddScatterDimsToOperandDims(builder, scatterDimsToOperandDims)
+        StablehloScatterOptionsAddIndexVectorDim(builder, self.indexVectorDim)
+        StablehloScatterOptionsAddUniqueIndices(builder, self.uniqueIndices)
+        StablehloScatterOptionsAddUpdateComputationSubgraphIndex(builder, self.updateComputationSubgraphIndex)
+        stablehloScatterOptions = StablehloScatterOptionsEnd(builder)
+        return stablehloScatterOptions
+
+
+class StablehloRngBitGeneratorOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StablehloRngBitGeneratorOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStablehloRngBitGeneratorOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StablehloRngBitGeneratorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # StablehloRngBitGeneratorOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
 
-def TensorAddHasRank(builder, hasRank):
-    builder.PrependBoolSlot(8, hasRank, 0)
+    # StablehloRngBitGeneratorOptions
+    def Algorithm(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
 
-def TensorAddVariantTensors(builder, variantTensors):
-    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(variantTensors), 0)
+def StablehloRngBitGeneratorOptionsStart(builder):
+    builder.StartObject(1)
 
-def TensorStartVariantTensorsVector(builder, numElems):
-    return builder.StartVector(4, numElems, 4)
+def StablehloRngBitGeneratorOptionsAddAlgorithm(builder, algorithm):
+    builder.PrependInt8Slot(0, algorithm, 0)
 
-def TensorEnd(builder):
+def StablehloRngBitGeneratorOptionsEnd(builder):
     return builder.EndObject()
 
 
-try:
-    from typing import List, Optional
-except:
-    pass
 
-class TensorT(object):
+class StablehloRngBitGeneratorOptionsT(object):
 
-    # TensorT
+    # StablehloRngBitGeneratorOptionsT
     def __init__(self):
-        self.shape = None  # type: List[int]
-        self.type = 0  # type: int
-        self.buffer = 0  # type: int
-        self.name = None  # type: str
-        self.quantization = None  # type: Optional[QuantizationParametersT]
-        self.isVariable = False  # type: bool
-        self.sparsity = None  # type: Optional[SparsityParametersT]
-        self.shapeSignature = None  # type: List[int]
-        self.hasRank = False  # type: bool
-        self.variantTensors = None  # type: List[VariantSubTypeT]
+        self.algorithm = 0  # type: int
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
-        tensor = Tensor()
-        tensor.Init(buf, pos)
-        return cls.InitFromObj(tensor)
+        stablehloRngBitGeneratorOptions = StablehloRngBitGeneratorOptions()
+        stablehloRngBitGeneratorOptions.Init(buf, pos)
+        return cls.InitFromObj(stablehloRngBitGeneratorOptions)
 
     @classmethod
     def InitFromPackedBuf(cls, buf, pos=0):
@@ -2211,98 +5973,23 @@ class TensorT(object):
         return cls.InitFromBuf(buf, pos+n)
 
     @classmethod
-    def InitFromObj(cls, tensor):
-        x = TensorT()
-        x._UnPack(tensor)
+    def InitFromObj(cls, stablehloRngBitGeneratorOptions):
+        x = StablehloRngBitGeneratorOptionsT()
+        x._UnPack(stablehloRngBitGeneratorOptions)
         return x
 
-    # TensorT
-    def _UnPack(self, tensor):
-        if tensor is None:
+    # StablehloRngBitGeneratorOptionsT
+    def _UnPack(self, stablehloRngBitGeneratorOptions):
+        if stablehloRngBitGeneratorOptions is None:
             return
-        if not tensor.ShapeIsNone():
-            if np is None:
-                self.shape = []
-                for i in range(tensor.ShapeLength()):
-                    self.shape.append(tensor.Shape(i))
-            else:
-                self.shape = tensor.ShapeAsNumpy()
-        self.type = tensor.Type()
-        self.buffer = tensor.Buffer()
-        self.name = tensor.Name()
-        if tensor.Quantization() is not None:
-            self.quantization = QuantizationParametersT.InitFromObj(tensor.Quantization())
-        self.isVariable = tensor.IsVariable()
-        if tensor.Sparsity() is not None:
-            self.sparsity = SparsityParametersT.InitFromObj(tensor.Sparsity())
-        if not tensor.ShapeSignatureIsNone():
-            if np is None:
-                self.shapeSignature = []
-                for i in range(tensor.ShapeSignatureLength()):
-                    self.shapeSignature.append(tensor.ShapeSignature(i))
-            else:
-                self.shapeSignature = tensor.ShapeSignatureAsNumpy()
-        self.hasRank = tensor.HasRank()
-        if not tensor.VariantTensorsIsNone():
-            self.variantTensors = []
-            for i in range(tensor.VariantTensorsLength()):
-                if tensor.VariantTensors(i) is None:
-                    self.variantTensors.append(None)
-                else:
-                    variantSubType_ = VariantSubTypeT.InitFromObj(tensor.VariantTensors(i))
-                    self.variantTensors.append(variantSubType_)
+        self.algorithm = stablehloRngBitGeneratorOptions.Algorithm()
 
-    # TensorT
+    # StablehloRngBitGeneratorOptionsT
     def Pack(self, builder):
-        if self.shape is not None:
-            if np is not None and type(self.shape) is np.ndarray:
-                shape = builder.CreateNumpyVector(self.shape)
-            else:
-                TensorStartShapeVector(builder, len(self.shape))
-                for i in reversed(range(len(self.shape))):
-                    builder.PrependInt32(self.shape[i])
-                shape = builder.EndVector()
-        if self.name is not None:
-            name = builder.CreateString(self.name)
-        if self.quantization is not None:
-            quantization = self.quantization.Pack(builder)
-        if self.sparsity is not None:
-            sparsity = self.sparsity.Pack(builder)
-        if self.shapeSignature is not None:
-            if np is not None and type(self.shapeSignature) is np.ndarray:
-                shapeSignature = builder.CreateNumpyVector(self.shapeSignature)
-            else:
-                TensorStartShapeSignatureVector(builder, len(self.shapeSignature))
-                for i in reversed(range(len(self.shapeSignature))):
-                    builder.PrependInt32(self.shapeSignature[i])
-                shapeSignature = builder.EndVector()
-        if self.variantTensors is not None:
-            variantTensorslist = []
-            for i in range(len(self.variantTensors)):
-                variantTensorslist.append(self.variantTensors[i].Pack(builder))
-            TensorStartVariantTensorsVector(builder, len(self.variantTensors))
-            for i in reversed(range(len(self.variantTensors))):
-                builder.PrependUOffsetTRelative(variantTensorslist[i])
-            variantTensors = builder.EndVector()
-        TensorStart(builder)
-        if self.shape is not None:
-            TensorAddShape(builder, shape)
-        TensorAddType(builder, self.type)
-        TensorAddBuffer(builder, self.buffer)
-        if self.name is not None:
-            TensorAddName(builder, name)
-        if self.quantization is not None:
-            TensorAddQuantization(builder, quantization)
-        TensorAddIsVariable(builder, self.isVariable)
-        if self.sparsity is not None:
-            TensorAddSparsity(builder, sparsity)
-        if self.shapeSignature is not None:
-            TensorAddShapeSignature(builder, shapeSignature)
-        TensorAddHasRank(builder, self.hasRank)
-        if self.variantTensors is not None:
-            TensorAddVariantTensors(builder, variantTensors)
-        tensor = TensorEnd(builder)
-        return tensor
+        StablehloRngBitGeneratorOptionsStart(builder)
+        StablehloRngBitGeneratorOptionsAddAlgorithm(builder, self.algorithm)
+        stablehloRngBitGeneratorOptions = StablehloRngBitGeneratorOptionsEnd(builder)
+        return stablehloRngBitGeneratorOptions
 
 
 class Conv2DOptions(object):
@@ -2369,8 +6056,15 @@ class Conv2DOptions(object):
             return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
         return 1
 
+    # Conv2DOptions
+    def QuantizedBiasType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
 def Conv2DOptionsStart(builder):
-    builder.StartObject(6)
+    builder.StartObject(7)
 
 def Conv2DOptionsAddPadding(builder, padding):
     builder.PrependInt8Slot(0, padding, 0)
@@ -2390,6 +6084,9 @@ def Conv2DOptionsAddDilationWFactor(builder, dilationWFactor):
 def Conv2DOptionsAddDilationHFactor(builder, dilationHFactor):
     builder.PrependInt32Slot(5, dilationHFactor, 1)
 
+def Conv2DOptionsAddQuantizedBiasType(builder, quantizedBiasType):
+    builder.PrependInt8Slot(6, quantizedBiasType, 0)
+
 def Conv2DOptionsEnd(builder):
     return builder.EndObject()
 
@@ -2405,6 +6102,7 @@ class Conv2DOptionsT(object):
         self.fusedActivationFunction = 0  # type: int
         self.dilationWFactor = 1  # type: int
         self.dilationHFactor = 1  # type: int
+        self.quantizedBiasType = 0  # type: int
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
@@ -2433,6 +6131,7 @@ class Conv2DOptionsT(object):
         self.fusedActivationFunction = conv2Doptions.FusedActivationFunction()
         self.dilationWFactor = conv2Doptions.DilationWFactor()
         self.dilationHFactor = conv2Doptions.DilationHFactor()
+        self.quantizedBiasType = conv2Doptions.QuantizedBiasType()
 
     # Conv2DOptionsT
     def Pack(self, builder):
@@ -2443,6 +6142,7 @@ class Conv2DOptionsT(object):
         Conv2DOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
         Conv2DOptionsAddDilationWFactor(builder, self.dilationWFactor)
         Conv2DOptionsAddDilationHFactor(builder, self.dilationHFactor)
+        Conv2DOptionsAddQuantizedBiasType(builder, self.quantizedBiasType)
         conv2Doptions = Conv2DOptionsEnd(builder)
         return conv2Doptions
 
@@ -3634,8 +7334,15 @@ class FullyConnectedOptions(object):
             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
         return False
 
+    # FullyConnectedOptions
+    def QuantizedBiasType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
 def FullyConnectedOptionsStart(builder):
-    builder.StartObject(4)
+    builder.StartObject(5)
 
 def FullyConnectedOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
     builder.PrependInt8Slot(0, fusedActivationFunction, 0)
@@ -3649,6 +7356,9 @@ def FullyConnectedOptionsAddKeepNumDims(builder, keepNumDims):
 def FullyConnectedOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs):
     builder.PrependBoolSlot(3, asymmetricQuantizeInputs, 0)
 
+def FullyConnectedOptionsAddQuantizedBiasType(builder, quantizedBiasType):
+    builder.PrependInt8Slot(4, quantizedBiasType, 0)
+
 def FullyConnectedOptionsEnd(builder):
     return builder.EndObject()
 
@@ -3662,6 +7372,7 @@ class FullyConnectedOptionsT(object):
         self.weightsFormat = 0  # type: int
         self.keepNumDims = False  # type: bool
         self.asymmetricQuantizeInputs = False  # type: bool
+        self.quantizedBiasType = 0  # type: int
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
@@ -3688,6 +7399,7 @@ class FullyConnectedOptionsT(object):
         self.weightsFormat = fullyConnectedOptions.WeightsFormat()
         self.keepNumDims = fullyConnectedOptions.KeepNumDims()
         self.asymmetricQuantizeInputs = fullyConnectedOptions.AsymmetricQuantizeInputs()
+        self.quantizedBiasType = fullyConnectedOptions.QuantizedBiasType()
 
     # FullyConnectedOptionsT
     def Pack(self, builder):
@@ -3696,6 +7408,7 @@ class FullyConnectedOptionsT(object):
         FullyConnectedOptionsAddWeightsFormat(builder, self.weightsFormat)
         FullyConnectedOptionsAddKeepNumDims(builder, self.keepNumDims)
         FullyConnectedOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs)
+        FullyConnectedOptionsAddQuantizedBiasType(builder, self.quantizedBiasType)
         fullyConnectedOptions = FullyConnectedOptionsEnd(builder)
         return fullyConnectedOptions
 
@@ -7628,8 +11341,15 @@ class TransposeConvOptions(object):
             return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
         return 0
 
+    # TransposeConvOptions
+    def QuantizedBiasType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
 def TransposeConvOptionsStart(builder):
-    builder.StartObject(4)
+    builder.StartObject(5)
 
 def TransposeConvOptionsAddPadding(builder, padding):
     builder.PrependInt8Slot(0, padding, 0)
@@ -7643,6 +11363,9 @@ def TransposeConvOptionsAddStrideH(builder, strideH):
 def TransposeConvOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
     builder.PrependInt8Slot(3, fusedActivationFunction, 0)
 
+def TransposeConvOptionsAddQuantizedBiasType(builder, quantizedBiasType):
+    builder.PrependInt8Slot(4, quantizedBiasType, 0)
+
 def TransposeConvOptionsEnd(builder):
     return builder.EndObject()
 
@@ -7656,6 +11379,7 @@ class TransposeConvOptionsT(object):
         self.strideW = 0  # type: int
         self.strideH = 0  # type: int
         self.fusedActivationFunction = 0  # type: int
+        self.quantizedBiasType = 0  # type: int
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
@@ -7682,6 +11406,7 @@ class TransposeConvOptionsT(object):
         self.strideW = transposeConvOptions.StrideW()
         self.strideH = transposeConvOptions.StrideH()
         self.fusedActivationFunction = transposeConvOptions.FusedActivationFunction()
+        self.quantizedBiasType = transposeConvOptions.QuantizedBiasType()
 
     # TransposeConvOptionsT
     def Pack(self, builder):
@@ -7690,6 +11415,7 @@ class TransposeConvOptionsT(object):
         TransposeConvOptionsAddStrideW(builder, self.strideW)
         TransposeConvOptionsAddStrideH(builder, self.strideH)
         TransposeConvOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
+        TransposeConvOptionsAddQuantizedBiasType(builder, self.quantizedBiasType)
         transposeConvOptions = TransposeConvOptionsEnd(builder)
         return transposeConvOptions
 
@@ -12532,6 +16258,148 @@ class RightShiftOptionsT(object):
         return rightShiftOptions
 
 
+class DilateOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = DilateOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsDilateOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def DilateOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # DilateOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def DilateOptionsStart(builder):
+    builder.StartObject(0)
+
+def DilateOptionsEnd(builder):
+    return builder.EndObject()
+
+
+
+class DilateOptionsT(object):
+
+    # DilateOptionsT
+    def __init__(self):
+        pass
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        dilateOptions = DilateOptions()
+        dilateOptions.Init(buf, pos)
+        return cls.InitFromObj(dilateOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, dilateOptions):
+        x = DilateOptionsT()
+        x._UnPack(dilateOptions)
+        return x
+
+    # DilateOptionsT
+    def _UnPack(self, dilateOptions):
+        if dilateOptions is None:
+            return
+
+    # DilateOptionsT
+    def Pack(self, builder):
+        DilateOptionsStart(builder)
+        dilateOptions = DilateOptionsEnd(builder)
+        return dilateOptions
+
+
+class ReduceWindowOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ReduceWindowOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsReduceWindowOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ReduceWindowOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # ReduceWindowOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ReduceWindowOptions
+    def ReduceFunction(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def ReduceWindowOptionsStart(builder):
+    builder.StartObject(1)
+
+def ReduceWindowOptionsAddReduceFunction(builder, reduceFunction):
+    builder.PrependInt32Slot(0, reduceFunction, 0)
+
+def ReduceWindowOptionsEnd(builder):
+    return builder.EndObject()
+
+
+
+class ReduceWindowOptionsT(object):
+
+    # ReduceWindowOptionsT
+    def __init__(self):
+        self.reduceFunction = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        reduceWindowOptions = ReduceWindowOptions()
+        reduceWindowOptions.Init(buf, pos)
+        return cls.InitFromObj(reduceWindowOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, reduceWindowOptions):
+        x = ReduceWindowOptionsT()
+        x._UnPack(reduceWindowOptions)
+        return x
+
+    # ReduceWindowOptionsT
+    def _UnPack(self, reduceWindowOptions):
+        if reduceWindowOptions is None:
+            return
+        self.reduceFunction = reduceWindowOptions.ReduceFunction()
+
+    # ReduceWindowOptionsT
+    def Pack(self, builder):
+        ReduceWindowOptionsStart(builder)
+        ReduceWindowOptionsAddReduceFunction(builder, self.reduceFunction)
+        reduceWindowOptions = ReduceWindowOptionsEnd(builder)
+        return reduceWindowOptions
+
+
 class OperatorCode(object):
     __slots__ = ['_tab']
 
@@ -12853,8 +16721,25 @@ class Operator(object):
             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
         return 0
 
+    # Operator
+    def BuiltinOptions2Type(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Operator
+    def BuiltinOptions2(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
 def OperatorStart(builder):
-    builder.StartObject(11)
+    builder.StartObject(13)
 
 def OperatorAddOpcodeIndex(builder, opcodeIndex):
     builder.PrependUint32Slot(0, opcodeIndex, 0)
@@ -12904,6 +16789,12 @@ def OperatorAddLargeCustomOptionsOffset(builder, largeCustomOptionsOffset):
 def OperatorAddLargeCustomOptionsSize(builder, largeCustomOptionsSize):
     builder.PrependUint64Slot(10, largeCustomOptionsSize, 0)
 
+def OperatorAddBuiltinOptions2Type(builder, builtinOptions2Type):
+    builder.PrependUint8Slot(11, builtinOptions2Type, 0)
+
+def OperatorAddBuiltinOptions2(builder, builtinOptions2):
+    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(builtinOptions2), 0)
+
 def OperatorEnd(builder):
     return builder.EndObject()
 
@@ -12928,6 +16819,8 @@ class OperatorT(object):
         self.intermediates = None  # type: List[int]
         self.largeCustomOptionsOffset = 0  # type: int
         self.largeCustomOptionsSize = 0  # type: int
+        self.builtinOptions2Type = 0  # type: int
+        self.builtinOptions2 = None  # type: Union[None, StablehloConcatenateOptionsT, StablehloBroadcastInDimOptionsT, StablehloSliceOptionsT, StablehloConvolutionOptionsT, StablehloCustomCallOptionsT, StablehloReduceOptionsT, StablehloScatterOptionsT, StablehloCompareOptionsT, StablehloDynamicSliceOptionsT, StablehloPadOptionsT, StablehloIotaOptionsT, StablehloDotGeneralOptionsT, StablehloReduceWindowOptionsT, StablehloSortOptionsT, StablehloWhileOptionsT, StablehloGatherOptionsT, StablehloTransposeOptionsT, DilateOptionsT, StablehloRngBitGeneratorOptionsT, ReduceWindowOptionsT]
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
@@ -12991,6 +16884,8 @@ class OperatorT(object):
                 self.intermediates = operator.IntermediatesAsNumpy()
         self.largeCustomOptionsOffset = operator.LargeCustomOptionsOffset()
         self.largeCustomOptionsSize = operator.LargeCustomOptionsSize()
+        self.builtinOptions2Type = operator.BuiltinOptions2Type()
+        self.builtinOptions2 = BuiltinOptions2Creator(self.builtinOptions2Type, operator.BuiltinOptions2())
 
     # OperatorT
     def Pack(self, builder):
@@ -13036,6 +16931,8 @@ class OperatorT(object):
                 for i in reversed(range(len(self.intermediates))):
                     builder.PrependInt32(self.intermediates[i])
                 intermediates = builder.EndVector()
+        if self.builtinOptions2 is not None:
+            builtinOptions2 = self.builtinOptions2.Pack(builder)
         OperatorStart(builder)
         OperatorAddOpcodeIndex(builder, self.opcodeIndex)
         if self.inputs is not None:
@@ -13054,6 +16951,9 @@ class OperatorT(object):
             OperatorAddIntermediates(builder, intermediates)
         OperatorAddLargeCustomOptionsOffset(builder, self.largeCustomOptionsOffset)
         OperatorAddLargeCustomOptionsSize(builder, self.largeCustomOptionsSize)
+        OperatorAddBuiltinOptions2Type(builder, self.builtinOptions2Type)
+        if self.builtinOptions2 is not None:
+            OperatorAddBuiltinOptions2(builder, builtinOptions2)
         operator = OperatorEnd(builder)
         return operator