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