docs: 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)