Subject: MileagePlus eTicket Itinerary and Receipt for Confirmation F0Q4EF
From: "United Airlines, Inc." <[email-masked]>
To: <[email-masked]>
Date: 11 Dec 2016 23:28:03 -0600



<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" lang="en-US">
<head id="Head1"><link id="linkCSS" href="https://www.united.com/web/format/css/StyleSheet.css" rel="stylesheet" type="text/css" /><title>
	eTicket Itinerary and Receipt
</title><meta name="robots" content="noindex,nofollow" /></head>
<body>
	<div style="padding-left:5px">
		<table width="645px" border="0" cellspacing="0" cellpadding="0">
			<tr>
				<td>
					
					<table width="100%" border="0" cellpadding="0" cellspacing="0">
						<tr>
							<td style="height:20px"></td>
						</tr>
						<tr>
							<td align="right" colspan="2">
<table width="100%" cellpadding="0" cellspacing="0">
	
	<tr id="Header_Setting2">
	<td>
			<table border="0" width="100%">
				<tr>
					<td align="left" valign="top"><a id="Header_HyperLinkSetting2A" href="http://www.united.com"><img id="Header_logo02" src="https://www.united.com/web/format/img/email/eticket/UaStarLogoHor.gif" alt="United Airlines" border="0" /></a></td>
					<td align="center" valign="top">
						<table>
							<tr>
								<span id="Header_ConfirmHeader2" class="eTicketConfirmationHeader">Confirmation: </span>
							</tr>
							<tr>
								<td align="center" valign="top"><span id="Header_ConfirmationNumber2" class="eTicketConfirmation">F0Q4EF</span><br />
									<a id="Header_HyperLinkSetting2B" href="https://www.united.com/travel/checkin/quickstart.aspx?camp=2004_email_ckin&amp;irLocation=IAD&amp;irPNR=F0Q4EF&amp;LangCode=en-US">Check-In ></a> </td>
							</tr>
						</table>
					</td>
				</tr>
				<tr>
					<td align="left"><span id="Header_DateIssue2" class="detailCaption">Issue Date: December 12, 2016</span> </td>
				</tr>
			</table>
		</td>
</tr>

	
	
	
	
</table>
</td>
						</tr>
						
						<tr>
							<td class="eTicketContentBold"> </td>
						</tr>
						<tr height="1px">
							<td colspan="2" style="height:1px">
								<hr size="1px" color="#000000">
							</td>
						</tr>
						<!-- Meeting Work -->
						
						<!-- Traveler Information -->
						<tr>
							<td colspan="2"><div id="ShowTravelers_traveler">
	
<table border="0" cellpadding="0" cellspacing="0" width="100%" >   
    <tr>
        <td class="eTicketContentBold">
            <h2 class="visuallyhidden" id="travelerinfo1">Traveler information</h2>
            <h3 id="travelerinfo" class="webAccessHead">Traveler</h3>
        </td>
        <td class="eTicketContentBold">
            <h3 class="webAccessHead">eTicket Number</h3>
        </td>
        <td class="eTicketContentBold">
            <h3 id="freqFlyerNumber" aria-describedby="freqFlyerNumber" class="webAccessHead">Frequent Flyer<span class="visuallyhidden">Number</span></h3>            
        </td>
        <td class="eTicketContentBold">
            <h3 class="webAccessHead">Seats</h3>
        </td>
    </tr>
    
            <tr>
                <td class="eTicketContent">
                    <p class="pMargin0"><span>BIDEN/NAOMIKING</span></p>
                </td>
                <td class="eTicketContent">
                    <p class="pMargin0"><span>0162328293884</span></p>
                </td>
                <td class="eTicketContent">
                    <p class="pMargin0"><span></span></p>
                </td>
                <td class="eTicketContent">
                    <p class="pMargin0"><span>---/---</span></p>
                </td>
            </tr>
        
 </table>
 
</div>
 </td>
						</tr>
						<tr>
							<td colspan="2" style="height:1px">
								<hr size="1px" color="#000000">
							</td>
						</tr>
						<!-- Flight Information -->
						<tr>
							<td colspan="2">
