TRAVEL

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