#define TENSORFLOW_C_EAGER_TRACING_UTILS_H_

#include "tensorflow/c/eager/abstract_operation.h"

namespace tensorflow {
namespace tracing {
Status MaybeSetOpName(AbstractOperation*, const char* op_name);
}  // namespace tracing
}  // namespace tensorflow

    auto custom_op = llvm::dyn_cast_or_null<CustomOp>(op);
    if (!custom_op) return false;

    // Custom op which is marked in the custom op map is quantizable.
    std::string op_name = custom_op.getCustomCode().str();
    return (custom_op_map.find(op_name) == custom_op_map.end()) ? false : true;
  }

  static bool AllowDynamicRangeQuantizedOperand(
      Operation* quantized_op, const quant::CustomOpMap& custom_op_map) {

  OpBuilder builder(func);

  func.walk([&](Operation *op) {
    if (op->hasTrait<OpTrait::IsTerminator>()) return;
    auto op_name = op_to_name_(op);

    // Check the named info collection first.
    auto it = name_to_info_.find(op_name);
    if (it != name_to_info_.end()) {
      ImportAsStatsOps(builder, op, it->second.first, it->second.second);
      return;
    }

// The consolidated logic to verify if each final op is acceptable or not.
// Also see `PrintOpStatsPass` and `CheckAcceptedOpsPass`.
bool IsAcceptedOp(llvm::StringRef dialect_name, llvm::StringRef op_name,
                  const std::vector<std::string> &accepted_dialects);

}  // namespace odml
}  // namespace mlir

    public companion object {
        public val EP_NAME: ExtensionPointName<KaResolveExtensionProvider> =
            ExtensionPointName<KaResolveExtensionProvider>("org.jetbrains.kotlin.kaResolveExtensionProvider")

        public fun provideExtensionsFor(module: KtModule): List<KaResolveExtension> {
            return EP_NAME.getExtensionList(module.project).flatMap { it.provideExtensionsFor(module) }
        }
    }

  return std::find(accepted_dialects.begin(), accepted_dialects.end(),
                   dialect_name) != accepted_dialects.end();
}

bool IsAcceptedOp(llvm::StringRef dialect_name, llvm::StringRef op_name,
                  const std::vector<std::string>& accepted_dialects) {
  return IsAcceptedDialect(dialect_name, accepted_dialects);
}

}  // namespace odml

        op_state.operands[1] = shape_op;
      }
    }
  }
  if (op_name == "vhlo.reduce_v1" || op_name == "vhlo.reduce_window_v1" ||
      op_name == "vhlo.sort_v1" || op_name == "vhlo.scatter_v1") {
    op_state.addRegion();
  }
  if (op_name == "vhlo.while_v1") {
    op_state.addRegion();
    op_state.addRegion();
  }

// `op_type` must outlive `op`.
void TF_AbstractOpSetOpType(TF_AbstractOp* op, const char* const op_type,
                            TF_Status* s);
// `op_name` must outlive `op`.
void TF_AbstractOpSetOpName(TF_AbstractOp* op, const char* const op_name,
                            TF_Status* s);
// `attr_name` must outlive `op`.
void TF_AbstractOpSetAttrType(TF_AbstractOp* op, const char* const attr_name,

    public companion object {
        public val EP_NAME: ExtensionPointName<AdditionalKDocResolutionProvider> =
            ExtensionPointName<AdditionalKDocResolutionProvider>("org.jetbrains.kotlin.analysis.additionalKDocResolutionProvider")

        public fun resolveKdocFqName(analysisSession: KaSession, fqName: FqName, contextElement: KtElement): Collection<KaSymbol> =

            KotlinCoreEnvironment.underApplicationLock {
                if (applicationArea.hasExtensionPoint(ClassTypePointerFactory.EP_NAME)) return@underApplicationLock
                CoreApplicationEnvironment.registerApplicationExtensionPoint(
                    ClassTypePointerFactory.EP_NAME,
                    ClassTypePointerFactory::class.java
                )