code: def canonical_odes(eqs, funcs, t):
      r"""
      Function that solves for highest order derivatives in a system
  
      Explanation
      ===========
  
      This function inputs a system of ODEs and based on the system,
      the dependent variables and their highest order, returns the system
      in the following form:
  
      .. math::
          X'(t) = A(t) X(t) + b(t)
  
      Here, $X(t)$ is the vector of dependent variables of lower order, $A(t)$ is
      the coefficient matrix, $b(t)$ is the non-homogeneous term and $X'(t)$ is the
      vector of dependent variables in their respective highest order. We use the term
      canonical form to imply the system of ODEs which is of the above form.
  
      If the system passed has a non-linear term with multiple solutions, then a list of
      systems is returned in its canonical form.
  
      Parameters
      ==========
  
      eqs : List
          List of the ODEs
      funcs : List
          List of dependent variables
      t : Symbol
          Independent variable
  
      Examples
      ========
  
      >>> from sympy import symbols, Function, Eq, Derivative
      >>> from sympy.solvers.ode.systems import canonical_odes
      >>> f, g = symbols("f g", cls=Function)
      >>> x, y = symbols("x y")
      >>> funcs = [f(x), g(x)]
      >>> eqs = [Eq(f(x).diff(x) - 7*f(x), 12*g(x)), Eq(g(x).diff(x) + g(x), 20*f(x))]
  
      >>> canonical_eqs = canonical_odes(eqs, funcs, x)
      >>> canonical_eqs
      [[Eq(Derivative(f(x), x), 7*f(x) + 12*g(x)), Eq(Derivative(g(x), x), 20*f(x) - g(x))]]
  
      >>> system = [Eq(Derivative(f(x), x)**2 - 2*Derivative(f(x), x) + 1, 4), Eq(-y*f(x) + Derivative(g(x), x), 0)]
  
      >>> canonical_system = canonical_odes(system, funcs, x)
      >>> canonical_system
      [[Eq(Derivative(f(x), x), -1), Eq(Derivative(g(x), x), y*f(x))], [Eq(Derivative(f(x), x), 3), Eq(Derivative(g(x), x), y*f(x))]]
  
      Returns
      =======
  
      List
  
      """
      from sympy.solvers.solvers import solve
  
      order = _get_func_order(eqs, funcs)
  
      canon_eqs = solve(
          eqs, *[func.diff(t, order[func]) for func in funcs], dict=True
      )
  
      systems = []
      for eq in canon_eqs:
          system = [
              Eq(
                  func.diff(t, order[func]),
                  eq[func.diff(t, order[func])],
              )
              for func in funcs
          ]
          systems.append(system)
  
      return systems
  
imports: from sympy.core import Add, Mul, S
  from sympy.core.containers import Tuple
  from sympy.core.exprtools import factor_terms
  from sympy.core.numbers import I
  from sympy.core.relational import Eq, Equality
  from sympy.core.sorting import default_sort_key, ordered
  from sympy.core.symbol import Dummy, Symbol
  from sympy.core.function import expand_mul, expand, Derivative, AppliedUndef, Function, Subs
  from sympy.functions import exp, im, cos, sin, re, Piecewise, piecewise_fold, sqrt, log
  from sympy.functions.combinatorial.factorials import factorial
  from sympy.matrices import zeros, Matrix, NonSquareMatrixError, MatrixBase, eye
  from sympy.polys import Poly, together
  from sympy.simplify import collect, radsimp, signsimp
  from sympy.simplify.powsimp import powdenest, powsimp
  from sympy.simplify.ratsimp import ratsimp
  from sympy.simplify.simplify import simplify
  from sympy.sets.sets import FiniteSet
  from sympy.solvers.deutils import ode_order
  from sympy.solvers.solveset import NonlinearError, solveset
  from sympy.utilities.iterables import connected_components, iterable, strongly_connected_components
  from sympy.utilities.misc import filldedent
  from sympy.integrals.integrals import Integral, integrate
label_desc: Use image node_id 12 for calling a global function with example usage: canonical_odes(eqs, funcs, t) and returns: systems