code: async def _handle_message(self,
                                message: BaseMessage,
                                responder: Responder) -> Optional[Dict]:
          
  
          async def noop(request: Request, responder: Responder):
              pass
  
          mm = MiddlewareManager.instance()
          reg_manager = self.register\
              .work_on_register(message.get_conversation().id)
  
          async with reg_manager as reg:
              request = Request(message, reg)
              await request.transform()
  
              if not request.stack.layers:
                  return
  
              logger.debug('Incoming message: %s', request.stack)
              await mm.get('pre_handle', noop)(request, responder)
  
              # noinspection PyBroadException
              try:
                  state, trigger, dnr = \
                      await self._build_state(request, message, responder)
              except Exception:
                  logger.exception('Error while finding a transition from %s',
                                   reg.get(Register.STATE))
                  reporter.report(request, None)
                  return
  
              if state is None:
                  logger.debug(
                      'No next state found but "%s" is not confusing, stopping',
                      request.message,
                  )
                  return
  
              state = await self._run_state(responder, state, trigger, request)
  
              # noinspection PyBroadException
              try:
                  await responder.flush(request)
              except MissingTranslationError as e:
                  responder.clear()
                  responder.send([RawText(str(e))])
                  await responder.flush(request)
  
                  reporter.report(request, state.name())
                  logger.exception('Missing translation in state %s',
                                   state.name())
              except Exception:
                  reporter.report(request, state.name())
                  logger.exception('Could not flush content after %s',
                                   state.name())
              else:
                  if not dnr:
                      reg.replacement = await self._build_state_register(
                          state,
                          request,
                          responder,
                      )
                  return reg.replacement
docs: Handles a message: find a state and run it.
  
          :return: The register that was saved