code: def _commute_controlled_right(op_list):
      """Push commuting single qubit gates to the right of controlled gates.
  
      Args:
          op_list (list[Operation]): The initial list of operations.
  
      Returns:
          list[Operation]: The modified list of operations with all single-qubit
          gates as far right as possible.
      """
      # We will go through the list backwards; whenever we find a single-qubit
      # gate, we will extract it and push it through 2-qubit gates as far as
      # possible to the right.
      current_location = len(op_list) - 1
  
      while current_location >= 0:
          current_gate = op_list[current_location]
  
          # We are looking only at the gates that can be pushed through
          # controls/targets; these are single-qubit gates with the basis
          # property specified.
          if current_gate.basis is None or len(current_gate.wires) != 1:
              current_location -= 1
              continue
  
          # Find the next gate that contains an overlapping wire
          next_gate_idx = find_next_gate(
              current_gate.wires, op_list[current_location + 1 :]
          )
  
          new_location = current_location
  
          # Loop as long as a valid next gate exists
          while next_gate_idx is not None:
              next_gate = op_list[new_location + next_gate_idx + 1]
  
              # Only go ahead if information is available
              if next_gate.basis is None:
                  break
  
              # If the next gate does not have control_wires defined, it is not
              # controlled so we can't push through.
              if len(next_gate.control_wires) == 0:
                  break
              shared_controls = Wires.shared_wires(
                  [Wires(current_gate.wires), next_gate.control_wires]
              )
  
              # Case 1: overlap is on the control wires. Only Z-type gates go through
              if len(shared_controls) > 0:
                  if current_gate.basis == "Z":
                      new_location += next_gate_idx + 1
                  else:
                      break
  
              # Case 2: since we know the gates overlap somewhere, and it's a
              # single-qubit gate, if it wasn't on a control it's the target.
              else:
                  if current_gate.basis == next_gate.basis:
                      new_location += next_gate_idx + 1
                  else:
                      break
  
              next_gate_idx = find_next_gate(
                  current_gate.wires, op_list[new_location + 1 :]
              )
  
          # After we have gone as far as possible, move the gate to new location
          op_list.insert(new_location + 1, current_gate)
          op_list.pop(current_location)
          current_location -= 1
  
      return op_list
  
imports: from typing import Sequence, Callable
  from pennylane.tape import QuantumTape
  from pennylane.transforms import transform
  from pennylane.wires import Wires
  from .optimization_utils import find_next_gate
label_desc: Use image node_id 1 for calling a global function with example usage: _commute_controlled_right(op_list) and returns: op_list