Subject: eTicket Itinerary and Receipt for Confirmation D0BXY4
From: "United Airlines, Inc. " <[email-masked]>
To: <[email-masked]>
Date: 15 Jun 2018 17:20:24 -0500



<!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="padding-top:20px;" align="right" colspan="2">
<table width="100%" cellpadding="0" cellspacing="0">
	<tr id="Header_Setting1">
	<td>
			<div>
				<div>
                    <h1 style="background:none;font-size:120%;"><span>Receipt for confirmation number </span><span>D0BXY4</span></h1>
					<div style="display:inline-block;"><a id="Header_HyperLinkSetting1A" href="http://www.united.com"><img id="Header_logo01" src="https://www.united.com/web/format/img/email/eticket/UaStarLogoHor.gif" alt="United Airlines, A Star Alliance Member" border="0" /><span class="visuallyhidden">United logo link to home page</span></a></div>
					<div style="display: inline-block; padding-right: 17px; float: right;">
						<div>
							 <div>
                                 <h2 class="webAccessHead">
								    <span id="Header_ConfirmHeader" class="eTicketConfirmationHeader">Confirmation: </span>
                                    <span id="Header_ConfirmationNumber1" class="eTicketConfirmation">D0BXY4</span>
                                 </h2>
                             </div>
							<div>
									 
							</div>
						</div>
					</div>
				</div>
				<div>
					<h2 style="margin:0;background:none;text-transform:none"><span id="Header_DateIssue1" class="detailCaption">Issue Date: June 14, 2018</span> </h2>
				</div>
                <div style="clear:both"></div>
			</div>
		</td>
</tr>

	
	
	
	
	
</table>
</td>
						</tr>
						
						<tr>
							<td class="eTicketContentBold"> </td>
						</tr>
						<tr>
							<td colspan="2" style="height:1px" role="presentation">
								<hr size="1px" color="#000000"/>
							</td>
						</tr>
						<!-- Meeting Work -->
						
						<!-- Traveler Information -->
						<tr>
							<td style="padding-top:10px;" colspan="2"><div id="ShowTravelers_traveler">
	
  <h2 class="eTicketContentBold visuallyhidden" id="travelerinfo1" style="margin-bottom: 4px; background:none">TRAVELER INFORMATION</h2>  
<table border="0" cellpadding="0" cellspacing="0" width="100%" >
   
    <tr>
        <td class="eTicketContentBold" style="vertical-align:top;">            
            <h3 id="travelerinfo" class="webAccessHead">Traveler</h3>
        </td>
        <td class="eTicketContentBold" style="">
            <h3 class="webAccessHead">eTicket Number</h3>
        </td>
        <td class="eTicketContentBold" style="">
            <h3 id="freqFlyerNumber" aria-describedby="freqFlyerNumber" class="webAccessHead">Frequent Flyer<span class="visuallyhidden">Number</span></h3>            
        </td>
        <td class="eTicketContentBold" style="">
            <h3 class="webAccessHead">Seats</h3>
        </td>
    </tr>

    
            <tr>
                <td class="eTicketContent">
                    <p class="pMargin0"><span>STRAUGHTER/ERINNICLOE</span></p>
                </td>
                <td class="eTicketContent">
                    <p class="pMargin0"><span>0162403946788</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" role="presentation">
								<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">
                <p class="pMargin0"><span>Thu, 14JUN18</span></p>
            </td>
            <td class="eTicketContent" valign="top">
                <p class="pMargin0"><span id="ShowSegments_ShowSegment_ctl00_Flight">UA2281</span></p>
            </td>
            <td class="eTicketContent" valign="top">
                <p class="pMargin0"><span>Y</span></p>
            </td>
            <td class="eTicketContent" valign="bottom">
                <span id="ShowSegments_ShowSegment_ctl00_DepatureCity">LOS ANGELES, CA <BR />(LAX)&nbsp;<b>3:10 PM</b></span>
            </td>
            <td class="eTicketContent" valign="bottom">
                <p class="pMargin0"><span>WASHINGTON, DC <BR />(IAD - DULLES)&nbsp;<b>11:06 PM</b></span></p>
            </td>
            <td class="eTicketContent" valign="top">
                <p class="pMargin0"><span></span></p>
            </td>
            <td class="eTicketContent" valign="top">
                <p class="pMargin0"><span>Lunch</span></p>
            </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>Fri, 15JUN18</span>
            </td>
            <td class="eTicketContent" style="background-color: LightGrey" valign="top">
                <span id="ShowSegments_ShowSegment_ctl01_Flight">UA1448</span>
            </td>
            <td class="eTicketContent" style="background-color: LightGrey" valign="top">
                <span>A</span>
            </td>
            <td class="eTicketContent" style="background-color: LightGrey" valign="bottom">
                <span id="ShowSegments_ShowSegment_ctl01_DepatureCity">WASHINGTON, DC <BR />(IAD - DULLES)&nbsp;<b>10:01 PM</b></span>
            </td>
            <td class="eTicketContent" style="background-color: LightGrey" valign="bottom">
                <span>LOS ANGELES, CA <BR />(LAX)&nbsp;<b>12:29 AM (16JUN)</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>Snack</span>
            </td>
        </tr>
        <tr>  
            <td class="eTicketContent" style="background-color: LightGrey;font-size: 8pt" valign="top" colspan="7">
                <p class="pMargin0"><span></span></p>
            </td>
        </tr>

        <tr><td style="height:5px"></td></tr>
                
