let description = [{
    Set a tensor in resource array.

    arg: the tensor to be set in the resource array.
    index: the index in the resource array
  }];

  let arguments = (ins
    TFTensorType:$arg,
    I64Attr:$index
  );

  let results = (outs);

  let assemblyFormat = "operands attr-dict";
}

  }];

  let arguments = (ins
    MlrtFutureType:$future
  );

  let assemblyFormat = "operands attr-dict";
}

def AwaitAllControlOp: Mlrt_Op<"await_all_control", []> {
  let summary = "Awaits multiple signals";

  let description = [{
    Awaits multiple signals

    $futures: A list of !mlrt.futures
  }];

  let arguments = (ins
    Variadic<MlrtFutureType>:$futures
  );

// elements. It returns a new slice of inline elements with links added.
func addSymbolLinksInlines(ins []md.Inline, defaultPackage string) []md.Inline {
	ins = splitAtBrackets(ins)
	var res []md.Inline
	for i := 0; i < len(ins); i++ {
		if txt := symbolLinkText(i, ins); txt != "" {
			link, ok := symbolLink(txt, defaultPackage)
			if ok {
				res = append(res, link)
				i += 2
				continue
			}

      "std::vector<int>", "GetSparseOperands", (ins)
    >,
    InterfaceMethod<
      [{Returns the supported block size of float sparse operands.}],
      "std::vector<std::vector<int>>", "GetFloatBlockSize", (ins)
    >,
    InterfaceMethod<
      [{Returns the supported block size of quantized sparse operands.}],
      "std::vector<std::vector<int>>", "GetQuantizedBlockSize", (ins)
    >,
  ];
}

      "int", "GetAffineOperandIndex",
      (ins), [{}], [{return 1;}]>,
    InterfaceMethod<
      [{Returns whether narrow range is required for the affine operand.}],
      "bool", "RequiredNarrowRangeAffineOperand",
      (ins), [{}], [{return true;}]>,
    InterfaceMethod<
      [{Returns quantization dim for the affine operand.}],
      "int", "GetQuantizationDimIndex",
      (ins)>,
    InterfaceMethod<

      "SmallVector<unsigned, 4>", "GetLayoutDependentArgs", (ins)
    >,
    InterfaceMethod<
      [{Returns indices of layout dependent results.}],
      "SmallVector<unsigned, 4>", "GetLayoutDependentResults", (ins)
    >,
    InterfaceMethod<
      [{Returns the optimal data layout based on the available devices.}],
      "StringRef", "GetOptimalLayout", (ins "const RuntimeDevices&":$devices)
    >,
    InterfaceMethod<

	}
	for _, test := range tests {
		t.Run(test.ins, func(t *testing.T) {
			if got := test.fn(test.a, test.b); got != test.want {
				t.Errorf("Assembly %v %v, %v = %v, want %v", test.ins, test.a, test.b, got, test.want)
			}
			if got := test.goFn(test.a, test.b); got != test.want {
				t.Errorf("Go %v %v, %v = %v, want %v", test.ins, test.a, test.b, got, test.want)
			}
		})
	}
}

		if n > 256 {
			n = 256
		}

		switch n {
		// Handle very small clears with move instructions.
		case 8, 4, 2, 1:
			ins := s390x.AMOVB
			switch n {
			case 8:
				ins = s390x.AMOVD
			case 4:
				ins = s390x.AMOVW
			case 2:
				ins = s390x.AMOVH
			}
			p = pp.Append(p, ins, obj.TYPE_CONST, 0, 0, obj.TYPE_MEM, reg, off)

		// Handle clears that would require multiple move instructions with CLEAR (assembled as XC).

def TF_UniformQuantizedDotGeneralOp : TF_Op<"UniformQuantizedDotGeneral", [Pure]> {
  // TODO(b/230804708): Improve the operator description.
  let summary = "Quantized dot general operator.";

  let arguments = (ins
    TensorOf<[TF_Float32, TF_Qint8]>:$lhs,
    TensorOf<[TF_Qint8]>:$rhs,
    TF_Float32Tensor:$lhs_scales,
    TF_Int32Tensor:$lhs_zps,
    TF_Float32Tensor:$rhs_scales,
    TF_Int32Tensor:$rhs_zps,

  let description = [{
    Setting a tensor value in TFRT runtime's static resource manager, using
    index as its identifier. It can be retrieved by _TfrtGetResource using the
    same index.
  }];

  let arguments = (ins
    TF_Tensor:$arg,
    I64Attr:$index
  );
}

def TF__TfrtGetResourceOp : TF_Op<"_TfrtGetResource",
    [Pure, TF_NoConstantFold, DeclareOpInterfaceMethods<TF_ResourceHandleAllocatorInterface>]> {