<h2 style="margin:0;background:none;" class="eTicketContentBold">FLIGHT INFORMATION</h2>
<table border="0" cellpadding="0" cellspacing="0" width="100%">
    <tr>
        <th align="left" scope="col">
            <span class="eTicketContentBold">Day, Date</span>
        </th>
        <th align="left" scope="col">
            <span class="eTicketContentBold">Flight</span>
        </th>
        <th align="left" scope="col">
            <span class="eTicketContentBold">Class</span>
        </th>
        <th align="left" scope="col">
            <span class="eTicketContentBold">Departure City and Time</span>
        </th>
        <th align="left" scope="col">
            <span class="eTicketContentBold">Arrival City and Time</span>
        </th>
        <th align="left" scope="col">
            <span class="eTicketContentBold">Aircraft</span> 
        </th>        
        <th align="left" scope="col">
            <span class="eTicketContentBold">Meal</span> 
        </th>        
    </tr>
    
        <tr>
            <td class="eTicketContent" valign="top">
                <span>Thu, 15DEC16</span>
            </td>
            <td class="eTicketContent" valign="top">
                <span id="ShowSegments_ShowSegment_ctl00_Flight">UA632</span>
            </td>
            <td class="eTicketContent" valign="top">
                <span>YN</span>
            </td>
            <td class="eTicketContent" valign="bottom">
                <span id="ShowSegments_ShowSegment_ctl00_DepatureCity">WASHINGTON, DC <BR />(IAD - DULLES)&nbsp;<b>12:46 PM</b></span>
            </td>
            <td class="eTicketContent" valign="bottom">
                <span>LOS ANGELES, CA <BR />(LAX)&nbsp;<b>3:31 PM</b></span>
            </td>
            <td class="eTicketContent" valign="top">
                <span>737-800</span>
            </td>
            <td class="eTicketContent" valign="top">
                <span>Purchase</span>
            </td> 
          
        </tr>            
        <tr>  
            <td class="eTicketContent" colspan="7" style="font-size: 8pt">
                <span></span>
            </td>
        </tr>

        <tr><td style="height:5px"></td></tr>
        
        <tr>
            <td class="eTicketContent" style="background-color: LightGrey" valign="top">
                <span>Sat, 17DEC16</span>
            </td>
            <td class="eTicketContent" style="background-color: LightGrey" valign="top">
                <span id="ShowSegments_ShowSegment_ctl01_Flight">UA584</span>
            </td>
            <td class="eTicketContent" style="background-color: LightGrey" valign="top">
                <span>YN</span>
            </td>
            <td class="eTicketContent" style="background-color: LightGrey" valign="bottom">
                <span id="ShowSegments_ShowSegment_ctl01_DepatureCity">LOS ANGELES, CA <BR />(LAX)&nbsp;<b>10:35 PM</b></span>
            </td>
            <td class="eTicketContent" style="background-color: LightGrey" valign="bottom">
                <span>WASHINGTON, DC <BR />(IAD - DULLES)&nbsp;<b>6:26 AM (18DEC)</b></span>
            </td>
            <td class="eTicketContent" style="background-color: LightGrey" valign="top">
                <span>737-900</span>
            </td>
            <td class="eTicketContent" style="background-color: LightGrey" valign="top">
                <span>Purchase</span>
            </td>
        </tr>
        <tr>  
            <td class="eTicketContent" style="background-color: LightGrey;font-size: 8pt" valign="top" colspan="7">
                <span></span>
            </td>
        </tr>

        <tr><td style="height:5px"></td></tr>
                
</table>


</td>
						</tr>
						<tr>
							<td colspan="2" style="height:1px">
								<hr size="1px" color="#000000">
							</td>
						</tr>
						<!-- Fare Information -->
						<tr id="trFareInfo">
	<td colspan="2">
<table width="100%" border="0" cellpadding="0" cellspacing="0">
	<tr>
		<td align="left"><h2 style="margin:0;background:none;"><span id="FareInfo_SectionHeader" class="eTicketContentBold">FARE INFORMATION</span></h2> </td>
	</tr>
	<tr>
		<td role="presentation" style="height: 10px"></td>
	</tr>
</table>



