pm.enableVerifier(false);

  QuantizationSpecs quant_specs;
  quant_specs.inference_type = tensorflow::DT_QINT8;
  quant_specs.disable_per_channel = !enable_per_channel_quantization_;

  pm.addPass(CreatePreprocessOpPass(target_opset_, quantization_method_,
                                    enable_per_channel_quantization_));

  // Apply activation-weight quantization.
  if (quantization_method_ ==

  }
  PassManager pm(func_.getContext());
  ::tensorflow::applyTensorflowAndCLOptions(pm);
  pm.addNestedPass<func::FuncOp>(
      CreateFunctionalToExecutorDialectConversionPass());
  pm.addPass(CreateBreakUpIslandsPass());

  // In case of failure, the `diag_handler` converts MLIR errors emitted to
  // the MLIRContext into a tensorflow::Status.
  StatusScopedDiagnosticHandler diag_handler(func_.getContext());

  }
  AddRegionsForTflWhileOp(module);
  AddRegionsForStableHLOOp(module);
  if (!disable_vhlo_to_stablehlo) {
    mlir::PassManager pass_manager(module.getContext());
    pass_manager.addPass(mlir::odml::createLegalizeVhloToStablehloPass());
    auto result = pass_manager.run(module);
    if (failed(result)) {
      return nullptr;
    }
  }
  return OwningOpRef<mlir::ModuleOp>(module);

 * 
 * @author mbechler
 *
 */
public interface Address {

    /**
     * 
     * @param type
     * @return instance for type, null if the type cannot be unwrapped
     */
    <T extends Address> T unwrap ( Class<T> type );


    /**
     * 
     * @return the resolved host name, or the host address if it could not be resolved
     */
    String getHostName ();


    /**

 * explicitly requested), this also includes that proxy information. For secure connections the
 * address also includes the SSL socket factory, hostname verifier, and certificate pinner.
 *
 * HTTP requests that share the same [Address] may also share the same [Connection].
 */
class Address(
  uriHost: String,
  uriPort: Int,
  /** Returns the service that will be used to resolve IP addresses for hostnames. */

import com.google.common.base.Strings

class Address {
    String street

    String getNonNullStreet() {
        Strings.nullToEmpty(street)
    }

import (
	"errors"
	"syscall"
	"unsafe"
)

// An Addr represents an address associated with packet routing.
type Addr interface {
	// Family returns an address family.
	Family() int
}

// An Inet4Addr represents an internet address for IPv4.
type Inet4Addr struct {
	IP        [4]byte // IP address
	PrefixLen int     // address prefix length
}

// Family implements the Family method of Addr interface.

	"runtime"
	"syscall"
)

// An Addr represents an address associated with packet routing.
type Addr interface {
	// Family returns an address family.
	Family() int
}

// A LinkAddr represents a link-layer address.
type LinkAddr struct {
	Index int    // interface index when attached
	Name  string // interface name when attached
	Addr  []byte // link-layer address when attached
}

 * limitations under the License.
 */
package org.gradle.internal.remote;

import java.io.Serializable;

/**
 * The address for a communication endpoint. Addresses are immutable.
 */
public interface Address extends Serializable {
    /**
     * Returns the display name for this address. Implementations should also override toString() to return the display name.
     *
     * @return The display name.
     */

      mlir::tf_executor::CreateTFExecutorGraphPruningPass());
  pm.addNestedPass<mlir::func::FuncOp>(
      mlir::CreateExecutorDialectToFunctionalConversionPass());
  if (!include_variables_in_initializers) {
    pm.addPass(
        mlir::tf_saved_model::CreateRemoveVariablesInSessionInitializerPass());
  }
  pm.addNestedPass<mlir::func::FuncOp>(
      mlir::TF::