docs: def calculate_max_stack_depth(ops, target=None):
      """
      Calculate the maximum stack depth (and required stack size) from a series
      of :class:`Op` and :class:`Label` instances. This is required when you
      manipulate the opcodes in such a way that the stack layout might change
      and you want to re-create a working function from it.
  
      This is a fairly literal re-implementation of python's stackdepth and
      stackdepth_walk.
  
      Arguments:
          ops(list): A list of opcodes and labels (as returned by
              :func:`disassemble`).
          target: The opcode specification of the targeted python
              version. If this is ``None`` the specification of the currently
              running python version will be used.
  
      Returns:
          int: The calculated maximum stack depth.
      """
  
      blocks = blocks_from_ops(ops)
      target = get_py_internals(target)
  
      block = blocks[None]
      while block:
          block.seen = False
          block.startdepth = -1
          block = block.next
  
      stackeffect = target['stackeffect']
      stackeffect_traits = target['stackeffect_traits']
  
      def walk(block=None, depth=0, max_depth=0):
          if not isinstance(block, Block):
              block = blocks[block]
  
          if block.seen or block.startdepth >= depth:
              return max_depth
  
          block.seen = True
          block.startdepth = depth
  
          for op in block.ops:
              effect = stackeffect[op.name]
              if callable(effect):
                  effect = effect(op.arg)
  
              depth += effect
              if depth > max_depth:
                  max_depth = depth
  
              op_code = target['opmap'][op.name]
              if op_code in target['hasjrel'] or op_code in target['hasjabs']:
                  target_depth = depth
  
                  if stackeffect_traits & 1:
                      if op.name == 'FOR_ITER':
                          target_depth -= 2
                      elif op.name in ('SETUP_FINALLY', 'SETUP_EXCEPT'):
                          target_depth += 3
                          if target_depth > max_depth:
                              max_depth = target_depth
                  if stackeffect_traits & 2:
                      if op.name in ('JUMP_IF_TRUE_OR_POP', 'JUMP_IF_FALSE_OR_POP'):
                          depth -= 1
  
                  max_depth = walk(op.arg, target_depth, max_depth)
              if op.name in ('JUMP_ABSOLUTE', 'JUMP_FORWARD'):
                  break
  
          else:
              if block.next:
                  max_depth = walk(block.next, depth, max_depth)
  
          block.seen = False
  
          return max_depth
  
      return walk()