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