class_docstr: The base class for code-printing subclasses.
class_docstr_tok: ["The","base","class","for","code-printing","subclasses","."]
code: def _print_Mul(self, expr):
      prec = precedence(expr)
  
      c, e = expr.as_coeff_Mul()
      if c < 0:
          expr = _keep_coeff(-c, e)
          sign = "-"
      else:
          sign = ""
  
      a = []  # items in the numerator
      b = []  # items that are in the denominator (if any)
  
      pow_paren = (
          []
      )  # Will collect all pow with more than one base element and exp = -1
  
      if self.order not in ("old", "none"):
          args = expr.as_ordered_factors()
      else:
          # use make_args in case expr was something like -x -> x
          args = Mul.make_args(expr)
  
      # Gather args for numerator/denominator
      for item in args:
          if (
              item.is_commutative
              and item.is_Pow
              and item.exp.is_Rational
              and item.exp.is_negative
          ):
              if item.exp != -1:
                  b.append(Pow(item.base, -item.exp, evaluate=False))
              else:
                  if len(item.args[0].args) != 1 and isinstance(
                      item.base, Mul
                  ):  # To avoid situations like #14160
                      pow_paren.append(item)
                  b.append(Pow(item.base, -item.exp))
          else:
              a.append(item)
  
      a = a or [S.One]
  
      if len(a) == 1 and sign == "-":
          # Unary minus does not have a SymPy class, and hence there's no
          # precedence weight associated with it, Python's unary minus has
          # an operator precedence between multiplication and exponentiation,
          # so we use this to compute a weight.
          a_str = [
              self.parenthesize(
                  a[0], 0.5 * (PRECEDENCE["Pow"] + PRECEDENCE["Mul"])
              )
          ]
      else:
          a_str = [self.parenthesize(x, prec) for x in a]
      b_str = [self.parenthesize(x, prec) for x in b]
  
      # To parenthesize Pow with exp = -1 and having more than one Symbol
      for item in pow_paren:
          if item.base in b:
              b_str[b.index(item.base)] = (
                  "(%s)" % b_str[b.index(item.base)]
              )
  
      if not b:
          return sign + "*".join(a_str)
      elif len(b) == 1:
          return sign + "*".join(a_str) + "/" + b_str[0]
      else:
          return sign + "*".join(a_str) + "/(%s)" % "*".join(b_str)
  
imports: from __future__ import annotations
  from typing import Any
  from functools import wraps
  from sympy.core import Add, Mul, Pow, S, sympify, Float
  from sympy.core.basic import Basic
  from sympy.core.expr import UnevaluatedExpr
  from sympy.core.function import Lambda
  from sympy.core.mul import _keep_coeff
  from sympy.core.sorting import default_sort_key
  from sympy.core.symbol import Symbol
  from sympy.functions.elementary.complexes import re
  from sympy.printing.str import StrPrinter
  from sympy.printing.precedence import precedence, PRECEDENCE
label_desc: Use image node_id 38 for calling the CodePrinter obj's underlying member method code with example usage: obj._print_Mul(expr) and returns: unknown, unknown, unknown