I’ve compared the generated C++ before and after 0.30. And yes, the problem is in the errors. Previously, they were ignored just in the place where they were emitted (the `ERR`

pulse) and now every recursively downstream node makes a computation to check whether it is affected by an error or not. The deeper the node, the more complex the computation is:

```
bool error_input_IDX = false;
error_input_IDX |= node_102.outputHasError_BYTE;
error_input_IDX |= node_97.outputHasError_DONE;
error_input_IDX |= node_92.outputHasError_DONE;
error_input_IDX |= node_86.outputHasError_DONE;
error_input_IDX |= node_81.outputHasError_DONE;
error_input_IDX |= node_78.outputHasError_DONE;
error_input_IDX |= node_74.outputHasError_DONE;
error_input_IDX |= node_71.outputHasError_DONE;
error_input_IDX |= node_68.outputHasError_DONE;
error_input_IDX |= node_64.outputHasError_DONE;
error_input_IDX |= node_78.outputHasError_BYTE;
error_input_IDX |= node_86.outputHasError_BYTE;
error_input_IDX |= node_97.outputHasError_BYTE;
error_input_IDX |= node_81.outputHasError_BYTE;
error_input_IDX |= node_108.outputHasError_BYTE;
error_input_IDX |= node_102.outputHasError_DONE;
error_input_IDX |= node_155.outputHasError_OUT;
error_input_IDX |= node_154.outputHasError_OUT;
bool error_input_X0 = false;
error_input_X0 |= node_102.outputHasError_BYTE;
error_input_X0 |= node_97.outputHasError_DONE;
error_input_X0 |= node_92.outputHasError_DONE;
error_input_X0 |= node_86.outputHasError_DONE;
error_input_X0 |= node_81.outputHasError_DONE;
error_input_X0 |= node_78.outputHasError_DONE;
error_input_X0 |= node_74.outputHasError_DONE;
error_input_X0 |= node_71.outputHasError_DONE;
error_input_X0 |= node_68.outputHasError_DONE;
error_input_X0 |= node_64.outputHasError_DONE;
error_input_X0 |= node_78.outputHasError_BYTE;
error_input_X0 |= node_86.outputHasError_BYTE;
error_input_X0 |= node_97.outputHasError_BYTE;
error_input_X0 |= node_81.outputHasError_BYTE;
error_input_X0 |= node_108.outputHasError_BYTE;
error_input_X0 |= node_102.outputHasError_DONE;
error_input_X0 |= node_155.outputHasError_OUT;
error_input_X0 |= node_154.outputHasError_OUT;
bool error_input_X1 = false;
error_input_X1 |= node_102.outputHasError_BYTE;
error_input_X1 |= node_97.outputHasError_DONE;
error_input_X1 |= node_92.outputHasError_DONE;
error_input_X1 |= node_86.outputHasError_DONE;
error_input_X1 |= node_81.outputHasError_DONE;
error_input_X1 |= node_78.outputHasError_DONE;
error_input_X1 |= node_74.outputHasError_DONE;
error_input_X1 |= node_71.outputHasError_DONE;
error_input_X1 |= node_68.outputHasError_DONE;
error_input_X1 |= node_64.outputHasError_DONE;
error_input_X1 |= node_78.outputHasError_BYTE;
error_input_X1 |= node_86.outputHasError_BYTE;
error_input_X1 |= node_97.outputHasError_BYTE;
error_input_X1 |= node_81.outputHasError_BYTE;
error_input_X1 |= node_108.outputHasError_BYTE;
error_input_X1 |= node_102.outputHasError_DONE;
bool hasUpstreamError = false;
hasUpstreamError |= error_input_IDX;
hasUpstreamError |= error_input_X0;
hasUpstreamError |= error_input_X1;
```

These computations consume flash. The example above is a rollout of a single stage of the `dataselect`

variadic node. And your example has maaany stages.

Well, I overlooked such scenarios and as a result, XOD 0.30 performs worse. I need some more time to find a solution to get back in terms of memory usage. If someone feels the power to solve this C++ riddle, help is much appreciated.