code: def dense_strategy_cuda(attrs, inputs, out_type, target):
      """dense cuda strategy"""
      strategy = _op.OpStrategy()
      data, weights = inputs
      b, i = get_const_tuple(data.shape)
      o, _ = get_const_tuple(weights.shape)
      if (
          target.kind.name in ["cuda", "vulkan", "rocm"]
          and data.dtype == "int8"
          and weights.dtype == "int8"
          and out_type.dtype == "int32"
      ):
          strategy.add_implementation(
              wrap_compute_dense(topi.cuda.dense_int8),
              wrap_topi_schedule(topi.cuda.schedule_dense_int8),
              name="dense_int8.cuda",
          )
      else:
          # Some AMDGPU cards have accuracy issues with this schedule
          # See https://github.com/apache/tvm/issues/13666
          if target.kind.name != "rocm":
              strategy.add_implementation(
                  wrap_compute_dense(topi.gpu.dense_small_batch),
                  wrap_topi_schedule(
                      topi.gpu.schedule_dense_small_batch
                  ),
                  name="dense_small_batch.gpu",
              )
  
          with SpecializedCondition(
              target.kind.name == "rocm" or b >= 32
          ):
              strategy.add_implementation(
                  wrap_compute_dense(topi.gpu.dense_large_batch),
                  wrap_topi_schedule(
                      topi.gpu.schedule_dense_large_batch
                  ),
                  name="dense_large_batch.gpu",
                  plevel=5,
              )
  
      if target.kind.name == "cuda":
          if nvcc.have_tensorcore(target=target):
              if (
                  (
                      data.dtype in ["float16", "int8", "uint8"]
                      and (
                          (i % 16 == 0 and b % 16 == 0 and o % 16 == 0)
                          or (
                              i % 16 == 0 and b % 8 == 0 and o % 32 == 0
                          )
                          or (
                              i % 16 == 0 and b % 32 == 0 and o % 8 == 0
                          )
                      )
                  )
                  or (
                      data.dtype in ["int4", "uint4"]
                      and i % 32 == 0
                      and b % 8 == 0
                      and o % 8 == 0
                  )
                  or (
                      data.dtype in ["int1", "uint1"]
                      and i % 128 == 0
                      and b % 8 == 0
                      and o % 8 == 0
                  )
              ):
                  strategy.add_implementation(
                      wrap_compute_dense(topi.cuda.dense_tensorcore),
                      wrap_topi_schedule(
                          topi.cuda.schedule_dense_tensorcore
                      ),
                      name="dense_tensorcore.cuda",
                      plevel=20,
                  )
  
      if target.kind.name == "cuda" and "cublas" in target.libs:
          strategy.add_implementation(
              wrap_compute_dense(topi.cuda.dense_cublas),
              wrap_topi_schedule(topi.cuda.schedule_dense_cublas),
              name="dense_cublas.cuda",
              plevel=25,
          )
      return strategy
  
imports: from tvm import topi
  from tvm.auto_scheduler import is_auto_scheduler_enabled
  from tvm.contrib import nvcc
  from tvm.contrib.thrust import can_use_thrust
  from tvm.meta_schedule import is_meta_schedule_enabled
  from tvm.te import SpecializedCondition
  from ....target import Target
  from ....tir import IntImm
  from ..None import op
  from .generic import *
label_desc: Use image node_id 23 for calling a global function with example usage: dense_strategy_cuda(attrs, inputs, out_type, target) and returns: strategy