
# Autogenerated by mlir-tblgen; don't manually edit.

from ._ods_common import _cext as _ods_cext
from ._ods_common import (
    equally_sized_accessor as _ods_equally_sized_accessor,
    get_default_loc_context as _ods_get_default_loc_context,
    get_op_results_or_values as _get_op_results_or_values,
    segmented_accessor as _ods_segmented_accessor,
)
_ods_ir = _ods_cext.ir
_ods_cext.globals.register_traceback_file_exclusion(__file__)

import builtins
from typing import Any as _Any, Sequence as _Sequence, Union as _Union, Optional as _Optional
import sys as _sys
if _sys.version_info >= (3, 12):
  from collections.abc import Buffer as _Buffer  # pytype: disable=not-supported-yet
else:
  try:
    from typing_extensions import Buffer as _Buffer
  except ImportError:
    _Buffer = _Any


from ._transform_ops_gen import _Dialect

@_ods_cext.register_operation(_Dialect)
class ApplyCastAwayVectorLeadingOneDimPatternsOp(_ods_ir.OpView):
  r"""
  Collect a set of leading one dimension removal patterns.
  
  These patterns insert vector.shape_cast to remove leading one dimensions
  to expose more canonical forms of read/write/insert/extract operations.
  With them, there are more chances that we can cancel out extract-insert
  pairs or forward write-read pairs.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.cast_away_vector_leading_one_dim"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyCastAwayVectorLeadingOneDimPatternsOp)
class ApplyCastAwayVectorLeadingOneDimPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.cast_away_vector_leading_one_dim"

def apply_patterns_vector_cast_away_vector_leading_one_dim(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyCastAwayVectorLeadingOneDimPatternsOp:
  return ApplyCastAwayVectorLeadingOneDimPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp(_ods_ir.OpView):
  r"""
  Apply vector patterns to drop the inner most unit dims from
  vector.transfer_read and vector.transfer_write Ops by taking a subview (via
  memref.subview) of the original source/destination MemRef. Since it
  requires the input/ouptu to be MemRefs, this Op is only helpful
  past-bufferization.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.drop_inner_most_unit_dims_from_xfer_ops"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp)
class ApplyDropInnerMostUnitDimsFromXferOpsPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.drop_inner_most_unit_dims_from_xfer_ops"

def apply_patterns_vector_drop_inner_most_unit_dims_from_xfer_ops(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp:
  return ApplyDropInnerMostUnitDimsFromXferOpsPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyDropUnitDimWithShapeCastPatternsOp(_ods_ir.OpView):
  r"""
   Apply vector patterns to fold unit dims with vector.shape_cast Ops:
    - DropUnitDimFromElementwiseOps
    - DropUnitDimsFromScfForOp
    - DropUnitDimsFromTransposeOp
  
  Excludes patterns for vector.transfer Ops. This is complemented by
  shape_cast folding patterns.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.drop_unit_dims_with_shape_cast"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyDropUnitDimWithShapeCastPatternsOp)
class ApplyDropUnitDimWithShapeCastPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.drop_unit_dims_with_shape_cast"

def apply_patterns_vector_drop_unit_dims_with_shape_cast(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyDropUnitDimWithShapeCastPatternsOp:
  return ApplyDropUnitDimWithShapeCastPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyFlattenVectorTransferOpsPatternsOp(_ods_ir.OpView):
  r"""
  Collect patterns to rewrite contiguous row-major vector.transfer_read or 
  vector.transfer_write operations to a 1D operation.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.flatten_vector_transfer_ops"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, target_vector_bitwidth: _Optional[_Union[int, _ods_ir.IntegerAttr]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    if target_vector_bitwidth is not None: attributes["target_vector_bitwidth"] = (target_vector_bitwidth if (
        isinstance(target_vector_bitwidth, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('UI32Attr')) else
          _ods_ir.AttrBuilder.get('UI32Attr')(target_vector_bitwidth, context=_ods_context))
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def target_vector_bitwidth(self) -> _ods_ir.IntegerAttr:
    return self.operation.attributes["target_vector_bitwidth"]

  @target_vector_bitwidth.setter
  def target_vector_bitwidth(self, value: _ods_ir.IntegerAttr):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["target_vector_bitwidth"] = value