</table>


</td>
						</tr>
						<tr>
							<td colspan="2" style="height:1px" role="presentation">
								<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 0 10px;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="50%">
			<h3 style="text-align:left;margin:0;background:none;" align="left" class="eTicketContentBold">Fare Breakdown </h3>
            <ul style="list-style:outside none none; margin-top:0px" class="webAccessList">
                <li style="clear:both; margin:5px 0px; overflow:hidden; float:none">
                    <div class="eTicketContent" style="width:190px; float:left; text-align:left;">Airfare:</div>
                    <div class="eTicketContent"  style="width:80px; float:left; text-align:right"><span id="FareInfo_AirFare" class="eTicketContent">1,855.81</span></div>
                    <div class="eTicketContent" style="width:10px; float:left; text-align: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">
								U.S. Transportation Tax: 
							</div>
							<div class="eTicketContent" style="width:80px;text-align:right;float:left;padding-right:10px">
								139.19
							</div>
							
						</li>
					
						<li style="margin-left:0;clear:both">
							<div class="eTicketContent" style="width:190px;text-align:left;float:left">
								U.S. Flight Segment Tax: 
							</div>
							<div class="eTicketContent" style="width:80px;text-align:right;float:left;padding-right:10px">
								8.20
							</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 style="margin-left:0;clear:both">
							<div class="eTicketContent" style="width:190px;text-align:left;float:left">
								U.S. Passenger Facility Charge: 
							</div>
							<div class="eTicketContent" style="width:80px;text-align:right;float:left;padding-right:10px">
								9.00
							</div>
							
						</li>
					
                 <li id="FareInfo_PerPersonTotalSection" style="clear:both; margin:5px 0px; overflow:hidden; float:none">
                    <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">2,023.40</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="clear:both; margin:5px 0px; overflow:hidden; float:none; 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">2,023.40</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 valign="top">
					<td align="left" valign="top" class="eTicketContent"> </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 1251</span></td>
				</tr>
			</table>
			
		</td>
			<td role="presentation" align="left" valign="top" width="185px">
			
			
		</td>
		</tr>
		<tr id="FareInfo_AirFareSummaryRow">
			<td colspan="3"><span id="FareInfo_AirFareSummary" class="eTicketContent">The airfare you paid on this itinerary totals:&nbsp;1,855.81 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;167.59 USD</span> </td>
		</tr>
		<tr>
			<td role="presentation" style="height: 10px"></td>
		</tr>
	</table>
	
