How to use the trezor.log.debug function in trezor

def read_report_stream(target, iface=_DEFAULT_IFACE):
    while True:
        report, = yield loop.Select(iface)
        log.debug(__name__, 'read report %s', hexlify(report))
        target.send(memoryview(report))

def _step(task: Task, value: Any) -> None:
    try:
        if isinstance(value, BaseException):
            result = task.throw(value)  # type: ignore
            # error: Argument 1 to "throw" of "Coroutine" has incompatible type "Exception"; expected "Type[BaseException]"
            # rationale: In micropython, generator.throw() accepts the exception object directly.
        else:
            result = task.send(value)
    except StopIteration as e:  # as e:
        if __debug__:
            log.debug(__name__, "finish: %s", task)
        finalize(task, e.value)
    except Exception as e:
        if __debug__:
            log.exception(__name__, e)
        finalize(task, e)
    else:
        if isinstance(result, Syscall):
            result.handle(task)
        elif result is None:
            schedule(task)
        else:
            if __debug__:
                log.error(__name__, "unknown syscall: %s", result)
        if after_step_hook:
            after_step_hook()

def start_default(constructor: Callable[[], loop.Task]) -> None:
    """Start a default workflow, created from `constructor`.

    If a default task is already running, nothing will happen. Use `replace_default`
    to set up a new default task for the next run.
    """
    global default_task
    global default_constructor

    if not default_task:
        default_constructor = constructor
        default_task = constructor()
        if __debug__:
            log.debug(__name__, "start default: %s", default_task)
        # Schedule the default task.  Because the task can complete on its own,
        # we need to reset the `default_task` global in a finalizer.
        loop.schedule(default_task, None, None, _finalize_default)
    else:
        if __debug__:
            log.debug(__name__, "default already started")

def kill_default() -> None:
    """Forcefully shut down default task.

    The purpose of the call is to prevent the default task from interfering with
    a synchronous layout-less workflow (e.g., the progress bar in `mnemonic.get_seed`).

    This function should only be called from a workflow registered with `on_start`.
    Otherwise the default will be restarted immediately.
    """
    if default_task:
        if __debug__:
            log.debug(__name__, "close default")
        # We let the `_finalize_default` reset the global.
        loop.close(default_task)

def dispatch(report, open_callback, close_callback, unknown_callback):
    '''
    Dispatches payloads of reports adhering to one of the wire codecs.
    '''

    if codec_v1.detect(report):
        marker, session_id, report_data = codec_v1.parse_report(report)
    else:
        marker, session_id, report_data = codec_v2.parse_report(report)

        if marker == codec_v2.REP_MARKER_OPEN:
            log.debug(__name__, 'request for new session')
            open_callback()
            return
        elif marker == codec_v2.REP_MARKER_CLOSE:
            log.debug(__name__, 'request for closing session %x', session_id)
            close_callback(session_id)
            return

    if session_id not in readers:
        log.warning(__name__, 'report on unknown session %x', session_id)
        unknown_callback(session_id, report_data)
        return

    log.debug(__name__, 'report on session %x', session_id)
    reader = readers[session_id]

    try:

def mem_trace(self, x=None, collect=False):
        if __debug__:
            log.debug(
                __name__,
                "Log trace: %s, ... F: %s A: %s",
                x,
                gc.mem_free(),
                gc.mem_alloc(),
            )
        if collect:
            gc.collect()

return req
    elif req.cmd == _CMD_WINK:
        if __debug__:
            log.debug(__name__, "_CMD_WINK")
        loop.schedule(ui.alert())
        return req
    elif req.cmd == _CMD_CBOR and _ALLOW_FIDO2:
        if not req.data:
            return cmd_error(req.cid, _ERR_INVALID_LEN)
        if req.data[0] == _CBOR_MAKE_CREDENTIAL:
            if __debug__:
                log.debug(__name__, "_CBOR_MAKE_CREDENTIAL")
            return cbor_make_credential(req, dialog_mgr)
        elif req.data[0] == _CBOR_GET_ASSERTION:
            if __debug__:
                log.debug(__name__, "_CBOR_GET_ASSERTION")
            return cbor_get_assertion(req, dialog_mgr)
        elif req.data[0] == _CBOR_GET_INFO:
            if __debug__:
                log.debug(__name__, "_CBOR_GET_INFO")
            return cbor_get_info(req)
        elif req.data[0] == _CBOR_CLIENT_PIN:
            if __debug__:
                log.debug(__name__, "_CBOR_CLIENT_PIN")
            return cbor_client_pin(req)
        elif req.data[0] == _CBOR_RESET:
            if __debug__:
                log.debug(__name__, "_CBOR_RESET")
            return cbor_reset(req, dialog_mgr)
        elif req.data[0] == _CBOR_GET_NEXT_ASSERTION:
            if __debug__:
                log.debug(__name__, "_CBOR_GET_NEXT_ASSERTION")

def register(msg_type: MessageClass) -> None:
    """Register custom message type in runtime."""
    if __debug__:
        log.debug(__name__, "register %s", msg_type)
    registered[msg_type.MESSAGE_WIRE_TYPE] = msg_type

def mem_trace(self, x=None, collect=False):
        if __debug__:
            log.debug(
                __name__,
                "Log trace: %s, ... F: %s A: %s",
                x,
                gc.mem_free(),
                gc.mem_alloc(),
            )
        if collect:
            gc.collect()

for i in range(ln):
                item, data = _cbor_decode(data)
                res.append(item)
            return (res, data)
    elif fb_type == _CBOR_MAP:
        return ({}, cbor[1:])
    elif fb_type == _CBOR_TAG:
        if cbor[1] == _CBOR_RAW_TAG:  # only tag 24 (0x18) is supported
            return _cbor_decode(cbor[2:])
        else:
            raise NotImplementedError()
    elif fb_type == _CBOR_PRIMITIVE:  # only break code is supported
        return (cbor[0], cbor[1:])
    else:
        if __debug__:
            log.debug(__name__, "not implemented (decode): %s", cbor[0])
        raise NotImplementedError()