// Insert ConvertOp if it does not exist yet. Otherwise, just rewire without
    // creating a ConvertOp.
    for (const OpOperand& connected_op : op.getResult().getUses()) {
      ConvertOp convert_op =
          dyn_cast_or_null<ConvertOp>(connected_op.getOwner());
      // ConvertOp already exists. Rewire the existing convert op into f16.

}

def ConvertFuncToBfloat16Pass : Pass<"stablehlo-convert-func-to-bfloat16", "mlir::func::FuncOp"> {
  let summary = "Convert a StableHLO function to bfloat16";
  let dependentDialects = ["mlir::stablehlo::StablehloDialect"];
}

def ConvertXlaCallModuleOpToBfloat16Pass : Pass<"stablehlo-convert-xla-call-module-op-to-bfloat16", "mlir::func::FuncOp"> {
  let summary = "Convert serialized XlaCallModuleOp to bfloat16";

    tensor_names->insert(coo_sparse.values_tensor_name());
    tensor_names->insert(coo_sparse.indices_tensor_name());
    tensor_names->insert(coo_sparse.dense_shape_tensor_name());
  } else if (tensor_info.has_composite_tensor()) {
    for (const auto& component : tensor_info.composite_tensor().components()) {
      tensor_names->insert(component.name());
    }
  } else {

  auto results = call.getResults();
  auto block_args = entry->getArguments();
  auto yield_args = std::vector<Value>();
  yield_args.insert(yield_args.end(), results.begin(), results.end());
  if (forward_block_args) {
    yield_args.insert(yield_args.end(), block_args.begin(), block_args.end());
  }
  return builder.create<YieldOp>(loc, yield_args);
}

  }

  // Collect all the registered attributes.
  llvm::DenseSet<llvm::StringRef> registered_attrs;
  registered_attrs.insert("name");
  registered_attrs.insert("device");
  for (const auto& attr_def : op_reg_data->op_def.attr()) {
    registered_attrs.insert(attr_def.name());
  }
  // Attributes are not in the registered attributes set will be ignored.
  for (auto& attr : inst->getAttrs()) {

						return true, proto.Clone(lp.Value).(*listener.ListenerFilter)
					}
					return false, nil
				},
			)
		} else if lp.Operation == networking.EnvoyFilter_Patch_INSERT_BEFORE {
			// insert before without a filter match is same as insert in the beginning
			if !hasListenerFilterMatch(lp) {
				lis.ListenerFilters = append([]*listener.ListenerFilter{proto.Clone(lp.Value).(*listener.ListenerFilter)}, lis.ListenerFilters...)
				continue

      const bool patch =
          (m.op_index >= remat.insert) && (m.op_index < remat.insert + len);
      // Are we past the insertion portion of the new operation sequence?
      // Then we need to convert indices back to the original sequence.
      const int shift = (m.op_index >= remat.insert + len) ? len : 0;
      m.size += patch ? 0 : operations_[m.op_index - shift].alloc;

	return int64(val), err
}

// Convert cgroup v1 cpu.shares value to cgroup v2 cpu.weight
// https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/2254-cgroup-v2#phase-1-convert-from-cgroups-v1-settings-to-v2
func CpuSharesToCpuWeight(cpuShares uint64) uint64 {
	return uint64((((cpuShares - 2) * 9999) / 262142) + 1)
}

// Convert cgroup v2 cpu.weight value to cgroup v1 cpu.shares

			t.Errorf("can't convert RC to RS: %v", err)
			continue
		}
		// Round-trip RS before converting back to RC.
		rs = roundTripRS(t, rs)
		out := &v1.ReplicationController{}
		if err := corev1.Convert_apps_ReplicaSet_To_v1_ReplicationController(rs, out, nil); err != nil {
			t.Errorf("can't convert RS to RC: %v", err)
			continue
		}

  op->walk([&](Operation *op) {
    if (op->getDialect()->getNamespace() != "vhlo") return;

    // Convert operands
    rewriter.modifyOpInPlace(op, [&]() {
      rewriter.setInsertionPoint(op);
      WrapOperandsInUnrealizedCastAndConvert(op, converter, rewriter);

      // Convert op types
      for (auto value : op->getResults()) {
        rewriter.setInsertionPointAfter(value.getDefiningOp());