<table id="FareInfo_FareBreakDownSection" width="100%" border="0" cellpadding="0" cellspacing="0">
		<tr>
			<td valign="top" align="left" width="320px">
			<h3 style="text-align:left;margin:0;background:none;" align="left" class="eTicketContentBold">Fare Breakdown </h3>
            <ul style="list-style:none;margin-top:0;" class="webAccessList">
                <li style="margin-left:0;clear:both">
                    <div class="eTicketContent" style="width:190px;text-align:left;float:left">Airfare:</div>
                    <div class="eTicketContent" role="presentation" style="width:80px;text-align:right;float:left"><span id="FareInfo_AirFare" class="eTicketContent">0.00</span></div>
                    <div class="eTicketContent" style="width:10px;text-align:left;float:left"><span id="FareInfo_AirFareCurrency" class="eTicketContent">USD</span></div>
                </li>
                
                
						<li style="margin-left:0;clear:both">
							<div class="eTicketContent" style="width:190px;text-align:left;float:left">
								September 11th Security Fee: 
							</div>
							<div class="eTicketContent" style="width:80px;text-align:right;float:left;padding-right:10px">
								11.20
							</div>
							
						</li>
					
                <li id="FareInfo_PerPersonTotalSection" style="margin-left:0;clear:both">
                    <div class="eTicketContent" style="width:190px;text-align:left;float:left">Per Person Total: </div>
                    <div class="eTicketContent" style="width:80px;text-align:right;float:left"><span id="FareInfo_TotalPerPerson" class="eTicketContent">11.20</span></div>
                    <div class="eTicketContent" style="width:10px;text-align:left;float:left"><span id="FareInfo_TotalPerPersonCurrency" class="eTicketContent">USD</span></div>
                </li>
                <li id="FareInfo_FareSection" style="margin-left:0;padding-top:10px;padding-bottom:10px;clear:both">
                    <div style="width:190px;float:left"><span id="FareInfo_FareHeader" class="eTicketContentBold">eTicket Total: </span> </div>
                    <div style="width:80px;text-align:right;float:left"><span id="FareInfo_FareGrandTotal" class="eTicketContentBold">11.20</span></div>
                    <div style="width:10px;text-align:left;float:left"><span id="FareInfo_FareGrandTotalCurrency" class="eTicketContentBold">USD</span></div>
                </li>
            </ul>
		</td>
			<td role="presentation" style="width: 10px"></td>
			<td align="left" valign="top" width="140px">
			<table id="FareInfo_Table1" border="0" width="100%" cellspacing="0" cellpadding="0">
				<tr id="FareInfo_OnePassAccountSection" valign="top">
					<td valign="top" class="eTicketContentBold">MileagePlus Account Debited: </td>
				</tr>
				<tr valign="top">
					<td align="left" valign="top" class="eTicketContent"><span id="FareInfo_OnePassAccountDebited" class="eTicketContent">KA552915</span> </td>
				</tr>
				<tr id="FareInfo_ExtraSpace">
					<td role="presentation" style="height: 10px"></td>
				</tr>
				<tr valign="top">
					<td align="left" valign="top" class="eTicketContentBold">Form of Payment:</td>
				</tr>
				<tr>
					<td align="left"><span id="FareInfo_CreditCardName" class="eTicketContent">VISA </span></td>
				</tr>
				<tr>
					<td align="left"><span id="FareInfo_CreditCardLast4" class="eTicketContent">Last Four Digits 4602</span></td>
				</tr>
			</table>
			
		</td>
			<td role="presentation" align="left" valign="top" width="185px">
			
			<table id="FareInfo_OnePassMilesInfoSection" width="100%" border="0">
				<tr>
					<td valign="top" class="eTicketContentBold">MileagePlus Miles Debited/<br>
						Award Used:</td>
				</tr>
				<tr>
					<td><span id="FareInfo_OnePassInformation" class="eTicketContent">50000/E25K-E25K</span></td>
				</tr>
				<tr>
					<td role="presentation" style="height: 10px"></td>
				</tr>
			</table>
			
		</td>
		</tr>
		<tr id="FareInfo_AirFareSummaryRow">
			<td colspan="3"><span id="FareInfo_AirFareSummary" class="eTicketContent">The airfare you paid on this itinerary totals:&nbsp;0.00 USD</span> </td>
		</tr>
		<tr>
			<td role="presentation" style="height: 10px"></td>
		</tr>
		<tr id="FareInfo_TaxSummaryRow">
			<td colspan="3"><span id="FareInfo_TaxSummary" class="eTicketContentBold">The taxes, fees, and surcharges paid total:&nbsp;11.20 USD</span> </td>
		</tr>
		<tr>
			<td role="presentation" style="height: 10px"></td>
		</tr>
	</table>
	

<table id="FareInfo_AdditionalChargeSection" style="width: 100%">
		<tr>
			<td valign="top" align="left" class="eTicketContent" style="width: 100px">Award Rules:</td>
			<td><span id="FareInfo_AdditionalCharge" class="eTicketContent">Additional charges may apply for changes in addition to any fare rules listed. <BR> RWD/NONEND/-TRAN;VALID UA;NOT VALID AFTER 12/11/2017<BR>All changes must be made prior to the departure date, or the ticket has no value.</span><br />
		</td>
		</tr>
		<tr>
			<td role="presentation" style="height: 10px"></td>
		</tr>
	</table>
	
