Output Get1DHostConstant(int64_t constant) {
    auto it = cache_.find(constant);
    if (it == cache_.end()) {
      Output new_const =
          ops::Const(scope_.WithOpName("const_", constant), {constant});
      it = cache_.insert({constant, new_const}).first;
      for (const Edge* e : control_deps_) {
        scope_.graph()->AddControlEdge(e->src(), new_const.node());
      }
    }

    %0 = tf_executor.graph {

    // CHECK: %[[CONST2:.*]] = "tf.Const"() <{value = dense<
    // CHECK-SAME: [8, 8, 3, 64]
    // CHECK: %[[RESHAPE1:.*]] = "tf.Reshape"(%[[TRANSPOSE1:.*]], %[[CONST2:.*]]) : (tensor<4x2x4x2x3x64xf32>, tensor<4xi64>) -> tensor<8x8x3x64xf32>
    // CHECK: %[[CONST3:.*]] = "tf.Const"() <{value = dense<

  %0 = "tf.Relu"(%arg0) : (tensor<1xi32>) -> tensor<1xi32>
  func.return %0: tensor<1xi32>

// CHECK-LABEL: testReluI32
// CHECK:  %[[CONST_0:.*]] = arith.constant dense<0> : tensor<i32>
// CHECK:  %[[RES0:.*]] = "tfl.maximum"(%arg0, %[[CONST_0]]) : (tensor<1xi32>, tensor<i32>) -> tensor<1xi32>
// CHECK:  return %[[RES0]] : tensor<1xi32>
}

func.func @testReluI64(%arg0: tensor<1xi64>) -> tensor<1xi64> {

  // considered dynamic so use -1 here if k is not a constant value.
  int const_k = -1;
  ElementsAttr cst;
  if (matchPattern(k, m_Constant(&cst)))
    // These casts should all be valid due to how Tensor constants are stored.
    // TODO(jpienaar): This should use a helper function.
    const_k = cst.getValues<IntegerAttr>()[0].getValue().getSExtValue();

	{name: "ConstNil", typ: "BytePtr"},   // nil pointer
	{name: "Const8", aux: "Int8"},        // auxint is sign-extended 8 bits
	{name: "Const16", aux: "Int16"},      // auxint is sign-extended 16 bits
	{name: "Const32", aux: "Int32"},      // auxint is sign-extended 32 bits
	// Note: ConstX are sign-extended even when the type of the value is unsigned.
	// For instance, uint8(0xaa) is stored as auxint=0xffffffffffffffaa.

}

// CHECK-LABEL: xla_conv_v2
func.func @xla_conv_v2(%arg0: tensor<4x8x8x16xf32>) -> tensor<4x8x8x16xf32> {
  %0 = "tf.Const"() {value = dense<1.000000e+00> : tensor<3x3x16x16xf32>} : () -> tensor<3x3x16x16xf32> loc("Const_1")
  %1 = "tf.Const"() {value = dense<1> : tensor<i32>} : () -> tensor<i32> loc("XlaConv/feature_group_count")
  %2 = "tf.Const"() {value = dense<1> : tensor<2x2xi32>} : () -> tensor<2x2xi32> loc("XlaConv/padding")

This improves the readability of assembly code, and keeps it robust to
changes in data layout either in the Go type definitions or in the
layout rules used by the Go compiler.
</p>

<p>
Constants are of the form <code>const_<i>name</i></code>.
For example, given the Go declaration <code>const bufSize =
1024</code>, assembly code can refer to the value of this constant
as <code>const_bufSize</code>.
</p>

<p>

(Rsh8Ux64 x (Const64 [c])) && uint64(c) < 8 => (SRLconst (SLLconst <typ.UInt32> x [24]) [int32(c+24)])

// large constant shifts
(Lsh32x64 _ (Const64 [c])) && uint64(c) >= 32 => (Const32 [0])
(Rsh32Ux64 _ (Const64 [c])) && uint64(c) >= 32 => (Const32 [0])
(Lsh16x64 _ (Const64 [c])) && uint64(c) >= 16 => (Const16 [0])
(Rsh16Ux64 _ (Const64 [c])) && uint64(c) >= 16 => (Const16 [0])
(Lsh8x64 _ (Const64 [c])) && uint64(c) >= 8 => (Const8 [0])

          func {
            name: "__inference_signature_wrapper_13"
          }
        }
      }
    }
    node {
      name: "NoOp"
      op: "NoOp"
    }
    node {
      name: "Const_1"
      op: "Const"
      device: "/device:CPU:0"
      attr {
        key: "_output_shapes"
        value {
          list {
            shape {
            }
          }
        }
      }