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