<table id="FareInfo_FareRuleSection" style="width: 100%">
		<tr>
			<td valign="top" class="eTicketContent" style="width: 100px"><p class="pMargin0">Fare Rules:</p></td>
			<td><p style="padding-top:0px"><span id="FareInfo_FareRule" class="eTicketContent">Additional charges may apply for changes in addition to any fare rules listed.<BR></span></p>
		</td>
		</tr>
		<tr>
			<td role="presentation" style="height: 10px"></td>
		</tr>
	</table>
	

<table cellpadding="0" cellspacing="0" style="width: 100%">
	
	
	<tr id="FareInfo_AddCollectRow">
		<td valign="top" align="left" class="eTicketContent" style="width: 100px">Add Collect:</td>
		<td align="left" valign="top"><span id="FareInfo_AddCollectDisplay" class="eTicketContent">An additional amount for the difference in fare was charged to VISA VIXXXXXXXXXXXX1251 on Friday, June 15, 2018. $297.00 USD per ticket for an additional total of $297.00 USD was collected.</span><br />
		</td>
	</tr>
	
	<tr>
		<td role="presentation" style="height: 10px"></td>
	</tr>
	
	
	
	
	
	<tr>
		<td role="presentation" style="height: 10px"></td>
	</tr>
</table>

<table width="100%">
	
			<tr>
				<td valign="top" align="left" class="eTicketContent" width="100px"><span id="FareInfo_SSTRepeater_ctl00_AdditionalChargesHeader">Additional Charges:</span> </td>
				<td class="eTicketContent">
					Thu., Jun. 14, 2018/Visa 1251 was charged 259 USD for the Merchandising / EDD 01629249237910<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;259.00 USD for: Premium Cabin Upgrade<br />
				</td>
			</tr>
			<tr height="10px">
				<td role="presentation" colspan="2"></td>
			</tr>
		
</table>
</td>
</tr>

						<tr id="trFareInfoSpacer">
	<td colspan="2" style="height:1px" role="presentation">
								<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'>6/14/2018 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><tr align='center'><td class='eTicketContent'>6/15/2018 Washington, DC (IAD - Dulles) to Los Angeles, CA (LAX)</td><td class='eTicketContent'>0.00 USD</td><td class='eTicketContent'>0.00 USD</td><td class='eTicketContent'>70.0lbs (32.0kg) - 62.0in (157.0cm)</td></tr></table></span><br />
