if (all_signatures_.insert({signature, spec}).second) return success();
    return failure();
  }

  KernelSpecs& WithSignature(const KernelSpecs::Signature& signature,
                             const ScaleFn& fn) {
    (void)Add(signature, {ScaleConstraintType::CustomScale, fn});
    return *this;
  }

  KernelSpecs& WithImpl(const ScaleDecomposeFn& dfn) {
    decompose_fn_ = dfn;
    return *this;
  }

 private:

LogicalResult DeviceTarget::RegisterKernel(
    llvm::StringRef kernel, const KernelSpecs::Signature& signature,
    const ScaleFn& fn, const ScaleDecomposeFn& dfn) {
  return specs_[kernel].Add(signature, {ScaleConstraintType::CustomScale, fn});
}

namespace ph = std::placeholders;

LogicalResult DeviceTarget::RegisterKernel(
    llvm::StringRef kernel, const KernelSpecs::Signature& signature,
    const ScaleConstraintType constraint) {

  all_ops.reserve(128);
  func_.walk([&](quantfork::QuantizeRegionOp op) { all_ops.push_back(op); });
  return all_ops;
}

KernelSpecs::Signature QuantizeContext::GetSignature(
    quantfork::QuantizeRegionOp op) {
  KernelSpecs::Signature signature;
  signature.reserve(op.getInputSpecs().size() + op.getOutputSpecs().size());
  for (int i = 0; i < op.getNumOperands(); ++i) {

  QuantParams GetOperandParams(Operation *op, int index) {
    return states_manager_.GetOperandParams(op, index);
  }

  // Return the signature of the op.
  KernelSpecs::Signature GetSignature(quantfork::QuantizeRegionOp op);

  // A heuristic to get quantization parameters satisfies the same scale
  // constraints:
  // - If there are immutable states,