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