void ConvertTFQuantTypes::runOnOperation() {
  TFQuantTypeConverter converter;
  RewritePatternSet patterns(&getContext());
  patterns.add<TFQuantTypePattern>(&getContext(), converter);
  patterns.add<TFConstOpQuantToIntPattern, TFUniformQuantizedOpsPattern>(
      &getContext());
  populateFunctionOpInterfaceTypeConversionPattern<func::FuncOp>(patterns,
                                                                 converter);

	iv.mu.RLock()
	defer iv.mu.RUnlock()

	patterns, exists := iv.patternsByNamespace[namespace]
	if !exists {
		return false
	}

	for _, pattern := range patterns.UnsortedList() {
		match, err := regexp.MatchString(pattern, name)
		if err != nil {
			continue
		}
		if match {
			return true
		}
	}
	return false
}

func (v *Validator) ValidateCustomResourceYAML(data string, ignorer *ValidationIgnorer) error {

  }

  return false;
}

// Compute heavy patterns should be quantized for both server and ODML targets.
// Most patterns here are useful when quantized since they are compute heavy
// or memory bound.
void PopulateCommonQuantizationPatterns(
    MLIRContext& ctx, RewritePatternSet& patterns,
    const bool enable_per_channel_quantized_weight) {
  patterns.add<XlaCallModuleOpToCallOp<QuantizeConvolutionOpPattern>>(

env GO111MODULE=on

# File system pattern searches should skip sub-modules and vendor directories.
cd x

# all packages
go list all
stdout ^m$
stdout ^m/vendor$
! stdout vendor/
stdout ^m/y$
! stdout ^m/y/z

# path pattern
go list m/...
stdout ^m$
stdout ^m/vendor$
! stdout vendor/
stdout ^m/y$
! stdout ^m/y/z

# directory pattern
go list ./...
stdout ^m$
stdout ^m/vendor$
! stdout vendor/

   (HasEqualElementSize<[-1], [0]> $conv_out, $add_rhs)], [], (addBenefit -1)>;

// Convert conv+sub+mul pattern to conv+mul+add.
// (conv - sub) * mul -> conv * mul + (-sub) * mul
//
// This is needed to support Conv+BatchNorm pattern from Jax models converted
// using jax2tf w/o native serialization. Note that Jax2tf patterns always
// extend bias shapes to a rank of 4, e.g. 1x1x1x5.
def ConvertSubMulToMulAdd : Pat<
  (TF_MulOp

	var patterns []string
	for _, pattern := range got.GetPatterns() {
		var pat string
		switch typ {
		case "prefix":
			pat = pattern.GetPrefix()
		case "suffix":
			pat = pattern.GetSuffix()
		case "regexp":
			// Migration tracked in https://github.com/istio/istio/issues/17127
			//nolint: staticcheck
			pat = pattern.GetSafeRegex().GetRegex()
		}

		if pat != "" {

    return success();
  }
};

void GpuOpFusionPass::runOnOperation() {
  func::FuncOp func = getOperation();
  RewritePatternSet patterns(&getContext());
  patterns.add<ReluToFusedBatchNorm>(&getContext());
  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateGpuOpFusionPass() {
  return std::make_unique<GpuOpFusionPass>();

        PatternSet patterns = new PatternSet();
        // if you would like to add more endings to this pattern, make sure to also edit DefaultCppComponent.java and default.vcxproj.filters
        patterns.include("**/*.h");
        patterns.include("**/*.hpp");
        patterns.include("**/*.h++");
        patterns.include("**/*.hxx");
        patterns.include("**/*.hm");
        patterns.include("**/*.inl");

			}
			bits = 0
		case '+', '-':
			if c == '+' && result == false {
				// Have already seen a -. Should be - from here on.
				return nil, &parseError{"invalid pattern syntax (+ after -): " + pattern}
			}
			if i > 0 {
				n := (i - start) * wid
				if n > 64 {
					return nil, &parseError{"pattern bits too long: " + pattern}
				}
				if n <= 0 {

// Variadic op patterns.
//===----------------------------------------------------------------------===//

def : Pat<(MHLO_ConcatenateOp $inputs, $dim),
          (TF_ConcatV2Op $inputs, (TF_ConstOp $dim))>;

//===----------------------------------------------------------------------===//
// Compare op patterns.
// Note that these are legalized from chlo.broadcast_* ops, since those are