<table cellpadding="0" cellspacing="0" style="width: 100%">
	
	
	
	<tr>
		<td role="presentation" style="height: 10px"></td>
	</tr>
	
	
	
	
	
	<tr>
		<td role="presentation" style="height: 10px"></td>
	</tr>
</table>

<table width="100%">
	
</table>
</td>
</tr>

						<tr id="trFareInfoSpacer">
	<td colspan="2" style="height:1px">
								<hr size="1px" color="#000000">
							</td>
</tr>

                        <tr>
                            <td colspan="2"><span id="BagFees_lblBagFees" class="eTicketContent"><strong><h2 id='bagTableDesc' style='text-align:center' class='webAccessHead'>Baggage allowance and charges for this itinerary. </h2><h3 style='text-align:center' class='webAccessHead'><p>Baggage fees are per traveler</p></h3></strong><table aria-describedby='bagTableDesc' width='100%' border='1' cellspacing='0' cellpadding='1' class='eTicketContent'><tr align='center'><th style='font-weight:normal' class='eTicketContent'>Origin and destination for checked baggage</th><th style='font-weight:normal' class='eTicketContent'>1<sup>st</sup> bag</th><th style='font-weight:normal' class='eTicketContent'>2<sup>nd</sup> bag</th><th style='font-weight:normal' class='eTicketContent'><div class='visuallyhidden'>Maximum weight and dimensions per piece of baggage</div><div aria-hidden='true'>Max wt / dim per piece</div></div></th></tr><tr align='center'><td class='eTicketContent'>12/15/2016 Washington, DC (IAD - Dulles) to Los Angeles, CA (LAX)</td><td class='eTicketContent'>25.00 USD</td><td class='eTicketContent'>35.00 USD</td><td class='eTicketContent'>50.0lbs (23.0kg) - 62.0in (157.0cm)</td></tr><tr align='center'><td class='eTicketContent'>12/17/2016 Los Angeles, CA (LAX) to Washington, DC (IAD - Dulles)</td><td class='eTicketContent'>25.00 USD</td><td class='eTicketContent'>35.00 USD</td><td class='eTicketContent'>50.0lbs (23.0kg) - 62.0in (157.0cm)</td></tr></table></span><br />
<span id="BagFees_lblFeeWaiverMsg" class="eTicketContent"></span><br />
</td>
                        </tr>
                        <tr>
							<td colspan="2" style="height: 1px">
								<hr size="1px" color="#000000">
							</td>
						</tr>
                        
                        
						<!-- Marketing Information -->
						<tr>
							<td colspan="2">
<style type="text/css">
    li {
        margin-left:0px;
        list-style:none;
    }

</style>
<table width="100%">
    
        <tr>
            <td>
                <table border="0" width="100%" cellpadding="0" cellspacing="0">
                    <tr>
                        <td width="100%"></td>
                    </tr>
                </table>
            </td>            
        </tr>
        <tr>
            <td>
                <table id="MarketingMsg_ShowMsg_ctl00_HeadLineSection" border="0" width="100%">
	<tr>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
	<tr>
		<td role="presentation" valign="top"></td>
		<td class="eTicketContentBold" align="center">
                            <h2 class="webAccessHead"><span id="MarketingMsg_ShowMsg_ctl00_HeadLine">Important Information about MileagePlus Earning</span></h2>
                        </td>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
</table>

            </td>
        </tr>
        <tr>
            <td>
                <ul style="margin:0 0 0 10px;">        
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl00_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl00_MessageText"></span> Accruals vary based on the terms and conditions of the traveler’s frequent flyer program, the traveler’s frequent flyer status and the itinerary selected. United MileagePlus® mileage accrual is subject to the rules of the MileagePlus program
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl01_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl01_MessageText"></span> Once travel has started, accruals will no longer display. You can view your MileagePlus account for posted accrual
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl02_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl02_MessageText"></span> You can earn up to 75,000 award miles per ticket. The 75,000 award miles cap may be applied to your posted flight activity in an order different than shown
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl03_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl03_MessageText"></span> PQD are a Premier status requirement for members in the U.S. only.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl04_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl04_MessageText"></span> Accrual is only displayed for MileagePlus members who choose to accrue to their MileagePlus account.
                        </div>
                    </li>
        
            </ul></td></tr>  
    
        <tr>
            <td>
                <table border="0" width="100%" cellpadding="0" cellspacing="0">
                    <tr>
                        <td width="100%"><hr id="MarketingMsg_ShowMsg_ctl01_Line" size="1px" color="#000000"></hr></td>
                    </tr>
                </table>
            </td>            
        </tr>
        <tr>
            <td>
                <table id="MarketingMsg_ShowMsg_ctl01_HeadLineSection" border="0" width="100%">
	<tr>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
	<tr>
		<td role="presentation" valign="top"></td>
		<td class="eTicketContentBold" align="center">
                            <h2 class="webAccessHead"><span id="MarketingMsg_ShowMsg_ctl01_HeadLine">MileagePlus eTicket Reminders</span></h2>
                        </td>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
