Office MVHR systems

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