#  ifdef CU_DLL
#    ifdef CU_BUILD_DLL
#      define CU_EXPORT __declspec(dllexport)
#    else
#      define CU_EXPORT __declspec(dllimport)
#    endif
#  else
#    define CU_EXPORT
#  endif
#  if _MSC_VER < 1900
#    define snprintf _snprintf
#  endif
#else
#  define CU_EXPORT
#endif  /* WIN32 */

#include "CUError.h"

                return new File(path).exists();
            }
        });
        lines.addAll(collect(validHeaderDirs, path -> "\tumbrella \"" + path + "\""));
        lines.add("\texport *");
        lines.add("}");
        try {
            Files.createParentDirs(moduleMapFile);
            FileUtils.writeLines(moduleMapFile, lines);
        } catch (IOException e) {

  void  CU_free(void *ptr, unsigned int uiLine, const char* szFileName);
  void* CU_realloc(void *ptr, size_t size, unsigned int uiLine, const char* szFileName);
  CU_EXPORT void CU_dump_memory_usage(const char*);

  /** c-allocate with memory tracking. */
  #define CU_CALLOC(x, y)         CU_calloc((x), (y), __LINE__, __FILE__)
  /** m-allocate with memory tracking. */

#include "tensorflow/core/protobuf/saver.pb.h"

namespace mlir::quant::stablehlo {

// Suffix string for the module export step. Used for debugging.
constexpr absl::string_view kExportStepSuffix = "_export";

// Options when running passes for exporting an MLIR ModuleOp.
struct ExportOptions {
  // If set to `true`, it runs `DuplicateShapeDeterminingConstantsPass` before
  // lowering to tf_executor dialect.

// .go_export section.
func readpkglist(shlibpath string) (pkgs []*load.Package) {
	var stk load.ImportStack
	if cfg.BuildToolchainName == "gccgo" {
		f, err := elf.Open(shlibpath)
		if err != nil {
			base.Fatal(fmt.Errorf("failed to open shared library: %v", err))
		}
		defer f.Close()
		sect := f.Section(".go_export")
		if sect == nil {

// Expm1 op patterns.
//===----------------------------------------------------------------------===//

// Expm1(x) = Exp(x) - 1
def LowerExp1mOp : Pat<
  (TF_Expm1Op $x),
  (TF_SubOp
    (TF_ExpOp $x),
    (TF_ConstOp (GetScalarOfType<1> $x))
  )>;

//===----------------------------------------------------------------------===//
// MatrixBandPart op patterns.

foreach Mapping = [
                   [TF_AbsOp, MHLO_AbsOp],
                   [TF_CeilOp, MHLO_CeilOp],
                   [TF_ComplexAbsOp, MHLO_AbsOp],
                   [TF_CosOp, MHLO_CosineOp],
                   [TF_ExpOp, MHLO_ExpOp],
                   [TF_Expm1Op, MHLO_Expm1Op],
                   [TF_ErfOp, MHLO_ErfOp],
                   [TF_FloorOp, MHLO_FloorOp],
                   [TF_ImagOp, MHLO_ImagOp],

def LegalizeUnique : Pat<(TF_UniqueOp $arg0),(TFL_UniqueOp $arg0)>;

def LegalizeFloorMod : Pat<(TF_FloorModOp $arg0, $arg1),
                           (TFL_FloorModOp $arg0, $arg1)>;
def LegalizeExp : Pat<(TF_ExpOp $arg0), (TFL_ExpOp $arg0)>;

def LegalizeLRN : Pat<
  (TF_LRNOp $arg0, $radius, F32Attr:$bias, F32Attr:$alpha, F32Attr:$beta),
  (TFL_LocalResponseNormalizationOp $arg0, (convertIntAttrTo32Bit $radius),

foreach Mapping = [[MHLO_AbsOp, TF_AbsOp],
                   [MHLO_BitcastConvertOp, TF_BitcastOp],
                   [MHLO_CeilOp, TF_CeilOp],
                   [MHLO_CosineOp, TF_CosOp],
                   [MHLO_ExpOp, TF_ExpOp],
                   [MHLO_Expm1Op, TF_Expm1Op],
                   [MHLO_FloorOp, TF_FloorOp],
                   [MHLO_ImagOp, TF_ImagOp],
                   [MHLO_IsFiniteOp, TF_IsFiniteOp],

    indicating its preferred use in language bindings for TensorFlow. What was
    previously `TF_Session` has been renamed to `TF_DeprecatedSession`.
*   Renamed `TF_Port` to `TF_Output` in the C API.
*   Removes RegisterShape from public API. Use C++ shape function registration
    instead. indexing now starts from 1 instead of 0, and `bus_id==0` is used