OpList& ops, bool include_internal,
    const std::vector<string>& api_def_dirs);

// Converts:
//   bazel-out/.../(bin|genfiles)/(external/YYY/)?XX
// to: XX.
string GetPath(StringPiece dot_h_fname);

// Converts: some/path/to/file.xx
// to: file
// (note that suffix is removed)
string GetFilename(StringPiece path);

// Converts:
//   cc/ops/gen_foo_ops.h
// to:
//   CC_OPS_GEN_FOO_OPS_H_

#ifndef TENSORFLOW_COMPILER_MLIR_LITE_UTILS_SIZE_UTILS_H_
#define TENSORFLOW_COMPILER_MLIR_LITE_UTILS_SIZE_UTILS_H_

#include <cstdint>

namespace mlir {
namespace TFL {

// Converts a TF size (64-bit) to TFLite (32-bit) and properly converts TF's
// value for dynamic size (`std::numeric_limits<int64_t>::min()`) to the
// TFLite-specific value.
int32_t ConvertToTfliteSize(int64_t size);

}  // namespace TFL
}  // namespace mlir

/**
 * Resolves a path object relative to some base directory.
 */
public interface RelativeFilePathResolver {
    /**
     * Converts the given path to a relative path.
     */
    String resolveAsRelativePath(Object path);

    /**
     * Converts the given path to a path that is useful to display to a human, for example in logging or error reports.

namespace tensorflow {

using tsl::StatusOr;

// Converts non func AttrValue proto into an MLIR attribute. Func attribute is
// exclused in this function because the function might be renamed when the
// function definition is imported.
absl::StatusOr<mlir::Attribute> ConvertNonFuncAttributeValue(
    const AttrValue& value, mlir::Builder* builder);

// Converts all kinds of AttrValue proto into an MLIR attribute.

		if pp != p2[i] {
			return false
		}
	}
	return true
}

// ToYAMLPath converts a path string to path such that the first letter of each path element is lower case.
func ToYAMLPath(path string) Path {
	p := PathFromString(path)
	for i := range p {
		p[i] = firstCharToLowerCase(p[i])
	}
	return p
}

// ToYAMLPathString converts a path string such that the first letter of each path element is lower case.

#include "absl/strings/string_view.h"

namespace mlir::tensorflow_to_stablehlo::pywrap {

// Converts a TensorFlow SavedModel to a StableHLO MLIR module and serializes it
// to bytecode.
//
// Args:
//   input_path: The path to the SavedModel directory.
//    exported_model_signatures: Comma-separated list of exported model
//   signatures to convert. tag_names: Comma-separated list of tags for loading
//    SavedModel.

  else
    input_tensor.AsProtoField(&tensor_proto);
  return tensor_proto;
}

static std::string MangleTensor(const Tensor& tensor) {
  return mangling_util::MangleTensor(ConvertToProto(tensor));
}

// Converts a TensorFlow tensor into an MLIR elements attribute.
template <typename T>
absl::StatusOr<ElementsAttr> ConvertFlatTensor(const Tensor& input_tensor,
                                               ShapedType type) {

	synthesized.ReadonlyPaths = securitycontext.ConvertToRuntimeReadonlyPaths(effectiveSc.ProcMount)

	return synthesized, nil
}

// convertToRuntimeSecurityContext converts v1.SecurityContext to runtimeapi.SecurityContext.
func convertToRuntimeSecurityContext(securityContext *v1.SecurityContext) *runtimeapi.LinuxContainerSecurityContext {
	if securityContext == nil {
		return nil
	}

import org.gradle.api.NonNullApi;

import java.io.File;
import java.net.URI;
import java.net.URISyntaxException;

/**
 * Converts a wrapper distribution url to a URI.
 */
@NonNullApi
public class WrapperDistributionUrlConverter {
    /**
     * Converts the given distribution url to a URI.
     * <p>
     * If the url is relative, it is resolved against the given file root.

	return runtimeapi.Protocol_TCP
}

// toKubeContainer converts runtimeapi.Container to kubecontainer.Container.
func (m *kubeGenericRuntimeManager) toKubeContainer(c *runtimeapi.Container) (*kubecontainer.Container, error) {
	if c == nil || c.Id == "" || c.Image == nil {
		return nil, fmt.Errorf("unable to convert a nil pointer to a runtime container")
	}