var recvTyp Type = ityp
		if def != nil {
			if named := asNamed(def.typ); named != nil {
				recvTyp = named
			}
		}
		sig.recv = NewVar(name.Pos(), check.pkg, "", recvTyp)

		m := NewFunc(name.Pos(), check.pkg, name.Name, sig)
		check.recordDef(name, m)
		ityp.methods = append(ityp.methods, m)
	}

	// All methods and embedded elements for this interface are collected;

			},
		)
		setupInformer(opts, inf)
		return inf
	})
}

func setupInformer(opts ktypes.InformerOptions, inf cache.SharedIndexInformer) {
	// It is important to set this in the newFunc rather than after InformerFor to avoid
	// https://github.com/kubernetes/kubernetes/issues/117869
	if opts.ObjectTransform != nil {
		_ = inf.SetTransform(opts.ObjectTransform)
	} else {

		// error.Error() string
		recv := NewVar(nopos, nil, "", typ)
		res := NewVar(nopos, nil, "", Typ[String])
		sig := NewSignatureType(recv, nil, nil, nil, NewTuple(res), false)
		err := NewFunc(nopos, nil, "Error", sig)

		// interface{ Error() string }
		ityp := &Interface{methods: []*Func{err}, complete: true}
		computeInterfaceTypeSet(nil, nopos, ityp) // prevent races due to lazy computation of tset

		// error.Error() string
		recv := NewVar(nopos, nil, "", typ)
		res := NewVar(nopos, nil, "", Typ[String])
		sig := NewSignatureType(recv, nil, nil, nil, NewTuple(res), false)
		err := NewFunc(nopos, nil, "Error", sig)

		// interface{ Error() string }
		ityp := &Interface{methods: []*Func{err}, complete: true}
		computeInterfaceTypeSet(nil, nopos, ityp) // prevent races due to lazy computation of tset

  function_builder.create<mlir::func::ReturnOp>(new_func.getLoc(),
                                                return_operands);
  ops_added.func_op = new_func;
  module.push_back(new_func);
  return new_func;
}

void ExtractSubgraphToFunc(const Subgraph& subgraph, OpBuilder& builder,
                           ModuleOp& module, OpsAdded& ops_added) {
  func::FuncOp func = BuildFuncOp(subgraph, builder, module, ops_added);

	ratioedOpts := opts.TimingHistogramOpts
	ratioedOpts.InitialValue /= opts.InitialDenominator
	th := compbasemetrics.NewTestableTimingHistogram(nowFunc, &ratioedOpts)
	return &TimingRatioHistogram{
		Registerable: th,
		timingRatioHistogramInner: timingRatioHistogramInner{
			nowFunc:         nowFunc,
			getGaugeOfRatio: func() Gauge { return th },
			numerator:       opts.InitialValue,
			denominator:     opts.InitialDenominator,
		}}
}

    // Set the function to private and insert to the module.
    func::FuncOp new_func = func.clone();
    new_func.setPrivate();
    symbol_table.insert(new_func);

    // For consistency, we require all quantized composite function to have
    // the "tf_quant.quantized_ops" attribute.
    if (!new_func.getSymName().starts_with("quantized_")) continue;
    if (!new_func->hasAttrOfType<ArrayAttr>("tf_quant.quantized_ops")) {

  auto name = rewriter.getStringAttr("gelu_decomp");
  func::FuncOp new_func = rewriter.create<func::FuncOp>(
      insertion_point->front().getLoc(), name, ftype);
  new_func.setPrivate();
  new_func.addEntryBlock();
  rewriter.setInsertionPointToStart(&new_func.getBody().front());

  auto one_val = DenseElementsAttr::get(type, kOne);
  auto one_cst =

        if (StringUtil.isBlank(enc)) {
            return defaultEncoding;
        }

        final String newEnc = encodingMap.get(toLowerCase(enc));
        if (StringUtil.isBlank(newEnc)) {
            return enc;
        }
        return newEnc;
    }

    public void setDefaultEncoding(final String defaultEncoding) {
        this.defaultEncoding = defaultEncoding;
    }

								if field.AutoUpdateTime == schema.UnixNanosecond {
									value = stmt.DB.NowFunc().UnixNano()
								} else if field.AutoUpdateTime == schema.UnixMillisecond {
									value = stmt.DB.NowFunc().UnixMilli()
								} else if field.AutoUpdateTime == schema.UnixSecond {
									value = stmt.DB.NowFunc().Unix()
								} else {
									value = stmt.DB.NowFunc()
								}
								isZero = false
							}