code: def derationalize_denom(expr):
      
      r_pos = -1
      p_pos = -1
      numerator = S.Zero
      denom_sq = S.One
      post_factors = []
      if isinstance(expr, Mul):
          for pos, factor in enumerate(expr.args):
              if isinstance(factor, Rational) and r_pos < 0:
                  r_pos = pos
                  numerator, denom_sq = factor.p, factor.q
              elif isinstance(factor, Pow) and r_pos >= 0:
                  if factor == sqrt(denom_sq):
                      p_pos = pos
                  else:
                      post_factors.append(factor)
              else:
                  post_factors.append(factor)
          if r_pos >= 0 and p_pos >= 0:
              return numerator, denom_sq, Mul(*post_factors)
          else:
              raise ValueError("Cannot derationalize")
      else:
          raise ValueError("expr is not a Mul instance")
docs: Try to de-rationalize the denominator of the given expression.
  
      The purpose is to allow to reconstruct e.g. ``1/sqrt(2)`` from
      ``sqrt(2)/2``.
  
      Specifically, this matches `expr` against the following pattern::
  
          Mul(..., Rational(n, d), Pow(d, Rational(1, 2)), ...)
  
      and returns a tuple ``(numerator, denom_sq, post_factor)``, where
      ``numerator`` and ``denom_sq`` are ``n`` and ``d`` in the above pattern (of
      type `int`), respectively, and ``post_factor`` is the product of the
      remaining factors (``...`` in `expr`). The result will fulfill the
      following identity::
  
          (numerator / sqrt(denom_sq)) * post_factor == expr
  
      If `expr` does not follow the appropriate pattern, a :exc:`ValueError` is
      raised.