```python:inference/core/workflows/execution_engine/v1/executor/execution_data_manager/branching_manager.py
from typing import Dict, Set, Union

from inference.core.workflows.errors import ExecutionEngineRuntimeError
from inference.core.workflows.execution_engine.v1.executor.execution_data_manager.dynamic_batches_manager import \
    DynamicBatchIndex


class BranchingManager:

    def __init__(self, masks: Dict[str, Union[Set[DynamicBatchIndex], bool]]):
        self._masks = masks
        self._batch_compatibility = {
            branch_name: not isinstance(mask, bool)
            for branch_name, mask in masks.items()
        }

    def register_non_batch_mask(self, execution_branch: str, mask: bool) -> None:
        if execution_branch in self._masks:
            raise ExecutionEngineRuntimeError(
                public_message=f"Attempted to re-register maks for execution branch: {execution_branch}. "
                f"This is most likely a bug. Contact Roboflow team through github issues "
                f"(https://github.com/roboflow/inference/issues) providing full context of"
                f"the problem - including workflow definition you use.",
                context="workflow_execution | step_input_assembling",
            )
        self._batch_compatibility[execution_branch] = False
        self._masks[execution_branch] = mask
```
```python:inference/core/workflows/execution_engine/v1/executor/execution_data_manager/manager.py
from typing import Any, Dict

from inference.core import logger
from inference.core.workflows.errors import ExecutionEngineRuntimeError
from inference.core.workflows.execution_engine.v1.compiler.entities import \
    StepNode
from inference.core.workflows.execution_engine.v1.entities import FlowControl
from inference.core.workflows.execution_engine.v1.executor.execution_data_manager.branching_manager import \
    BranchingManager
from inference.core.workflows.execution_engine.v1.executor.execution_data_manager.dynamic_batches_manager import \
    DynamicBatchesManager
from inference.core.workflows.execution_engine.v1.executor.execution_data_manager.execution_cache import \
    ExecutionCache
from networkx import DiGraph


class ExecutionDataManager:

    def __init__(
        self,
        execution_graph: DiGraph,
        runtime_parameters: Dict[str, Any],
        execution_cache: ExecutionCache,
        dynamic_batches_manager: DynamicBatchesManager,
        branching_manager: BranchingManager,
    ):
        self._execution_graph = execution_graph
        self._runtime_parameters = runtime_parameters
        self._execution_cache = execution_cache
        self._dynamic_batches_manager = dynamic_batches_manager
        self._branching_manager = branching_manager

    def _register_control_flow_output_for_non_simd_step(
        self,
        step_node: StepNode,
        output: FlowControl,
    ) -> None:
        if not step_node.child_execution_branches:
            raise ExecutionEngineRuntimeError(
                public_message=f"Error in execution engine. Step: {step_node.name} "
                f"which is not flow-control step attempted to register FlowControl output. "
                f"This is most likely bug. "
                f"Contact Roboflow team through github issues "
                f"(https://github.com/roboflow/inference/issues) providing full context of"
                f"the problem - including workflow definition you use.",
                context="workflow_execution | step_output_registration",
            )
        selected_steps = output.context
        if not isinstance(selected_steps, list):
            selected_steps = {selected_steps}
        else:
            selected_steps = set(selected_steps)
        selected_execution_branches = set()
        for target_step, branch_name in step_node.child_execution_branches.items():
            if target_step in selected_steps:
                selected_execution_branches.add(branch_name)
        
        debug_enabled = logger.isEnabledFor(10)  # 10 is DEBUG level
        for branch_name in step_node.child_execution_branches.values():
            mask = branch_name in selected_execution_branches
            if debug_enabled:
                logger.debug(f"NON-SIMD flow control -> {branch_name}: {mask}")
            self._branching_manager.register_non_batch_mask(
                execution_branch=branch_name,
                mask=mask,
            )
        return None
```