code: def _decompose_no_control_values(
      op: "operation.Operator",
  ) -> List["operation.Operator"]:
      """Provides a decomposition without considering control values. Returns None if
      no decomposition.
      """
      if len(op.control_wires) == 1 and hasattr(op.base, "_controlled"):
          result = op.base._controlled(op.control_wires[0])
          # disallow decomposing to itself
          # pylint: disable=unidiomatic-typecheck
          if type(result) != type(op):
              return [result]
          qml.QueuingManager.remove(result)
      if isinstance(op.base, qml.PauliX):
          # has some special case handling of its own for further decomposition
          return [
              qml.MultiControlledX(
                  wires=op.active_wires, work_wires=op.work_wires
              )
          ]
      if _is_single_qubit_special_unitary(op.base):
          if (
              len(op.control_wires) >= 2
              and qmlmath.get_interface(*op.data) == "numpy"
          ):
              return ctrl_decomp_bisect(op.base, op.control_wires)
          return ctrl_decomp_zyz(op.base, op.control_wires)
  
      if not op.base.has_decomposition:
          return None
  
      base_decomp = op.base.decomposition()
      if len(base_decomp) == 0 and isinstance(op.base, qml.GlobalPhase):
          warnings.warn(
              "Controlled-GlobalPhase currently decomposes to nothing, and this will likely "
              "produce incorrect results. Consider implementing your circuit with a different set "
              "of operations, or use a device that natively supports GlobalPhase.",
              UserWarning,
          )
  
      return [
          Controlled(newop, op.control_wires, work_wires=op.work_wires)
          for newop in base_decomp
      ]
  
imports: import warnings
  from copy import copy
  from functools import wraps
  from inspect import signature
  from typing import List
  import numpy
  from scipy import sparse
  import pennylane
  from pennylane import operation
  from pennylane import math
  from pennylane.operation import Operator
  from pennylane.wires import Wires
  from pennylane.compiler import compiler
  from .symbolicop import SymbolicOp
  from .controlled_decompositions import ctrl_decomp_bisect, ctrl_decomp_zyz
label_desc: Use image node_id 3 for calling a global function with example usage: _decompose_no_control_values(op) and returns: unknown, list, ctrl_decomp_zyz, None, list, ctrl_decomp_bisect