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