</table>

            </td>
        </tr>
        <tr>
            <td>
                <ul style="margin:0 0 0 10px;">        
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl00_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl00_MessageText"></span> <b>Check-in Requirement</b> -  Bags must be checked and boarding passes obtained at least 30 minutes prior to scheduled departure. Baggage will not be accepted and advance seat assignments may be cancelled if this condition is not met.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl01_MessageText"></span> <b>EXCEPTION</b>: When departing from Anchorage, Atlanta, Chicago, Cincinnati, Cleveland, Denver, Dallas/Ft. Worth, Fort Lauderdale, Honolulu, Houston, Indianapolis, Jacksonville, Kahului, Kona, Las Vegas, Los Angeles,
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl02_MessageText"></span> Maui, Miami, Newark, Orange County (SNA), Orlando, Philadelphia, Phoenix, Reno, San Francisco, San Juan, PR, St. Louis, Seattle, Tampa, Washington, DC (both IAD and DCA)or Austin the check in requirement time for Passengers and Bags is 45 minutes.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl03_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl03_MessageText"></span> <b>Boarding Requirement</b> - Passengers must be prepared to board at the departure gate with their boarding pass at least 15 minutes prior to scheduled departure.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl04_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl04_MessageText"></span> Failure to meet the <b>Boarding Requirements</b> may result in cancellation of reservations, denied boarding, removal of checked baggage from the aircraft and loss of eligibility for denied boarding compensation.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl05_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl05_MessageText"></span> Bring your boarding pass or this eTicket Receipt along with <a><a href="http://www.united.com/travel/policies/id/">photo identification</a> to the airport.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl06_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl06_MessageText"></span> The FAA now restricts carry-on baggage to one bag plus one personal item (purse, briefcase, laptop computer, etc.) per passenger.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl07_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl07_MessageText"></span> For up to the minute flight information, sign-up for our <a href="https://www.united.com/web/en-US/content/flightStatus/updates.aspx">Flight Status Updates </a> or call 1-800-824-6200; in Spanish 1-800-426-5561.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl08_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl08_MessageText"></span> If flight segments are not flown in order, your reservation will be cancelled. Rebooking will be subject to the fare rules governing your ticket.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl09_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl09_MessageText"></span> For the most current status of your reservation, go to our <a href="https://www.united.com/web/en-US/apps/travel/flightstatus/Default.aspx">Flight Status</a> page.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl10_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl10_MessageText"></span> Your eTicket is non transferable and valid for 1 year from the issue date unless otherwise noted in the fare rules above.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl11_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl11_MessageText"></span> Award travel is subject to the terms and conditions of the MileagePlus program.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl12_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl12_MessageText"></span> Redeposit or change fees apply for award travel based on Premier level. Please go to <u><a href="http://www.united.com/web/en-US/content/onepass/rules/rewards.aspx">united.com</a></u> or call 800-UNITED-1 for details.
                        </div>
                    </li>
        
            </ul></td></tr>  
    
        <tr>
            <td>
                <table border="0" width="100%" cellpadding="0" cellspacing="0">
                    <tr>
                        <td width="100%"><hr id="MarketingMsg_ShowMsg_ctl02_Line" size="1px" color="#000000"></hr></td>
                    </tr>
                </table>
            </td>            
        </tr>
        <tr>
            <td>
                <table id="MarketingMsg_ShowMsg_ctl02_HeadLineSection" border="0" width="100%">
	<tr>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
	<tr>
		<td role="presentation" valign="top"></td>
		<td class="eTicketContentBold" align="center">
                            <h2 class="webAccessHead"><span id="MarketingMsg_ShowMsg_ctl02_HeadLine">Customer Care Contact Information</span></h2>
                        </td>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
