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