"input_quantization_axis", "quantization_axis", "rhs_quantization_axis"};

// Common suffixes for attributes used in FillQuantizationAttributes.
constexpr std::array<absl::string_view, 2> kSuffixes = {"_min_val", "_max_val"};

Attribute GetWindowStridesValue(
    PatternRewriter& rewriter, llvm::StringMap<Attribute>& identifier_to_attr) {
  ArrayAttr stride = mlir::dyn_cast<ArrayAttr>(identifier_to_attr["strides"]);

//go:build aix

package runtime

const (
	_EPERM     = 0x1
	_ENOENT    = 0x2
	_EINTR     = 0x4
	_EAGAIN    = 0xb
	_ENOMEM    = 0xc
	_EACCES    = 0xd
	_EFAULT    = 0xe
	_EINVAL    = 0x16
	_ETIMEDOUT = 0x4e

	_PROT_NONE  = 0x0
	_PROT_READ  = 0x1
	_PROT_WRITE = 0x2
	_PROT_EXEC  = 0x4

	_MAP_ANON      = 0x10
	_MAP_PRIVATE   = 0x2
	_MAP_FIXED     = 0x100
	_MADV_DONTNEED = 0x4

#include <semaphore.h>
*/
import "C"

const (
	_EPERM     = C.EPERM
	_ENOENT    = C.ENOENT
	_EINTR     = C.EINTR
	_EAGAIN    = C.EAGAIN
	_ENOMEM    = C.ENOMEM
	_EACCES    = C.EACCES
	_EFAULT    = C.EFAULT
	_EINVAL    = C.EINVAL
	_ETIMEDOUT = C.ETIMEDOUT

	_PROT_NONE  = C.PROT_NONE
	_PROT_READ  = C.PROT_READ
	_PROT_WRITE = C.PROT_WRITE
	_PROT_EXEC  = C.PROT_EXEC

	_MAP_ANON      = C.MAP_ANONYMOUS

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package runtime

import (
	"internal/runtime/atomic"
	"unsafe"
)

const (
	_EACCES = 13
	_EINVAL = 22
)

// Don't split the stack as this method may be invoked without a valid G, which
// prevents us from allocating more stack.
//
//go:nosplit
func sysAllocOS(n uintptr) unsafe.Pointer {

//
// This is exported via linkname to assembly in the syscall package.
//
//go:nosplit
//go:linkname syscall_Syscall
func syscall_Syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
	return 0, 0, _EINVAL
}

// This is syscall.RawSyscall, it exists to satisfy some build dependency,
// but it doesn't work.
//
// This is exported via linkname to assembly in the syscall package.
//
//go:linkname syscall_RawSyscall

    """
    in_placeholder = array_ops.placeholder(dtypes.float32, shape=input_shape)

    filters = random_ops.random_uniform(
        shape=filter_shape, minval=-1.0, maxval=1.0
    )
    if use_variable_for_filter:
      filters = variables.Variable(filters)

    output_tensor = nn_ops.conv2d(
        in_placeholder,
        filters,
        strides=[1, 1, 2, 1],

  let description = [{
The generated values are uniform integers in the range `[minval, maxval)`.
The lower bound `minval` is included in the range, while the upper bound
`maxval` is excluded.

The random integers are slightly biased unless `maxval - minval` is an exact
power of two.  The bias is small for values of `maxval - minval` significantly
smaller than the range of the output (either `2^32` or `2^64`).
  }];

In particular, in the Java ecosystem, Gradle provides a built-in attribute that library authors can use to express compatibility with the Java ecosystem: `org.gradle.jvm.version`.
This attribute expresses the _minimal version that a consumer must have in order to work properly_.

When you apply the `java` or `java-library` plugins, Gradle will automatically associate this attribute to the outgoing variants.

  """A model with 2 signatures.

  Used to test where the quantizer has to handle multiple signatures.
  """

  def __init__(self):
    self.matmul_filters = random_ops.random_uniform(
        shape=(4, 3), minval=-1.0, maxval=1.0
    )
    self.conv_filters = np.random.uniform(
        low=-10, high=10, size=(2, 3, 3, 2)
    ).astype('f4')

  @def_function.function(
      input_signature=[

  Output shape_shape = ops::Const(root.WithOpName("shape_shape"), {2}, {1});
  Output shape =
      ops::RandomUniformInt(root.WithOpName("shape"), shape_shape,
                            ops::Const(root.WithOpName("minval"), 1),
                            ops::Const(root.WithOpName("maxval"), 20));
  Output reshape_input =
      ops::Placeholder(root.WithOpName("reshape_input"), DT_FLOAT,