ConvertToTensorShapeProto(tensor_type.getShape(), &tensor_shape_proto);
    return PartialTensorShape(tensor_shape_proto);
  }

  // If type is not a RankedTensor or UnrankedTensor, it must be a scalar.
  // Empty TensorShape indicates a scalar.
  return TensorShape();
}

mlir::TF::ShapeAttr ConvertTypeToTensorShapeAttr(const mlir::Type& type) {
  if (mlir::isa<mlir::UnrankedTensorType>(type)) {

  map:
    fields:
    - name: apiVersion
      type:
        scalar: string
    - name: fieldsType
      type:
        scalar: string
    - name: fieldsV1
      type:
        namedType: io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1
    - name: manager
      type:
        scalar: string
    - name: operation
      type:
        scalar: string
    - name: time
      type:

      t.scalar<tensorflow::ResourceHandle>()().set_name("var1");
      t.scalar<tensorflow::ResourceHandle>()().set_device(kDeviceName);

      outputs->push_back(t);
    } else if (output_name == "var2") {
      Tensor t = Tensor(tensorflow::DT_RESOURCE, tensorflow::TensorShape({1}));
      t.scalar<tensorflow::ResourceHandle>()().set_name("var2");

    deps = [
        ":iostream",
        ":none",
        ":scalars",
        ":string",
        ":tensor_spec",
        "//tensorflow/core:framework",
        "//tensorflow/core:protos_all_cc",
        "//tensorflow/core:test",
        "//tensorflow/core:test_main",
    ],
)

cc_library(
    name = "scalars",
    hdrs = [
        "scalars.h",
    ],
)

tf_cc_test(
    name = "scalars_test",

		k = new(big.Int).Neg(k)
	}
	if k.Cmp(c.params.N) >= 0 {
		// This should never happen.
		k = new(big.Int).Mod(k, c.params.N)
	}
	scalar := k.FillBytes(make([]byte, 32))
	inverse, err := nistec.P256OrdInverse(scalar)
	if err != nil {
		panic("crypto/elliptic: nistec rejected normalized scalar")
	}
	return new(big.Int).SetBytes(inverse)

    name: server
---
# Control plane pod proving the existence of istio.io/rev 'canary'
apiVersion: v1
kind: Pod
metadata:
  name: istiod-canary-1234567890-12345
  namespace: istio-system
  labels:
    app: istiod
    istio: pilot
    istio.io/rev: canary
spec:
  containers:
  - image: gcr.io/google-samples/microservices-demo/adservice:v0.1.1
    name: server
---

    .Attr("max_percentile: float = 0.0")
    .SetShapeFn([](::tensorflow::shape_inference::InferenceContext* c) {
      c->set_output(0, c->input(0));
      c->set_output(1, c->Scalar());
      c->set_output(2, c->Scalar());

      const tensorflow::AttrValue* num_bins_attr;
      TF_RETURN_IF_ERROR(c->GetAttr("num_bins", &num_bins_attr));
      c->set_output(3, c->MakeShape({num_bins_attr->i()}));

			stable := namespace.NewOrFail(t, t, namespace.Config{
				Prefix:   "stable",
				Inject:   true,
				Revision: "stable",
			})
			canary := namespace.NewOrFail(t, t, namespace.Config{
				Prefix:   "canary",
				Inject:   true,
				Revision: "canary",
			})

			echos := deployment.New(t).
				WithClusters(t.Clusters()...).
				WithConfig(echo.Config{
					Service:   "client",
					Namespace: stable,

cond: A Tensor. If the tensor is a scalar of non-boolean type, the
    scalar is converted to a boolean according to the
    following rule: if the scalar is a numerical value, non-zero means
    True and zero means False; if the scalar is a string, non-empty
    means True and empty means False. If the tensor is not a scalar,
    being empty means False and being non-empty means True.

                    } else if (userAgent.indexOf("Chrome") >= 0) {
                        uaType = UserAgentType.CHROME;
                    } else if (userAgent.indexOf("Safari") >= 0) {
                        uaType = UserAgentType.SAFARI;
                    } else if (userAgent.indexOf("Opera") >= 0) {
                        uaType = UserAgentType.OPERA;
                    }
                }