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