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