MVHR Control and Sensors

{{widget type="Magenerds\WysiwygWidget\Block\Widget\Editor" content="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"}}