{"html":"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"}