@_ods_cext.register_op_adaptor(ApplyFlattenVectorTransferOpsPatternsOp)
class ApplyFlattenVectorTransferOpsPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.flatten_vector_transfer_ops"

  @builtins.property
  def target_vector_bitwidth(self) -> _ods_ir.IntegerAttr:
    return self.attributes["target_vector_bitwidth"]

def apply_patterns_vector_flatten_vector_transfer_ops(*, target_vector_bitwidth: _Optional[_Union[int, _ods_ir.IntegerAttr]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyFlattenVectorTransferOpsPatternsOp:
  return ApplyFlattenVectorTransferOpsPatternsOp(target_vector_bitwidth=target_vector_bitwidth, loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyFoldArithExtensionPatternsOp(_ods_ir.OpView):
  r"""
  Collect a set of patterns that fold arithmetic extension on floating point
  into vector contract for the backends with native support.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.fold_arith_extension"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyFoldArithExtensionPatternsOp)
class ApplyFoldArithExtensionPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.fold_arith_extension"

def apply_patterns_vector_fold_arith_extension(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyFoldArithExtensionPatternsOp:
  return ApplyFoldArithExtensionPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyFoldElementwiseToVectorPatternsOp(_ods_ir.OpView):
  r"""
  Collect a set of patterns that fold elementwise op on vectors to the vector
  dialect.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.elementwise_to_vector"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyFoldElementwiseToVectorPatternsOp)
class ApplyFoldElementwiseToVectorPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.elementwise_to_vector"

def apply_patterns_vector_elementwise_to_vector(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyFoldElementwiseToVectorPatternsOp:
  return ApplyFoldElementwiseToVectorPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyInterleaveToShufflePatternsOp(_ods_ir.OpView):
  r"""
  Indicates that 1D vector interleave operations should be rewritten as
  vector shuffle operations.
  
  This is motivated by some current codegen backends not handling vector
  interleave operations.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.interleave_to_shuffle"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyInterleaveToShufflePatternsOp)
class ApplyInterleaveToShufflePatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.interleave_to_shuffle"

def apply_patterns_vector_interleave_to_shuffle(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyInterleaveToShufflePatternsOp:
  return ApplyInterleaveToShufflePatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerBitCastPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector bitcast operations should be lowered to
  finer-grained vector primitives.
  
  This is usally a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_bitcast"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyLowerBitCastPatternsOp)
class ApplyLowerBitCastPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_bitcast"

def apply_patterns_vector_lower_bitcast(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerBitCastPatternsOp:
  return ApplyLowerBitCastPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerBroadcastPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector broadcast operations should be lowered to
  finer-grained vector primitives.
  
  This is usally a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_broadcast"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyLowerBroadcastPatternsOp)
class ApplyLowerBroadcastPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_broadcast"

def apply_patterns_vector_lower_broadcast(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerBroadcastPatternsOp:
  return ApplyLowerBroadcastPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerContractionPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector contraction-like operations should be lowered to
  finer-grained vector primitives.
  
  This is usually a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_contraction"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, lowering_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    if lowering_strategy is not None: attributes["lowering_strategy"] = (lowering_strategy if (
        isinstance(lowering_strategy, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('VectorContractLoweringAttr')) else
          _ods_ir.AttrBuilder.get('VectorContractLoweringAttr')(lowering_strategy, context=_ods_context))
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def lowering_strategy(self) -> _ods_ir.Attribute:
    return self.operation.attributes["lowering_strategy"]

  @lowering_strategy.setter
  def lowering_strategy(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["lowering_strategy"] = value

@_ods_cext.register_op_adaptor(ApplyLowerContractionPatternsOp)
class ApplyLowerContractionPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_contraction"

  @builtins.property
  def lowering_strategy(self) -> _ods_ir.Attribute:
    return self.attributes["lowering_strategy"]

def apply_patterns_vector_lower_contraction(*, lowering_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerContractionPatternsOp:
  return ApplyLowerContractionPatternsOp(lowering_strategy=lowering_strategy, loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerCreateMaskPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector create_mask-like operations should be lowered to
  finer-grained vector primitives.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_create_mask"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyLowerCreateMaskPatternsOp)
class ApplyLowerCreateMaskPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_create_mask"

def apply_patterns_vector_lower_create_mask(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerCreateMaskPatternsOp:
  return ApplyLowerCreateMaskPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerGatherPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector.gather operations should be lowered to
  finer-grained vector primitives.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_gather"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyLowerGatherPatternsOp)
class ApplyLowerGatherPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_gather"

def apply_patterns_vector_lower_gather(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerGatherPatternsOp:
  return ApplyLowerGatherPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerInterleavePatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector interleave operations should be lowered to
  finer-grained vector primitives.
  
  This is usally a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_interleave"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyLowerInterleavePatternsOp)
class ApplyLowerInterleavePatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_interleave"

def apply_patterns_vector_lower_interleave(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerInterleavePatternsOp:
  return ApplyLowerInterleavePatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerMaskedTransfersPatternsOp(_ods_ir.OpView):
  r"""
  Apply opt-in patterns that lower vector.mask operations surrounding
  side-effecting ops:
    - MaskedTransferReadOpPattern
    - MaskedTransferWriteOpPattern
    - MaskedGatherOpPattern
  
  This is usually a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_masked_transfers"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyLowerMaskedTransfersPatternsOp)
class ApplyLowerMaskedTransfersPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_masked_transfers"

def apply_patterns_vector_lower_masked_transfers(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerMaskedTransfersPatternsOp:
  return ApplyLowerMaskedTransfersPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerMasksPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector.create_mask and vector.constant_mask operations
  should be lowered to finer-grained vector primitives.
  
  This is usually a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_masks"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyLowerMasksPatternsOp)
class ApplyLowerMasksPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_masks"

def apply_patterns_vector_lower_masks(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerMasksPatternsOp:
  return ApplyLowerMasksPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerOuterProductPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that the vector outerproduct operations should be lowered to
  finer-grained vector primitives.
  
  This is usually a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_outerproduct"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyLowerOuterProductPatternsOp)
class ApplyLowerOuterProductPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_outerproduct"

def apply_patterns_vector_lower_outerproduct(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerOuterProductPatternsOp:
  return ApplyLowerOuterProductPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerScanPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector.scan operations should be lowered to
  finer-grained vector primitives.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_scan"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyLowerScanPatternsOp)
class ApplyLowerScanPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_scan"

def apply_patterns_vector_lower_scan(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerScanPatternsOp:
  return ApplyLowerScanPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerShapeCastPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector shape_cast operations should be lowered to
  finer-grained vector primitives.
  
  This is usually a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_shape_cast"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyLowerShapeCastPatternsOp)
class ApplyLowerShapeCastPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_shape_cast"

def apply_patterns_vector_lower_shape_cast(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerShapeCastPatternsOp:
  return ApplyLowerShapeCastPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerTransferPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector transfer operations should be lowered to finer-grained
  vector primitives.
  
  This is usually a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_transfer"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, max_transfer_rank: _Optional[_Union[int, _ods_ir.IntegerAttr]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    if max_transfer_rank is not None: attributes["max_transfer_rank"] = (max_transfer_rank if (
        isinstance(max_transfer_rank, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('I64Attr')) else
          _ods_ir.AttrBuilder.get('I64Attr')(max_transfer_rank, context=_ods_context))
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def max_transfer_rank(self) -> _ods_ir.IntegerAttr:
    return self.operation.attributes["max_transfer_rank"]

  @max_transfer_rank.setter
  def max_transfer_rank(self, value: _ods_ir.IntegerAttr):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["max_transfer_rank"] = value

@_ods_cext.register_op_adaptor(ApplyLowerTransferPatternsOp)
class ApplyLowerTransferPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_transfer"

  @builtins.property
  def max_transfer_rank(self) -> _ods_ir.IntegerAttr:
    return self.attributes["max_transfer_rank"]

def apply_patterns_vector_lower_transfer(*, max_transfer_rank: _Optional[_Union[int, _ods_ir.IntegerAttr]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerTransferPatternsOp:
  return ApplyLowerTransferPatternsOp(max_transfer_rank=max_transfer_rank, loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyLowerTransposePatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector transpose-like operations should be lowered to
  finer-grained vector primitives.
  
  This is usually a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.lower_transpose"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, lowering_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, avx2_lowering_strategy: _Optional[_Union[bool, _ods_ir.BoolAttr]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    if lowering_strategy is not None: attributes["lowering_strategy"] = (lowering_strategy if (
        isinstance(lowering_strategy, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('VectorTransposeLoweringAttr')) else
          _ods_ir.AttrBuilder.get('VectorTransposeLoweringAttr')(lowering_strategy, context=_ods_context))
    if avx2_lowering_strategy is not None: attributes["avx2_lowering_strategy"] = (avx2_lowering_strategy if (
        isinstance(avx2_lowering_strategy, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('BoolAttr')) else
          _ods_ir.AttrBuilder.get('BoolAttr')(avx2_lowering_strategy, context=_ods_context))
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def lowering_strategy(self) -> _ods_ir.Attribute:
    return self.operation.attributes["lowering_strategy"]

  @lowering_strategy.setter
  def lowering_strategy(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["lowering_strategy"] = value

  @builtins.property
  def avx2_lowering_strategy(self) -> _ods_ir.BoolAttr:
    return self.operation.attributes["avx2_lowering_strategy"]

  @avx2_lowering_strategy.setter
  def avx2_lowering_strategy(self, value: _ods_ir.BoolAttr):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["avx2_lowering_strategy"] = value

@_ods_cext.register_op_adaptor(ApplyLowerTransposePatternsOp)
class ApplyLowerTransposePatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.lower_transpose"

  @builtins.property
  def lowering_strategy(self) -> _ods_ir.Attribute:
    return self.attributes["lowering_strategy"]

  @builtins.property
  def avx2_lowering_strategy(self) -> _ods_ir.BoolAttr:
    return self.attributes["avx2_lowering_strategy"]

def apply_patterns_vector_lower_transpose(*, lowering_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, avx2_lowering_strategy: _Optional[_Union[bool, _ods_ir.BoolAttr]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyLowerTransposePatternsOp:
  return ApplyLowerTransposePatternsOp(lowering_strategy=lowering_strategy, avx2_lowering_strategy=avx2_lowering_strategy, loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyMaterializeMasksPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that mask operations should be lowered to fine-grained arithemtic
  operations.
  
  This is usually the last step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.materialize_masks"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyMaterializeMasksPatternsOp)
class ApplyMaterializeMasksPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.materialize_masks"

def apply_patterns_vector_materialize_masks(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyMaterializeMasksPatternsOp:
  return ApplyMaterializeMasksPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyMultiReductionFlatteningPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector multi_reduction operations should be flattened from
  more than 2-D to 2-D.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.multi_reduction_flattening"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, lowering_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    if lowering_strategy is not None: attributes["lowering_strategy"] = (lowering_strategy if (
        isinstance(lowering_strategy, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('VectorMultiReductionLoweringAttr')) else
          _ods_ir.AttrBuilder.get('VectorMultiReductionLoweringAttr')(lowering_strategy, context=_ods_context))
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def lowering_strategy(self) -> _ods_ir.Attribute:
    return self.operation.attributes["lowering_strategy"]

  @lowering_strategy.setter
  def lowering_strategy(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["lowering_strategy"] = value

@_ods_cext.register_op_adaptor(ApplyMultiReductionFlatteningPatternsOp)
class ApplyMultiReductionFlatteningPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.multi_reduction_flattening"

  @builtins.property
  def lowering_strategy(self) -> _ods_ir.Attribute:
    return self.attributes["lowering_strategy"]

def apply_patterns_vector_multi_reduction_flattening(*, lowering_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyMultiReductionFlatteningPatternsOp:
  return ApplyMultiReductionFlatteningPatternsOp(lowering_strategy=lowering_strategy, loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyMultiReductionUnrollingPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector multi_reduction operations should be unrolled.
  1-D multi_reductions are converted directly to vector.reduction.
  2-D multi_reductions are unrolled into either a sequence of
  vector.reduction ops (innerreduction) or element-wise arith ops
  (innerparallel).
  
  This populates the patterns from
  `populateVectorMultiReductionUnrollingPatterns`, i.e.:
  * `OneDimMultiReductionToReduction`
  * `TwoDimMultiReductionToReduction` (innerreduction)
  * `TwoDimMultiReductionToElementWise` (innerparallel)
  """

  OPERATION_NAME = "transform.apply_patterns.vector.multi_reduction_unrolling"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, lowering_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    if lowering_strategy is not None: attributes["lowering_strategy"] = (lowering_strategy if (
        isinstance(lowering_strategy, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('VectorMultiReductionLoweringAttr')) else
          _ods_ir.AttrBuilder.get('VectorMultiReductionLoweringAttr')(lowering_strategy, context=_ods_context))
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def lowering_strategy(self) -> _ods_ir.Attribute:
    return self.operation.attributes["lowering_strategy"]

  @lowering_strategy.setter
  def lowering_strategy(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["lowering_strategy"] = value

@_ods_cext.register_op_adaptor(ApplyMultiReductionUnrollingPatternsOp)
class ApplyMultiReductionUnrollingPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.multi_reduction_unrolling"

  @builtins.property
  def lowering_strategy(self) -> _ods_ir.Attribute:
    return self.attributes["lowering_strategy"]

def apply_patterns_vector_multi_reduction_unrolling(*, lowering_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyMultiReductionUnrollingPatternsOp:
  return ApplyMultiReductionUnrollingPatternsOp(lowering_strategy=lowering_strategy, loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyRankReducingSubviewPatternsOp(_ods_ir.OpView):
  r"""
  Apply opt-in vector transfer permutation patterns that include:
    - TransferReadDropUnitDimsPattern
    - TransferWriteDropUnitDimsPattern
  
  These patterns have the effect of rewriting a vector.transfer with unit
  dimensions into a rank-reduced version thanks to subview operations.
  This is complemented by shape_cast folding patterns.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.rank_reducing_subview_patterns"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyRankReducingSubviewPatternsOp)
class ApplyRankReducingSubviewPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.rank_reducing_subview_patterns"

def apply_patterns_vector_rank_reducing_subview_patterns(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyRankReducingSubviewPatternsOp:
  return ApplyRankReducingSubviewPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyReorderMultiReductionPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector multi_reduction-like operations should be
  transformed such that all reduction dimensions become innermost or
  outermost, depending on `lowering_strategy`.
  
  This populates the patterns from
  `populateVectorMultiReductionReorderPatterns`, i.e.:
  * `InnerOuterDimReductionConversion`
  """

  OPERATION_NAME = "transform.apply_patterns.vector.reorder_multi_reduction_dims"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, lowering_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    if lowering_strategy is not None: attributes["lowering_strategy"] = (lowering_strategy if (
        isinstance(lowering_strategy, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('VectorMultiReductionLoweringAttr')) else
          _ods_ir.AttrBuilder.get('VectorMultiReductionLoweringAttr')(lowering_strategy, context=_ods_context))
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def lowering_strategy(self) -> _ods_ir.Attribute:
    return self.operation.attributes["lowering_strategy"]

  @lowering_strategy.setter
  def lowering_strategy(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["lowering_strategy"] = value

@_ods_cext.register_op_adaptor(ApplyReorderMultiReductionPatternsOp)
class ApplyReorderMultiReductionPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.reorder_multi_reduction_dims"

  @builtins.property
  def lowering_strategy(self) -> _ods_ir.Attribute:
    return self.attributes["lowering_strategy"]

def apply_patterns_vector_reorder_multi_reduction_dims(*, lowering_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyReorderMultiReductionPatternsOp:
  return ApplyReorderMultiReductionPatternsOp(lowering_strategy=lowering_strategy, loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyRewriteNarrowTypePatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector narrow rewrite operations should be applied.
  
  This is usually a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  
  Warning: these patterns currently only work for little endian targets.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.rewrite_narrow_types"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyRewriteNarrowTypePatternsOp)
class ApplyRewriteNarrowTypePatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.rewrite_narrow_types"

def apply_patterns_vector_rewrite_narrow_types(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyRewriteNarrowTypePatternsOp:
  return ApplyRewriteNarrowTypePatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplySinkVectorMemPatternsOp(_ods_ir.OpView):
  r"""
  Patterns that replace redundant Vector Ops (followed by
  `vector.load`/`vector.store`) with either vector.load/vector.store or
  `memref.load`/`memref.store`. Currently limited to 1-element vectors.
  
  Example:
  ```
  vector.load %arg0[%arg1] : memref<?xf32>, vector<4xf32>
  vector.extract %0[1] : f32 from vector<4xf32>
  ```
  Gets converted to:
  ```
  %c1 = arith.constant 1 : index
  %0 = arith.addi %arg1, %c1 overflow<nsw> : index
  %1 = memref.load %arg0[%0] : memref<?xf32>
  ```
  """

  OPERATION_NAME = "transform.apply_patterns.vector.sink_mem_ops"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplySinkVectorMemPatternsOp)
class ApplySinkVectorMemPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.sink_mem_ops"

def apply_patterns_vector_sink_mem_ops(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplySinkVectorMemPatternsOp:
  return ApplySinkVectorMemPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplySinkVectorPatternsOp(_ods_ir.OpView):
  r"""
  Patterns that remove redundant Vector Ops by re-ordering them with
  e.g. elementwise Ops.
  
  Example:
  ```
  %at = vector.transpose %a, [1, 0]: vector<4x2xf32> to vector<2x4xf32>
  %bt = vector.transpose %b, [1, 0]: vector<4x2xf32> to vector<2x4xf32>
  %r = arith.addf %at, %bt : vector<2x4xf32>
  ```
  gets converted to:
  ```
  %0 = arith.addf %a, %b : vector<4x2xf32>
  %r = vector.transpose %0, [1, 0] : vector<2x4xf32>
  ```
  At the moment, these patterns are limited to vector.broadcast,
  vector.transpose and vector.extract.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.sink_ops"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplySinkVectorPatternsOp)
class ApplySinkVectorPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.sink_ops"

def apply_patterns_vector_sink_ops(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplySinkVectorPatternsOp:
  return ApplySinkVectorPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplySplitTransferFullPartialPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector transfer operations should be split to full and
  partial parts.
  
  This is usually a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.split_transfer_full_partial"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, split_transfer_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    if split_transfer_strategy is not None: attributes["split_transfer_strategy"] = (split_transfer_strategy if (
        isinstance(split_transfer_strategy, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('VectorTransferSplitAttr')) else
          _ods_ir.AttrBuilder.get('VectorTransferSplitAttr')(split_transfer_strategy, context=_ods_context))
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def split_transfer_strategy(self) -> _ods_ir.Attribute:
    return self.operation.attributes["split_transfer_strategy"]

  @split_transfer_strategy.setter
  def split_transfer_strategy(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["split_transfer_strategy"] = value

@_ods_cext.register_op_adaptor(ApplySplitTransferFullPartialPatternsOp)
class ApplySplitTransferFullPartialPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.split_transfer_full_partial"

  @builtins.property
  def split_transfer_strategy(self) -> _ods_ir.Attribute:
    return self.attributes["split_transfer_strategy"]

def apply_patterns_vector_split_transfer_full_partial(*, split_transfer_strategy: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplySplitTransferFullPartialPatternsOp:
  return ApplySplitTransferFullPartialPatternsOp(split_transfer_strategy=split_transfer_strategy, loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyTransferPermutationPatternsOp(_ods_ir.OpView):
  r"""
  Apply opt-in vector transfer permutation patterns that include:
    - TransferReadPermutationLowering
    - TransferWritePermutationLowering
    - TransferOpReduceRank
    - TransferWriteNonPermutationLowering
  
  These patterns have the effect of rewriting a vector.transfer with an
  arbitrary permutation_map to a vector.transfer with a permutation_map that
  is a minor identity followed by a vector.transpose.
  
  In other words, this makes the vector.transfer contiguous on the most minor
  dimensions and materializes the permutation_map as a vector.transpose.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.transfer_permutation_patterns"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyTransferPermutationPatternsOp)
class ApplyTransferPermutationPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.transfer_permutation_patterns"

def apply_patterns_vector_transfer_permutation_patterns(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyTransferPermutationPatternsOp:
  return ApplyTransferPermutationPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyTransferToScfPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector transfer operations should be rewritten with scf.for
  loops over finer-grained vector primitives.
  
  This is usually a late step that is run after bufferization as part of the
  process of lowering to e.g. LLVM or NVVM.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.transfer_to_scf"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, max_transfer_rank: _Optional[_Union[int, _ods_ir.IntegerAttr]] = None, full_unroll: _Optional[_Union[bool, _ods_ir.BoolAttr]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    if max_transfer_rank is not None: attributes["max_transfer_rank"] = (max_transfer_rank if (
        isinstance(max_transfer_rank, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('I64Attr')) else
          _ods_ir.AttrBuilder.get('I64Attr')(max_transfer_rank, context=_ods_context))
    if full_unroll is not None: attributes["full_unroll"] = (full_unroll if (
        isinstance(full_unroll, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('BoolAttr')) else
          _ods_ir.AttrBuilder.get('BoolAttr')(full_unroll, context=_ods_context))
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def max_transfer_rank(self) -> _ods_ir.IntegerAttr:
    return self.operation.attributes["max_transfer_rank"]

  @max_transfer_rank.setter
  def max_transfer_rank(self, value: _ods_ir.IntegerAttr):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["max_transfer_rank"] = value

  @builtins.property
  def full_unroll(self) -> _ods_ir.BoolAttr:
    return self.operation.attributes["full_unroll"]

  @full_unroll.setter
  def full_unroll(self, value: _ods_ir.BoolAttr):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["full_unroll"] = value

@_ods_cext.register_op_adaptor(ApplyTransferToScfPatternsOp)
class ApplyTransferToScfPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.transfer_to_scf"

  @builtins.property
  def max_transfer_rank(self) -> _ods_ir.IntegerAttr:
    return self.attributes["max_transfer_rank"]

  @builtins.property
  def full_unroll(self) -> _ods_ir.BoolAttr:
    return self.attributes["full_unroll"]

def apply_patterns_vector_transfer_to_scf(*, max_transfer_rank: _Optional[_Union[int, _ods_ir.IntegerAttr]] = None, full_unroll: _Optional[_Union[bool, _ods_ir.BoolAttr]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyTransferToScfPatternsOp:
  return ApplyTransferToScfPatternsOp(max_transfer_rank=max_transfer_rank, full_unroll=full_unroll, loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyUnrollFromElementsPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector from_elements operations should be unrolled
  along the outermost dimension.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.unroll_from_elements"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyUnrollFromElementsPatternsOp)
class ApplyUnrollFromElementsPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.unroll_from_elements"

def apply_patterns_vector_unroll_from_elements(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyUnrollFromElementsPatternsOp:
  return ApplyUnrollFromElementsPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyUnrollToElementsPatternsOp(_ods_ir.OpView):
  r"""
  Indicates that vector to_elements operations should be unrolled
  along the outermost dimension.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.unroll_to_elements"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyUnrollToElementsPatternsOp)
class ApplyUnrollToElementsPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.unroll_to_elements"

def apply_patterns_vector_unroll_to_elements(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyUnrollToElementsPatternsOp:
  return ApplyUnrollToElementsPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyVectorReductionToContractPatternsOp(_ods_ir.OpView):
  r"""
  Apply opt-in patterns that convert reductions to contract:
    - MultiReduceToContract
    - CombineContractBroadcast
    - CombineContractABTranspose
    - CombineContractResultTranspose
    - ReorderElementwiseOpsOnTranspose
    - ReorderElementwiseOpsOnBroadcast
    - ReorderCastOpsOnBroadcast
  
  These patterns have the effect of rewriting a vector.multi_reduce into a
  vector.contract.
  """

  OPERATION_NAME = "transform.apply_patterns.vector.reduction_to_contract"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

@_ods_cext.register_op_adaptor(ApplyVectorReductionToContractPatternsOp)
class ApplyVectorReductionToContractPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_patterns.vector.reduction_to_contract"

def apply_patterns_vector_reduction_to_contract(*, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyVectorReductionToContractPatternsOp:
  return ApplyVectorReductionToContractPatternsOp(loc=loc, ip=ip)

@_ods_cext.register_operation(_Dialect)
class ApplyVectorToLLVMConversionPatternsOp(_ods_ir.OpView):
  r"""
  Collects patterns that convert vector dialect ops to LLVM dialect ops. These
  patterns require an "LLVMTypeConverter".
  
  The patterns can be customized as follows:
  - `reassociate_fp_reductions`: Allows LLVM to reassociate floating-point
    reductions for speed.
  - `force_32bit_vector_indices`: Allows the compiler to assume that vector
    indices fit in 32-bit if that yields faster code.
  """

  OPERATION_NAME = "transform.apply_conversion_patterns.vector.vector_to_llvm"

  _ODS_REGIONS = (0, True)

  def __init__(self, *, reassociate_fp_reductions: _Optional[_Union[bool, _ods_ir.BoolAttr]] = None, force_32bit_vector_indices: _Optional[_Union[bool, _ods_ir.BoolAttr]] = None, use_vector_alignment: _Optional[_Union[bool, _ods_ir.BoolAttr]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    _ods_context = _ods_get_default_loc_context(loc)
    if reassociate_fp_reductions is not None: attributes["reassociate_fp_reductions"] = (reassociate_fp_reductions if (
        isinstance(reassociate_fp_reductions, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('BoolAttr')) else
          _ods_ir.AttrBuilder.get('BoolAttr')(reassociate_fp_reductions, context=_ods_context))
    if force_32bit_vector_indices is not None: attributes["force_32bit_vector_indices"] = (force_32bit_vector_indices if (
        isinstance(force_32bit_vector_indices, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('BoolAttr')) else
          _ods_ir.AttrBuilder.get('BoolAttr')(force_32bit_vector_indices, context=_ods_context))
    if use_vector_alignment is not None: attributes["use_vector_alignment"] = (use_vector_alignment if (
        isinstance(use_vector_alignment, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('BoolAttr')) else
          _ods_ir.AttrBuilder.get('BoolAttr')(use_vector_alignment, context=_ods_context))
    results = []
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def reassociate_fp_reductions(self) -> _ods_ir.BoolAttr:
    return self.operation.attributes["reassociate_fp_reductions"]

  @reassociate_fp_reductions.setter
  def reassociate_fp_reductions(self, value: _ods_ir.BoolAttr):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["reassociate_fp_reductions"] = value

  @builtins.property
  def force_32bit_vector_indices(self) -> _ods_ir.BoolAttr:
    return self.operation.attributes["force_32bit_vector_indices"]

  @force_32bit_vector_indices.setter
  def force_32bit_vector_indices(self, value: _ods_ir.BoolAttr):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["force_32bit_vector_indices"] = value

  @builtins.property
  def use_vector_alignment(self) -> _ods_ir.BoolAttr:
    return self.operation.attributes["use_vector_alignment"]

  @use_vector_alignment.setter
  def use_vector_alignment(self, value: _ods_ir.BoolAttr):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["use_vector_alignment"] = value

@_ods_cext.register_op_adaptor(ApplyVectorToLLVMConversionPatternsOp)
class ApplyVectorToLLVMConversionPatternsOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "transform.apply_conversion_patterns.vector.vector_to_llvm"

  @builtins.property
  def reassociate_fp_reductions(self) -> _ods_ir.BoolAttr:
    return self.attributes["reassociate_fp_reductions"]

  @builtins.property
  def force_32bit_vector_indices(self) -> _ods_ir.BoolAttr:
    return self.attributes["force_32bit_vector_indices"]

  @builtins.property
  def use_vector_alignment(self) -> _ods_ir.BoolAttr:
    return self.attributes["use_vector_alignment"]

def apply_conversion_patterns_vector_vector_to_llvm(*, reassociate_fp_reductions: _Optional[_Union[bool, _ods_ir.BoolAttr]] = None, force_32bit_vector_indices: _Optional[_Union[bool, _ods_ir.BoolAttr]] = None, use_vector_alignment: _Optional[_Union[bool, _ods_ir.BoolAttr]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> ApplyVectorToLLVMConversionPatternsOp:
  return ApplyVectorToLLVMConversionPatternsOp(reassociate_fp_reductions=reassociate_fp_reductions, force_32bit_vector_indices=force_32bit_vector_indices, use_vector_alignment=use_vector_alignment, loc=loc, ip=ip)