</table>

            </td>
        </tr>
        <tr>
            <td>
                <ul style="margin:0 0 0 10px;">        
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl02_ShowDetailMsg_ctl00_MessageText"></span> <p>We welcome your compliments, comments or complaints regarding United or a United travel experience.</p>
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl02_ShowDetailMsg_ctl01_MessageText"></span> <p>You may contact us using our <u><a href="https://www.united.com/web/en-US/content/contact/customer/default.aspx">Customer Care</a></u> form </p>
                        </div>
                    </li>
        
            </ul></td></tr>  
    
        <tr>
            <td>
                <table border="0" width="100%" cellpadding="0" cellspacing="0">
                    <tr>
                        <td width="100%"><hr id="MarketingMsg_ShowMsg_ctl03_Line" size="1px" color="#000000"></hr></td>
                    </tr>
                </table>
            </td>            
        </tr>
        <tr>
            <td>
                <table id="MarketingMsg_ShowMsg_ctl03_HeadLineSection" border="0" width="100%">
	<tr>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
	<tr>
		<td role="presentation" valign="top"></td>
		<td class="eTicketContentBold" align="center">
                            <h2 class="webAccessHead"><span id="MarketingMsg_ShowMsg_ctl03_HeadLine">Refunds Within 24 Hours</span></h2>
                        </td>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
</table>

            </td>
        </tr>
        <tr>
            <td>
                <ul style="margin:0 0 0 10px;">        
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl03_ShowDetailMsg_ctl00_MessageText"></span> When you book and ticket a reservation through united.com, the United mobile app, the United Customer Contact Center, at our ticket counters or city ticket offices, or if you
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl03_ShowDetailMsg_ctl01_MessageText"></span> use MileagePlus® miles to book an award ticket, we will allow you to cancel the ticketed reservation without penalty and receive a 100 percent refund of the ticket price
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl03_ShowDetailMsg_ctl02_MessageText"></span> to the original form of payment if you cancel the reservation within 24 hours of purchase and if the reservation is made one week or more prior to scheduled flight departure.
                        </div>
                    </li>
        
            </ul></td></tr>  
    
        <tr>
            <td>
                <table border="0" width="100%" cellpadding="0" cellspacing="0">
                    <tr>
                        <td width="100%"><hr id="MarketingMsg_ShowMsg_ctl04_Line" size="1px" color="#000000"></hr></td>
                    </tr>
                </table>
            </td>            
        </tr>
        <tr>
            <td>
                <table id="MarketingMsg_ShowMsg_ctl04_HeadLineSection" border="0" width="100%">
	<tr>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
	<tr>
		<td role="presentation" valign="top"></td>
		<td class="eTicketContentBold" align="center">
                            <h2 class="webAccessHead"><span id="MarketingMsg_ShowMsg_ctl04_HeadLine">Hazardous materials</span></h2>
                        </td>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
</table>

            </td>
        </tr>
        <tr>
            <td>
                <ul style="margin:0 0 0 10px;">        
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl04_ShowDetailMsg_ctl00_MessageText"></span> <p>Federal law forbids the carriage of hazardous materials on board aircraft in your luggage or on your person. A violation can result in five years imprisonment and penalties of $250,000 or more (49 U.S.C. 5124).</P>
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl04_ShowDetailMsg_ctl01_MessageText"></span> <p>Hazardous materials include explosives, compressed gases, flammable liquids and solids, oxidizers, poisons, corrosives and radioactive materials. Common examples of hazardous materials/dangerous goods</p>
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl04_ShowDetailMsg_ctl02_MessageText"></span> <CONT>include spare or loose lithium batteries, fireworks, strike-anywhere matches, aerosols, pesticides, bleach and corrosive materials.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl04_ShowDetailMsg_ctl03_MessageText"></span> <p>Additional information can be found on:<p/>
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl04_ShowDetailMsg_ctl04_MessageText"></span> <ul style="list-style:none;"><li style="margin-left:0px"><u><a href="http://www.united.com/web/en-US/content/travel/baggage/dangerous.aspx">united.com restricted items page</a></u></li><li style="margin-left:0px"> <u><a href=" http://www.faa.gov/about/initiatives/hazmat_safety/">FAA website Pack Safe page</a></u></li><li style="margin-left:0px"> <u><a href="http://www.tsa.gov/traveler-information/prohibited-items">TSA website Prohibited Items page</a></u></li></ul>
                        </div>
                    </li>
        
            </ul></td></tr>  
    
        <tr>
            <td>
                <table border="0" width="100%" cellpadding="0" cellspacing="0">
                    <tr>
                        <td width="100%"><hr id="MarketingMsg_ShowMsg_ctl05_Line" size="1px" color="#000000"></hr></td>
                    </tr>
                </table>
            </td>            
        </tr>
        <tr>
            <td>
                <table id="MarketingMsg_ShowMsg_ctl05_HeadLineSection" border="0" width="100%">
	<tr>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
	<tr>
		<td role="presentation" valign="top"></td>
		<td class="eTicketContentBold" align="center">
                            <h2 class="webAccessHead"><span id="MarketingMsg_ShowMsg_ctl05_HeadLine">Proud Member of Star Alliance</span></h2>
                        </td>
		<td role="presentation" valign="top"></td>
		<td role="presentation"></td>
	</tr>
