/*CACHE-CONTROL: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*/