code: def _apply_unitary_circuit(circuit: Circuit,
                             state: np.ndarray,
                             qubits: Tuple[ops.Qid, ...],
                             dtype: Type[np.number]) -> np.ndarray:
      
      qubit_map = {q: i for i, q in enumerate(qubits)}
      buffer = np.zeros(state.shape, dtype=dtype)
  
      def on_stuck(bad_op):
          return TypeError(
              'Operation without a known matrix or decomposition: {!r}'.format(
                  bad_op))
  
      unitary_ops = protocols.decompose(
          circuit.all_operations(),
          keep=protocols.has_unitary,
          intercepting_decomposer=_decompose_measurement_inversions,
          on_stuck_raise=on_stuck)
  
      for op in unitary_ops:
          indices = [qubit_map[q] for q in op.qubits]
          result = protocols.apply_unitary(
              unitary_value=op,
              args=protocols.ApplyUnitaryArgs(state, buffer, indices))
          if result is buffer:
              buffer = state
          state = result
      return state
docs: Applies a circuit's unitary effect to the given vector or matrix.
  
      This method assumes that the caller wants to ignore measurements.
  
      Args:
          circuit: The circuit to simulate. All operations must have a known
              matrix or decompositions leading to known matrices. Measurements
              are allowed to be in the circuit, but they will be ignored.
          state: The initial state tensor (i.e. superposition or unitary matrix).
              This is what will be left-multiplied by the circuit's effective
              unitary. If this is a state vector, it must have shape
              (2,) * num_qubits. If it is a unitary matrix it should have shape
              (2,) * (2*num_qubits).
          qubits: The qubits in the state tensor. Determines which axes operations
              apply to. An operation targeting the k'th qubit in this list will
              operate on the k'th axis of the state tensor.
          dtype: The numpy dtype to use for applying the unitary. Must be a
              complex dtype.
  
      Returns:
          The left-multiplied state tensor.