window.nitroFragments['cc982398a20ae78b841a4fd306204a2f'] = {"isLazyLoaded":true,"content":"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"};
window.dispatchEvent(new CustomEvent('nitrofragmentloaded', {detail: "cc982398a20ae78b841a4fd306204a2f"}));