"format": "int32",
            "type": "integer"
          },
          "nominalConcurrencyShares": {

            "format": "int32",
            "type": "integer"
          },
          "nominalConcurrencyShares": {

1e10                uint64      10000000000 is in the set of unsigned 64-bit integers
2.718281828459045   float32     2.718281828459045 rounds to 2.7182817 which is in the set of float32 values
-1e-1000            float64     -1e-1000 rounds to IEEE -0.0 which is further simplified to 0.0
0i                  int         0 is an integer value
(42 + 0i)           float32     42.0 (with zero imaginary part) is in the set of float32 values
</pre>

# - NUM_MIGS
# - NUM_WINDOWS_MIGS
function set_num_migs() {
  local defaulted_max_instances_per_mig=${MAX_INSTANCES_PER_MIG:-1000}

  if [[ ${defaulted_max_instances_per_mig} -le "0" ]]; then
    echo "MAX_INSTANCES_PER_MIG cannot be negative. Assuming default 1000"
    defaulted_max_instances_per_mig=1000
  fi
  export NUM_MIGS=$(((NUM_NODES + defaulted_max_instances_per_mig - 1) / defaulted_max_instances_per_mig))

    ```

      return failure();
    }

    // For a cumulative op, padding (expressed as a list of left-padding and
    // right-padding pairs) should be of the form:
    //  dense<[[0, 0], [0, 0], [N-1, 0], [0, 0]]>
    // where N is the size of the input dimension being operated over.
    if (!rw.getPadding()) return failure();
    const auto& padding = rw.getPadding()->getValues<int64_t>();

	{AMOVW, Ytask, Ynone, Yml, movRegMem2op, [4]uint8{0x0f, 0x00, 1, 0}},

	/* load full pointer - unsupported
	{AMOVL, Yml, Ycol, movFullPtr, [4]uint8{0, 0, 0, 0}},
	{AMOVW, Yml, Ycol, movFullPtr, [4]uint8{Pe, 0, 0, 0}},
	*/

	// double shift
	{ASHLL, Yi8, Yrl, Yml, movDoubleShift, [4]uint8{0xa4, 0xa5, 0, 0}},
	{ASHLL, Ycl, Yrl, Yml, movDoubleShift, [4]uint8{0xa4, 0xa5, 0, 0}},

  %0 = arith.constant dense<[0]> : tensor<1xi32>
  %1 = arith.constant dense<[-1]> : tensor<1xi32>
  %2 = arith.constant dense<[-1]> : tensor<1xi32>
  %3 = arith.constant dense<[0.0, 0.0]> : tensor<2xf32>
  %4 = "tf.MatrixDiagV2"(%arg0, %0, %1, %2, %3) : (tensor<8x16xf32>, tensor<1xi32>, tensor<1xi32>, tensor<1xi32>, tensor<2xf32>) -> tensor<8x16x16xf32>
  func.return %4 : tensor<8x16x16xf32>

  SmallVector<int64_t, 4> GetPadding(stablehlo::ConvolutionOp op) const {
    DenseIntElementsAttr padding_attr = op.getPaddingAttr();
    if (!padding_attr) {
      return {0, 0, 0, 0};
    }

    auto padding_values = padding_attr.getValues<int64_t>();
    // Padding has [[h_low, h_high], [w_low, w_high]] format.
    // https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution.

	SYS_FABSD64                         = 0xBB5 // 2997
	SYS_FABSD128                        = 0xBB6 // 2998
	SYS_FDIMD32                         = 0xBB7 // 2999
	SYS_FDIMD64                         = 0xBB8 // 3000
	SYS_FDIMD128                        = 0xBB9 // 3001
	SYS_FE_DEC_GETROUND                 = 0xBBA // 3002
	SYS_FE_DEC_SETROUND                 = 0xBBB // 3003
	SYS_FLOORD32                        = 0xBBC // 3004