Mean 1
 Mul 164
 Pad 1
 ReadVariableOp 646
 Relu 49
 ReluGrad 49
 Reshape 2
 ResourceApplyKerasMomentum 161
 ShapeN 50
 Softmax 1
 SparseSoftmaxCrossEntropyWithLogits 1
 Square 55
 Squeeze 1
 Sub 106
 Sum 57
 Tile 1

 MaxPoolGrad 1
 Mean 1
 Mul 218
 Pad 2
 ReadVariableOp 538
 Relu 49
 ReluGrad 49
 Reshape 2
 ResourceApplyKerasMomentum 161
 Slice 1
 Softmax 1
 SparseSoftmaxCrossEntropyWithLogits 1
 Squeeze 1
 Sum 1
 Tile 1
 Transpose 1
cluster 1 size 815
 AddN 1
 AssignAddVariableOp 1
 AssignSubVariableOp 106
 Const 220
 DivNoNan 1
 Identity 1
 Mul 161
 ReadVariableOp 106
 Square 55
 Sub 106

    "Shape",
    "ShapeN",
    "Size",
    "Slice",
    "Snapshot",
    "SpaceToBatch",
    "SpaceToBatchND",
    "SpaceToDepth",
    "Split",
    "SplitV",
    "Squeeze",
    "StopGradient",
    "StridedSlice",
    "StridedSliceGrad",
    "TensorScatterAdd",
    "TensorScatterMax",
    "TensorScatterMin",
    "TensorScatterSub",
    "TensorStridedSliceUpdate",

//   shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]
//   ```
//
//   This operation requires that:
//
//   `-1-input.dims() <= dim <= input.dims()`
//
//   This operation is related to `squeeze()`, which removes dimensions of
//   size 1.
Status ExpandDims(AbstractContext* ctx, AbstractTensorHandle* const input,
                  AbstractTensorHandle* const dim,

 Fill 1
 GreaterEqual 8
 Identity 1
 Less 1
 MatMul 10
 Mul 44
 Range 1
 Rsqrt 1
 Select 19
 Shape 6
 Sigmoid 24
 Snapshot 8
 Softmax 1
 Split 8
 SplitV 6
 Square 1
 Squeeze 1
 StridedSlice 1
 Sum 2
 Tanh 17
cluster 12 size 6
 Add 1
 All 1
 Const 2
 GreaterEqual 1
 LogicalOr 1
cluster 15 size 614
 Add 22
 AddN 41
 BatchMatMulV2 2
 BiasAddGrad 8

	for len(out) > 0 {
		n := copy(out, d.storage[d.i:d.n])
		d.i += n
		out = out[n:]

		// Apply the permutation if we've squeezed the sponge dry.
		if d.i == d.rate {
			d.permute()
		}
	}

	return
}

// Sum applies padding to the hash state and then squeezes out the desired
// number of output bytes. It panics if any output has already been read.
func (d *state) Sum(in []byte) []byte {

include "mlir/IR/PatternBase.td"
include "mlir/Dialect/Arith/IR/ArithOps.td"
include "tensorflow/compiler/mlir/lite/ir/tfl_ops.td"
include "tensorflow/compiler/mlir/lite/utils/utils.td"

// Returns Squeezed shape of a ranked-tensor.
// Squeezed, here, means eliminating any 1s' in the
// dimensions of the tensor
def GetSqueezedShape: NativeCodeCall<"GetSqueezedShape($0)">;

// is then "full" and the permutation is applied to "empty" it. This process is
// repeated until all the input has been "absorbed". The input is then padded.
// The digest is "squeezed" from the sponge in the same way, except that output
// is copied out instead of input being XORed in.
//
// A sponge is parameterized by its generic security strength, which is equal

		n := len(b)
		if len(b) > cap(s.buf)-len(s.buf) {
			n = cap(s.buf) - len(s.buf)
		}
		s.copyIntoBuf(b[:n])
		b = b[n:]
	}
	return length, nil
}

// Read squeezes an arbitrary number of bytes from the sponge.
func (s *asmState) Read(out []byte) (n int, err error) {
	// The 'compute last message digest' instruction only stores the digest
	// at the first operand (dst) for SHAKE functions.