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