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