EMAIL DETAILS
SUBJECT:
eTicket Itinerary and Receipt for Confirmation CHKFH8
PRI: NORMAL
FROM:
U
unitedairlines@united.com
DATE:
2017-06-07 05:36:02
MSG_ID:
<09.94.21369.2C097395@mx2.coair.com>
RECIPIENTS:
TO:
R
rhbdc@icloud.com
CONTENT:
TEXT: YES |
HTML: NO
PROCESSED
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
METADATA:
THREAD:
INDEX:
AdhhqEu4gekc4uwuQ0GRHVWdzsW3Jg==