code: def articulare_analyse(self):
      low, dfn, cut = dict(), dict(), dict()
      pcnt, root, st = [0], self, []
  
      ##### Mask Articulation Points
      def mask_dfs(u):
          tot = 0
          st.append(u)
          pcnt[0] += 1
          dfn[u] = low[u] = pcnt[0]
  
          for v in u.inputs + u.outputs:
              # Assume every param tensor is unshared
              if v.op_type == "param":
                  continue
              if v not in dfn:
                  tot += 1
                  mask_dfs(v)
                  low[u] = min(low[u], low[v])
                  if (u == root and tot > 1) or (
                      u != root and low[v] >= dfn[u]
                  ):
                      cut[u] = cut.get(u, 0) + 1
                  if low[v] >= dfn[u]:
                      while st.pop() != v:
                          continue
              else:
                  low[u] = min(low[u], dfn[v])
          cut[u] = cut.get(u, 0) + 1
  
      mask_dfs(self)
  
      ##### Partition Computations into Groups
      pcnt, visited, group_export = [0], set(), dict()
  
      def compute_dfs(u, vid, is_leader):
          if u in visited:
              return
          if u.op_type != "compute":
              return
          if is_leader:
              group_export[vid] = [u]
          else:
              group_export[vid].append(u)
  
          visited.add(u)
          for v in u.inputs:
              if cut.get(v, 0) > 1:
                  pcnt[0] += 1
                  compute_dfs(v, pcnt[0], True)
              else:
                  compute_dfs(v, vid, False)
  
      compute_dfs(self, pcnt[0], True)
  
      compute_groups = []
      for _, members in sorted(group_export.items(), reverse=True):
          for x in members:
              multi_used = set()
              for y in x.inputs:
                  if len(y.outputs) > 1:
                      multi_used.add(y)
          compute_groups.append(
              ([x for x in reversed(members)], multi_used)
          )
      return compute_groups
  
imports: import os, sys, json, re
  import tempfile
  import copy
  import inspect
  import logging
  import importlib
  from .None import solver
  from .None import patterns
label_desc: Use image node_id 10 for calling the Custom obj's underlying member method code with example usage: obj.articulare_analyse() and returns: compute_groups