As we were leaving Paris, a message came from Baron Eric de Rothschild to secure 1kg of foie gras.
{"content":"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"}