Walk statement and render nodes which are representing
        hardware components (MUX, LATCH, FF, ...) for specified signal

def renderForSignal(self, stm: Union[HdlStatement, List[HdlStatement]],
                        s: RtlSignalBase,
                        connectOut) -> Optional[Tuple[LNode, Union[RtlSignalBase, LPort]]]:
        """
        Walk statement and render nodes which are representing
        hardware components (MUX, LATCH, FF, ...) for specified signal
        """
        # filter statements for this signal only if required
        if not isinstance(stm, HdlStatement):
            stm = list(walkStatementsForSig(stm, s))
            if not stm:
                return None
            elif len(stm) != 1:
                raise NotImplementedError("deduced MUX")
            else:
                stm = stm[0]

        # render assignment instances
        if isinstance(stm, Assignment):
            return self.createAssignment(stm, connectOut)

        encl = stm._enclosed_for
        full_ev_dep = stm._is_completly_event_dependent
        par = stm.parentStm
        parent_ev_dep = par is not None and par._now_is_event_dependent

        # render IfContainer instances
        if isinstance(stm, IfContainer):
            if full_ev_dep and not parent_ev_dep:
                # FF with optional MUX
                return self.renderEventDepIfContainer(stm, s, connectOut)

            else:
                latched = par is None and not parent_ev_dep and s not in encl
                # MUX/LATCH/MUX+LATCH
                controls = [stm.cond]
                ren = self.renderForSignal(stm.ifTrue, s, False)
                if ren is not None:
                    inputs = [ren[1]]
                else:
                    inputs = []

                for c, stms in stm.elIfs:
                    controls.append(c)
                    ren = self.renderForSignal(stms, s, False)
                    if ren is not None:
                        inputs.append(ren[1])
                if stm.ifFalse:
                    ren = self.renderForSignal(stm.ifFalse, s, False)
                    if ren is not None:
                        inputs.append(ren[1])

                return self.createMux(s, inputs, controls, connectOut,
                                      latched=latched)

        # render SwitchContainer instances
        elif isinstance(stm, SwitchContainer):
            latched = s not in encl
            inputs = []
            for _, stms in stm.cases:
                d = self.renderForSignal(stms, s, False)
                if d is not None:
                    _, port = d
                    inputs.append(port)
                else:
                    assert latched, (s, stm)

            if stm.default:
                d = self.renderForSignal(stm.default, s, False)
                if d is not None:
                    _, port = d
                    inputs.append(port)
                else:
                    assert latched, (s, stm)

            return self.createMux(s, inputs, stm.switchOn, connectOut,
                                  latched=latched)
        else:
            raise TypeError(stm)