code: def _exponentiate_general_case(pauli_term, param):
      
  
      def reverse_hack(p):
          # A hack to produce a *temporary* program which reverses p.
          revp = Program()
          revp.inst(list(reversed(p.instructions)))
          return revp
  
      quil_prog = Program()
      change_to_z_basis = Program()
      change_to_original_basis = Program()
      cnot_seq = Program()
      prev_index = None
      highest_target_index = None
  
      for index, op in pauli_term:
          if 'X' == op:
              change_to_z_basis.inst(H(index))
              change_to_original_basis.inst(H(index))
  
          elif 'Y' == op:
              change_to_z_basis.inst(RX(np.pi / 2.0, index))
              change_to_original_basis.inst(RX(-np.pi / 2.0, index))
  
          elif 'I' == op:
              continue
  
          if prev_index is not None:
              cnot_seq.inst(CNOT(prev_index, index))
  
          prev_index = index
          highest_target_index = index
  
      # building rotation circuit
      quil_prog += change_to_z_basis
      quil_prog += cnot_seq
      quil_prog.inst(RZ(2.0 * pauli_term.coefficient * param, highest_target_index))
      quil_prog += reverse_hack(cnot_seq)
      quil_prog += change_to_original_basis
  
      return quil_prog
docs: Returns a Quil (Program()) object corresponding to the exponential of
      the pauli_term object, i.e. exp[-1.0j * param * pauli_term]
  
      :param PauliTerm pauli_term: A PauliTerm to exponentiate
      :param float param: scalar, non-complex, value
      :returns: A Quil program object
      :rtype: Program