TRAVEL

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