}
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateConvertTfXlaOpToTfOpPass() {
  return std::make_unique<ConvertTfXlaOpToTfOpPass>();
}

static PassRegistration<ConvertTfXlaOpToTfOpPass> pass;

}  // namespace quant

std::unique_ptr<OperationPass<ModuleOp>> CreateAlternativeSubgraphPass(
    llvm::ArrayRef<std::string> device_specs) {
  return std::make_unique<AlternativeSubgraphPass>(device_specs);
}

static PassRegistration<AlternativeSubgraphPass> pass;

}  // namespace tac
}  // namespace TFL

    bool skip_raise_cpu_ops, bool ignore_inference_type) {
  return std::make_unique<RaiseTargetSubgraphsPass>(skip_raise_cpu_ops,
                                                    ignore_inference_type);
}

static PassRegistration<RaiseTargetSubgraphsPass> pass;

}  // namespace tac
}  // namespace TFL

  return erase_indices.any();
}

void ReduceWhileOperandsPass::runOnOperation() {
  auto fn = getOperation();
  fn.walk([&](TFL::WhileOp while_op) { ReduceWhileOperands(while_op); });
}

static PassRegistration<ReduceWhileOperandsPass> pass;
}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateReduceWhileOperandsPass() {
  return std::make_unique<ReduceWhileOperandsPass>();
}

}  // namespace TFL

              return !isa<TF::DumpTensorOp>(use.getOwner());
            });
      }
    }
  }

  DebuggerType debugger_type_;
  std::string log_dir_path_;
};

static PassRegistration<AddDumpTensorOpPass> pass;

void AddDumpTensorOpPass::runOnOperation() {
  MLIRContext *ctx = &getContext();
  RewritePatternSet patterns(ctx);
  ModuleOp module = getOperation();

}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreatePrepareLiftingPass(
    const OpSet target_opset) {
  return std::make_unique<PrepareLiftingPass>(target_opset);
}

static PassRegistration<PrepareLiftingPass> pass;

}  // namespace quant

}  // namespace internal

std::unique_ptr<OperationPass<func::FuncOp>> CreateFallbackToFlexOpsPass(
    const std::string &mode) {
  return std::make_unique<internal::FallbackToFlexOps>(mode);
}

static PassRegistration<internal::FallbackToFlexOps> pass([] {
  return CreateFallbackToFlexOpsPass(/*mode=*/internal::kDefaultMode);
});

}  // namespace TF

}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateUnfreezeConstantsPass() {
  return std::make_unique<UnfreezeConstantsPass>();
}

static PassRegistration<UnfreezeConstantsPass> pass([] {
  return CreateUnfreezeConstantsPass();
});

}  // namespace quant

std::unique_ptr<OperationPass<ModuleOp>>
CreateMergeInitializerFunctionOpsToMainPass() {
  return std::make_unique<MergeInitializerFunctionOpsToMainPass>();
}

// Registers MergeInitializerFunctionOpsToMainPass.
static PassRegistration<MergeInitializerFunctionOpsToMainPass> pass([] {
  return CreateMergeInitializerFunctionOpsToMainPass();
});

}  // namespace quant

        op->print(log_stream);
        VLOG(2) << log_message;
      }
    });
  }

  const QuantizationOptions& quant_options_;
};

static PassRegistration<LiftQuantizableSpotsAsFunctionsPass> pass;

#include "tensorflow/compiler/mlir/quantization/tensorflow/passes/lift_quantizable_spots_as_functions.inc"

void LiftQuantizableSpotsAsFunctionsPass::runOnOperation() {