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

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

    return %3: tensor<512xi32>
  }
func.func private @_func(%arg0: tensor<?xi32, #mhlo.type_extensions<bounds = [512]>> {mhlo.sharding = "\08\01\1A\01\01\22\01\00"}) -> (tensor<512xi32>) {
    %0 = "tf.A"(%arg0) {} : (tensor<?xi32, #mhlo.type_extensions<bounds = [512]>>) -> tensor<512xi32>
    return %0 : tensor<512xi32>
  }
}

// -----

// The following xla.OpSharding is used:

    }                                                                     \
    if (index < 0 || index >= list->response.size()) {                    \
      status->status = InvalidArgument("index out of bounds");            \
      return err_val;                                                     \
    }                                                                     \

  func.return %0 : tensor<i1>
}

// -----

func.func @testRoundInvalidInputType(%arg: tensor<?xi32>) -> tensor<?xi32> {
  // expected-error @+1 {{'tfl.round' op operand #0 must be tensor of 32-bit float values}}
  %0 = "tfl.round"(%arg) : (tensor<?xi32>) -> tensor<?xi32>
  func.return %0 : tensor<?xi32>
}

// -----

        return op.emitOpError()
               << "found mismatching batch dimensions for lhs shape " << x_ty
               << " and rhs shape " << y_ty;
      }
    }
  } else {
    if (!OpTrait::util::getBroadcastedShape(x_batches, y_batches,
                                            result_batch_shape))
      return op.emitOpError()
             << "found incompatible broadcast batch dimensions for lhs shape "

                                    rewriter))) {
      return failure();
    }

    ImplicitLocOpBuilder builder(gather_op.getLoc(), rewriter);
    // Clamp the start indices to ensure it is in bounds.
    auto max_start_indices = BuildIntArrayConstOp(
        builder, rewriter,
        llvm::SmallVector<int64_t>(
            {operand_type.getDimSize(0) - slice_sizes_vector[0],

	// The scopes field is used to avoid unnecessary parentheses
	// around expressions that use > (or >>). It is incremented if
	// we output a parenthesis or something else that means that >
	// or >> won't be treated as ending a template. It starts out
	// as 1, and is set to 0 when we start writing template
	// arguments. We add parentheses around expressions using > if
	// scopes is 0. The effect is that an expression with > gets

  // Test dimensions sizes.
  %d1 = "tf.Const"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>
  %d2 = "tf.Const"() {value = dense<2> : tensor<i32>} : () -> tensor<i32>

  // Slice bounds.
  %0 = "tf.Const"() {value = dense<0> : tensor<1xi32>} : () -> tensor<1xi32>
  %1 = "tf.Const"() {value = dense<1> : tensor<1xi32>} : () -> tensor<1xi32>

employed. The Polish I used was in this manner. I had two round Copper Plates, each six Inches in Diameter, the one convex, the other concave, ground very true to one another. On the convex I ground the Object-Metal or Concave which was to be polish'd, 'till it had taken the Figure of the Convex and was ready for a Polish. Then I pitched over the convex very thinly, by dropping melted Pitch upon it, and warming it to keep the Pitch soft, whilst I ground it with the concave Copper wetted to make it spread...