</table>

            </td>
        </tr>
        <tr>
            <td>
                <ul style="margin:0 0 0 10px;">        
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl05_ShowDetailMsg_ctl00_MessageText"></span> <CONT> We are making connections so you make yours. You can earn and redeem miles on 28 member airlines offering over 18,000 daily flights to more than 1,300 destinations worldwide.
                        </div>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent">
                        <div style="float:left"></div>
                        <div style="padding-left:17px">
                            <span id="MarketingMsg_ShowMsg_ctl05_ShowDetailMsg_ctl01_MessageText"></span> Go to <u><a href="http://www.staralliance.com/en/">www.staralliance.com</a></u> to find out more. You’ve earned it.
                        </div>
                    </li>
        
            </ul></td></tr>  
        
</table></td>
						</tr>
					</table>
					
					
					<table id="TermsSection" width="100%">
	<tr>
		<td colspan="2" style="height:1px">
								<hr size="1px" color="#000000">
							</td>
	</tr>
	<tr>
		<td colspan="2" align="center" class="eTicketContentBold">IMPORTANT CONSUMER NOTICES </td>
	</tr>
	<tr>
		<td height="10px"></td>
	</tr>
	<tr>
		<td valign="top"><img src="https://www.united.com/web/format/img/email/eticket/bullet/dot_Small.gif" alt="" /></td>
		<td class="eTicketContent"><b>Notice of Baggage Liability Limitations</b> - For domestic travel between points within the United States (except for domestic portions of international journeys), United’s liability for loss of, damage to, or delay in delivery of a customer’s checked baggage is limited to $3,500 per ticketed customer unless a higher value is declared in advance and additional charges are paid (not applicable to wheelchairs or other assistive devices).  For such travel, United assumes no liability for high value, fragile, perishable, or otherwise excluded items; excess valuation may not be declared on certain types of valuable articles.  Further information may be obtained from the carrier. For international travel governed by the Warsaw Convention (including the domestic portions of the trip), maximum liability is approximately 640 USD per bag for checked baggage, and 400 USD per passenger for unchecked baggage. For international travel governed by the Montreal Convention (including the domestic portions of the trip), maximum liability is 1,131 SDRs per passenger for baggage, whether checked or unchecked. For baggage lost, delayed, or damaged in connection with domestic travel, United requires that customers provide preliminary notice within 24 hours after arrival of the flight on which the baggage was or was to be transported and submit a written claim within 45 days of the flight.  For baggage damaged or delayed in connection with most international travel (including domestic portions of international journeys), the Montreal Convention and United require customers to provide carriers written notice as follows: (a) for damaged baggage, within seven days from the date of receipt of the damaged baggage; (b) for delayed baggage, within 21 days from the date the baggage should have been returned to the customer.  Please refer to Rule 28 of United’s Contract of Carriage for important information relating to baggage and other limitations of liability.</td>
	</tr>
	<tr>
		<td valign="top"><img src="https://www.united.com/web/format/img/email/eticket/bullet/dot_Small.gif" alt="" /></td>
		<td class="eTicketContent"><b>Notice of Incorporated Terms</b> - Transportation is subject to the terms and conditions of United’s Contract of Carriage, which are incorporated herein by reference.  Incorporated terms may include, but are not limited to: 1.	Limits on liability for personal injury or death of the customer, and for loss, damage, or delay of goods and baggage, including high value, fragile, perishable, or otherwise excluded items. 2.	Claims restrictions, including time periods within which customers must file a claim or bring an action against the carrier. 3.	Rights of the carrier to change terms of the contract. 4.	Rules about reconfirmation of reservations, check-in times, and refusal to carry. 5.	Rights of the carrier and limits on liability for delay or failure to perform service, including schedule changes, substitution of an alternate air carrier or aircraft, and rerouting.  The full text of United’s Contract of Carriage is available at united.com or you may request a copy at any United ticket counter.  Passengers have the right, upon request at any location where United’s tickets are sold within the United States, to receive free of charge by mail or other delivery service the full text of United’s Contract of Carriage.</td>
	</tr>
	<tr>
		<td valign="top"><img src="https://www.united.com/web/format/img/email/eticket/bullet/dot_Small.gif" alt="" /></td>
		<td class="eTicketContent"><b>Notice of Certain Terms</b> - If you have purchased a restricted ticket, depending on the rules applicable to the fare paid, one or more restrictions including, but not limited to, the following may apply to your travel: (1) the ticket may not be refundable but can be exchanged for a fee for another restricted fare ticket meeting all the rules/restrictions of the original ticket (including the payment of any difference in fares); (2) a fee may apply for changing/canceling reservations; or (3) travel may be restricted to specific flights and/ or times and a minimum and/or maximum stay may be required. United reserves the right to refuse carriage to any person who has acquired a ticket in violation of any United tariffs, rules, or regulations, or in violation of any applicable national, federal, state, or local law, order, regulation, or ordinance.  Notwithstanding the foregoing, you are entitled to a full refund if you cancel a ticket purchased at least a week prior to departure within 24 hours of purchase.</td>
	</tr>
	<tr>
		<td valign="top"><img src="https://www.united.com/web/format/img/email/eticket/bullet/dot_Small.gif" alt="" /></td>
		<td class="eTicketContent"><b>Notice of Boarding Times</b> - For Domestic flights, customers must be at the boarding gate at least 15 minutes prior to scheduled departure.  For International flights, customers must be at the boarding gate at least 30 minutes prior to scheduled departure.  The time limits provided by United in this Notice are minimum time requirements.  Customer and baggage processing times may differ from airport to airport.  Please visit united.com for information regarding airport-specific boarding times.  It is the customer’s responsibility to arrive at the airport with enough time to complete check-in, baggage, and security screening processes within these minimum time limits.  Please be sure to check flight information monitors for the correct boarding gate and the departure time of your flight.  Failure to be at the boarding gate by the required time could result in the loss of your seat without compensation, regardless of whether you are already checked in or have a confirmed seat and boarding pass.</td>
	</tr>
	<tr>
		<td valign="top"><img src="https://www.united.com/web/format/img/email/eticket/bullet/dot_Small.gif" alt="" /></td>
		<td class="eTicketContent"><b>Advice to International Passengers on Carrier Liability</b> - Passengers on a journey involving an ultimate destination or a stop in a country other than the country of departure are advised that international treaties known as the Montreal Convention, or its predecessor, the Warsaw Convention, including its amendments, may apply to the entire journey, including any portion thereof within a country.  For such passengers, the treaty, including contracts of carriage embodied in applicable tariffs, governs, and may limit the liability of the Carrier in respect of death or injury to passengers, and for destruction or loss of, or damage to, baggage, and for delay of passengers and baggage.</td>
	</tr>
	<tr>
		<td valign="top"><img src="https://www.united.com/web/format/img/email/eticket/bullet/dot_Small.gif" alt="" /></td>
		<td class="eTicketContent"><b>Notice - Overbooking of Flights</b> - Airline flights may be overbooked, and there is a slight chance that a seat will not be available on a flight for which a person has a confirmed reservation.  If the flight is overbooked, no one will be denied a seat until airline personnel first ask for volunteers willing to give up their reservation in exchange for compensation of the airline’s choosing.  If there are not enough volunteers, the airline will deny boarding to other persons in accordance with its particular boarding priority.  With few exceptions, including failure to comply with the carrier’s check-in deadlines, which are available upon request from the air carrier, persons, denied boarding involuntarily are entitled to compensation.  The complete rules for the payment of compensation and each airline’s boarding   priorities are available at all airport ticket counters and boarding locations.<i>  Some airlines do not apply these consumer protections to travel from some foreign countries, although other consumer protections may be available.  Check with your airline or your travel agent.</i></td>
	</tr>
	<tr>
		<td height="10px"></td>
	</tr>
</table>

					<table id="FooterSection" width="100%">
	<tr>
		<td height="10px"></td>
	</tr>
	<tr>
		<td align="center" class="eTicketContent"><span id="ThankYou"><B>Thank you for choosing United Airlines</B><BR><a href='http://www.united.com'>united.com</a></span> </td>
	</tr>
	<tr>
		<td height="10px"></td>
	</tr>
	<tr>
		<td align="center" class="eTicketContent"><span id="Footer"><a href='http://www.united.com/web/en-US/content/legal.aspx'>Legal Notices</a>.&nbsp;<a href='http://www.united.com/web/en-US/content/privacy.aspx'>Privacy Policy</a><BR>Copyright &copy; {0} United Airlines, Inc. All rights reserved.<br><br><b>Please do not reply to this message using the &quot; reply &quot; address.</b><br>For assistance, please contact United Airlines via telephone or via e-mail.2016</span> </td>
	</tr>
	<tr>
		<td height="20px"></td>
	</tr>
</table>

				</td>
			</tr>
		</table>
	</div>
</body>
</html>
 conversation-id 36716 date-last-viewed 0 date-received 1481520484 flags 8590195713 remote-id 255391