docs: def m(self, msg,
            state=False, more=None, cmdd=None, critical=True, verbose=None):
          '''
          Mysterious mega method managing multiple meshed modules magically
  
          .. note:: If this function is used, the code contains facepalms: ``m(``
  
          * It is possible to just show a message, \
          or to run a command with message.
  
          * But it is not possible to run a command without a message, \
          use the `verbose`-flag to hide your debug message.
  
          :param msg:
              Add a message. Shown depending on `verbose` (see below)
          :param state:
              Pass `state` down to :func:`util.system.shell_notify`
          :param more:
              Pass `more` down to :func:`util.system.shell_notify`
          :param dict cmdd:
              If given, :func:`util.system.shell_run` is launched with
              it's values
          :param critical:
              If set to ``True``: |appteardown| on failure of `cmdd` contents.
  
              * Similar to :func:`util.system.shell_run` `critical`-flag
  
          :param verbose:
              Overrules parent's class `verbose`-flag.
  
              * If left to ``None``, the verbose value Photon \
              was started with is used
  
              * Messages are shown/hidden if explicitly set to ``True``/``False``
  
          :returns:
              A dictionary specified the following:
  
              * 'more':
                  `more` if it is not a dictionary otherwise \
                  it gets merged in if `more` is specified
  
              * The output of :func:`util.system.shell_run` gets merged in \
              if `cmdd` is specified
  
              * 'failed': ``True`` if command failed
  
              :func:`util.system.shell_notify` is used with this dictionary
              to pipe it's output into :func:`meta.Meta.log` before returning.
          '''
  
          if verbose is None:
              verbose = self.__verbose
  
          res = dict()
          if more:
              res.update(more if isinstance(more, dict) else dict(more=more))
  
          if cmdd and isinstance(cmdd, dict) and cmdd.get('cmd'):
              res.update(shell_run(
                  cmdd.get('cmd'),
                  cin=cmdd.get('cin'),
                  cwd=cmdd.get('cwd'),
                  timeout=cmdd.get('timeout', 120),
                  critical=False,
                  verbose=cmdd.get('verbose', verbose)
              ))
  
              if res.get('returncode', -1) != 0:
                  res.update(dict(failed=True))
  
          if state or critical and res.get('failed'):
              self.meta.log = dict(message=msg, more=res, verbose=verbose)
              shell_notify(msg, more=res, state=True)
          self.meta.log = shell_notify(msg, more=res,
                                       state=state, verbose=verbose)
          return res