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