$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)
   ),

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)>;

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))>;

		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() ||

				// same test runs 3 times, make copy of objects to have unique ones
				evictionCopy := tc.eviction.DeepCopy()
				prcCopy := tc.prc.DeepCopy()
				var pdbsCopy []runtime.Object
				for _, pdb := range tc.pdbs {
					pdbCopy := pdb.DeepCopyObject()

                               ranked_ty.getEncoding());
}

template <typename SrcOpT, typename DstOpT>
class LowerControlFlowOp : public OpConversionPattern<SrcOpT> {
 public:
  using OpConversionPattern<SrcOpT>::OpConversionPattern;

  LogicalResult matchAndRewrite(
      SrcOpT op, typename SrcOpT::Adaptor adaptor,
      ConversionPatternRewriter &rewriter) const override {
    DstOpT mhlo_op;