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