$multiply_linear_by_lr,
       (Clamp $src_op,
         (TF_NegOp (TF_MulOp $l1, $lr)),
         (CreateTFReadVariableOp $src_op, $l1, $linear),
         (TF_MulOp $l1, $lr)
       ),
       (Clamp $src_op,
         (TF_NegOp $l1),
         (CreateTFReadVariableOp $src_op, $l1, $linear),
         $l1
       )
     ),
     (CreateTFReadVariableOp $src_op, $l1, $linear)
   ),

  void runOnOperation() override;
};

template <typename SrcOp>
class DequantizeConverter : public OpRewritePattern<SrcOp> {
 public:
  using OpRewritePattern<SrcOp>::OpRewritePattern;

  LogicalResult matchAndRewrite(SrcOp srcop,
                                PatternRewriter &rewriter) const final {
    Operation *op = srcop.getOperation();
    bool allTypesFp = true;
    bool allTypesQuantizedOrInt = true;

def LegalizeSelectV2SameStaticShape : Pat<(TF_SelectV2Op:$src_op $cond, $x, $y),
    (TFL_SelectOp $cond, $x, $y),
    [(OpHasSameStaticShapes $src_op)]>;
def LegalizeSelectV2NotSameStaticShape : Pat<
  (TF_SelectV2Op:$src_op $cond, $x, $y),
  (TFL_SelectV2Op $cond, $x, $y),
  [(OpHasNotSameStaticShapes $src_op)]>;
def LegalizeShape : Pat<(TF_ShapeOp $arg), (TFL_ShapeOp $arg)>;

template <typename SrcOpT, typename FusedOpT>
class FuseContractionWithBiasAdd : public OpRewritePattern<SrcOpT> {
 public:
  using OpRewritePattern<SrcOpT>::OpRewritePattern;
  // Class users should override this method if there are any op-specific
  // compatibility requirements between the contraction op and the BiasAdd op.
  virtual bool AreFuseCompatible(SrcOpT contraction_op, BiasAddOp bias_add,

             UnpackOp::getOperationName(), PackOp::getOperationName()}) {}

  LogicalResult matchAndRewrite(Operation *src_op,
                                PatternRewriter &rewriter) const override {
    auto op = cast<OpT>(src_op);

    // Static output type is used to compute intermediate values. Note that the
    // output type doesn't have to be static but if input types and indices are

class LowerInitializationOp<Op FromOp, int initial_val>
  : Pat<(FromOp:$src_op
         TensorOf<[AnyInteger, AnyFloat, AnyComplex]>:$input),
        (TF_BroadcastToOp (TF_ConstOp (GetScalarOfType<initial_val> $input)),
                          (CreateTFShapeOp $src_op, $input,
                                           /*use 32bit*/ConstBoolAttrFalse))>;

	var tw timeoutWriter
	tw, w = newTimeoutWriter(w)

	// Make a copy of request and work on it in new goroutine
	// to avoid race condition when accessing/modifying request (e.g. headers)
	rCopy := r.Clone(r.Context())
	go func() {
		defer func() {
			err := recover()
			// do not wrap the sentinel ErrAbortHandler panic value
			if err != nil && err != http.ErrAbortHandler {

		if !compatibleValueTypes(minType, t) {
			return nil, fmt.Errorf("incompatible types: %v %v", *minType, *t)
		}
		if ratio, _ := Scale(1, t.Unit, minType.Unit); ratio < 1 {
			minType = t
		}
	}
	rcopy := *minType
	return &rcopy, nil
}

func compatibleValueTypes(v1, v2 *profile.ValueType) bool {
	if v1 == nil || v2 == nil {
		return true // No grounds to disqualify.
	}
	// Remove trailing 's' to permit minor mismatches.

                                          broadcasted_rhs);
    return success();
  }

  LogicalResult matchAndRewrite(SourceOp src_op,
                                PatternRewriter& rewriter) const override {
    Operation* op = static_cast<Operation*>(src_op);
    auto lhs = op->getOperand(0);
    auto rhs = op->getOperand(1);

    if (!mlir::cast<ShapedType>(lhs.getType()).hasStaticShape() ||

		t.Error("Clone should not have made a copy")
	}

	// Clone should not make a copy of s, since s is a static string.
	sCopy := UserArenaClone(s)
	if unsafe.StringData(s) != unsafe.StringData(sCopy) {
		t.Error("Clone should not have made a copy")
	}

	a.Free()
}

func TestUserArenaClonePointer(t *testing.T) {
	a := NewUserArena()