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