<span id="BagFees_lblFeeWaiverMsg" class="eTicketContent">The service charges for standard first and second checked bags (within specified size and weight limits) have been waived based on the fare purchased. Changes to the fare type purchased could result in increased baggage service charges.<br /><br /></span><br />
</td>
                        </tr>
                        <tr>
							<td colspan="2" style="height: 1px" role="presentation">
								<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; list-style:none; padding-top:8px"">        
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl00_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <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
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl01_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <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
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl02_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <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
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl03_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl03_MessageText"></span> PQD are a Premier status requirement for members in the U.S. only.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl04_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl00_ShowDetailMsg_ctl04_MessageText"></span> Accrual is only displayed for MileagePlus members who choose to accrue to their MileagePlus account.
                        </span>
                    </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">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; list-style:none; padding-top:8px"">        
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl00_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <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.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl01_MessageText"></span> <b>EXCEPTION</b>: When departing from Anchorage, Atlanta, Austin, Baltimore, Chicago, Cincinnati, Cleveland, Dallas/Ft. Worth, Denver, Detroit, Fort Lauderdale, Greenville-Spartanburg, Guam, Honolulu, Houston, Indianapolis, Jacksonville,
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl02_MessageText"></span> Kona, Las Vegas, Los Angeles, Maui, Miami, New York (LGA), Newark, Orange County (SNA), Orlando, Philadelphia, Phoenix, Pittsburgh, Raleigh/Durham, Reno, San Diego, San Francisco, San Juan, PR (60 minutes), Savannah, Seattle, St. Louis,
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl03_MessageText"></span> St. Thomas, U.S. Virgin Islands (60 minutes), Tampa, Washington, DC (both IAD and DCA), the check in requirement time for Passengers and Bags is 45 minutes except where noted.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl04_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl04_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.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl05_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl05_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.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl06_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl06_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.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl07_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl07_MessageText"></span> The FAA now restricts carry-on baggage to one bag plus one personal item (purse, briefcase, laptop computer, etc.) per passenger. The fare rules for your ticket may restrict your carry-on baggage allowance even further.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl08_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl08_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.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl09_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl09_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.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl10_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl10_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.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"><img id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl11_Bullet" src="http://www.united.com/img/eTicket/Bullets/dot_Small.gif" border="0" /></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl01_ShowDetailMsg_ctl11_MessageText"></span> Your eTicket is non transferable and valid for 1 year from the issue date unless otherwise noted in the fare rules.
                        </span>
                    </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">Data Protection Notice</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; list-style:none; padding-top:8px"">        
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl02_ShowDetailMsg_ctl00_MessageText"></span> Your personal data will be processed in accordance with the applicable carriers privacy policy and if your booking is made via a reservation system provider ("GDS"), with its privacy policy. These are available at
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl02_ShowDetailMsg_ctl01_MessageText"></span> http://www.iatatravelcenter.com/privacy or from the carrier or GDS directly. You should read this documentation, which applies to your booking and specifies, for example, how your personal data is
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl02_ShowDetailMsg_ctl02_MessageText"></span> collected, stored, used, disclosed and transferred
                        </span>
                    </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">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; list-style:none; padding-top:8px"">        
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl03_ShowDetailMsg_ctl00_MessageText"></span> <p>We welcome your compliments, comments or complaints regarding United or a United travel experience.</p>
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl03_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>
                        </span>
                    </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; list-style:none; padding-top:8px"">        
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <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>
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <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>
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <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.
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl04_ShowDetailMsg_ctl03_MessageText"></span> <p>Additional information can be found on:<p/>
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <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>
                        </span>
                    </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">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; list-style:none; padding-top:8px"">        
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl05_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
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl05_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
                        </span>
                    </li>
            
                    <li class="webAccessReceipt eTicketContent" style="overflow:hidden;padding-top:8px">
                        <span style="width:17px; display:inline-block; vertical-align:top"></span>
                        <span style="display:inline-block; width:95%; font-size:13px">
                            <span id="MarketingMsg_ShowMsg_ctl05_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.
                        </span>
                    </li>
        
            </ul></td></tr>  
        
</table></td>
						</tr>
					</table>
					
					
					<table id="TermsSection" width="100%">
	<tr>
		<td colspan="2" style="height:1px" role="presentation">
								<hr size="1px" color="#000000">
							</td>
	</tr>
	<tr>
		<td colspan="2" style="padding-bottom:10px;" align="center" class="eTicketContentBold">IMPORTANT CONSUMER NOTICES </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"><strong>Notice of Baggage Liability Limitations</strong> - 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"><strong>Notice of Incorporated Terms</strong> - 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"><strong>Notice of Certain Terms</strong> - 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) select tickets may not be eligible for refunds or changes even for a fee; (4) select tickets have no residual value and cannot be applied towards the purchase of future travel; or (5) 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"><strong>Notice of Boarding Times</strong> - 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="adviceToInternational"><strong>Advice to International Passengers on Carrier Liability</strong> - 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="noticeOverBooking"><strong>Notice - Overbooking of Flights</strong> - 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>
</table>

					<table id="FooterSection" width="100%" style="margin-top:20px;">
	<tr>
		<td align="center" style="padding:20px 0px;" 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 align="center" style="padding-bottom:20px;" 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><p style='margin:0em;'>Copyright &copy; 2018 United Airlines, Inc. All rights reserved.</p><p style='margin-top:0em;'>For assistance, please contact United Airlines via telephone or via e-mail.</p></span> </td>
	</tr>
</table>

				</td>
			</tr>
		</table>
	</div>
</body>
</html>
 color 000000 conversation-id 21670 date-last-viewed 1635356794 date-received 1529101225 flags 8590195857 remote-id 297988