﻿<?xml version="1.0" encoding="utf-8"?><rg:licenseGroup xmlns:rg="urn:mpeg:mpeg21:2003:01-REL-R-NS"><r:license xmlns:r="urn:mpeg:mpeg21:2003:01-REL-R-NS" licenseId="{edf8aeeb-7ed9-45ee-82bb-9513e445eb3a}" xmlns:sx="urn:mpeg:mpeg21:2003:01-REL-SX-NS" xmlns:mx="urn:mpeg:mpeg21:2003:01-REL-MX-NS" xmlns:sl="http://www.microsoft.com/DRM/XrML2/SL/v2" xmlns:tm="http://www.microsoft.com/DRM/XrML2/TM/v2"><r:title>XrML 2.1 License - Product Key Configuration</r:title><r:issuer><Signature xmlns="http://www.w3.org/2000/09/xmldsig#"><SignedInfo><CanonicalizationMethod Algorithm="http://www.microsoft.com/xrml/lwc14n"/><SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/><Reference><Transforms><Transform Algorithm="urn:mpeg:mpeg21:2003:01-REL-R-NS:licenseTransform"/><Transform Algorithm="http://www.microsoft.com/xrml/lwc14n"/></Transforms><DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/><DigestValue>Jlu2W5fQM4205NWpTV2TPXmudZQ=</DigestValue></Reference></SignedInfo><SignatureValue>EAbuaf/gaNjQ+o/+5jwUw3TJVzOHC8atsPyrMuTbH2mdnpY+yryQyKO96H+p4EkPCGWgiCbRk8lEnycPMIkDnaXJjncvyy8IeXTnfugoQS1DxqfT+6gMQ10v0gxllBfeEt2opYpSVorftb+rlYAyl6GNj/7uxbCflHKNuxfEdZEEG0X9Xc0KayPSxy1tdJ52dlwTFnlju9Fed+/imewoG3YDLbj0BnktplPY9KZZqbSi9CavKas4qMVSwQAYg9JXohbMJaJu26lmCXxA/iE+3Mvz1HPfJi/BdVIdzsiuLo4U4eBGWn1jRxmoijfsxYy1i1kYrovs7i25IRzHkOo5pg==</SignatureValue><KeyInfo><KeyValue><RSAKeyValue><Modulus>1N+QaYteSIjGmRMzTkxCE+5oiPoLk2Fq+RA9GLnl+dHOcyxt2a/0HvUdagaL/NwDquzOef4JOMMuVavd4PtWQiO/aBLvxVv7yIhUhhB6PEsw59mhbVlT/Z5OGkp6gfzH9ezZ+qHHFHo0cloAAu5QGUeuYCPLheVK7X3+syHE1qXagfRa5m0xG+770FyPeMKazK+keeQ/goW+nt2wTM9Pofj4yTGCbn6Fc6EpKdyHmzrzQDc5FjZemXP2PbGjS6iPC7l3+Ut5JPL66ZUZzCs5qRc+/wRODknUWAcqURJWP79knfPhf3/dvbytHpr64wFfpBNDSbNVubol0E8oTa/NYw==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue></KeyValue></KeyInfo></Signature></r:issuer><r:otherInfo xmlns:r="urn:mpeg:mpeg21:2003:01-REL-R-NS"><tm:infoTables xmlns:tm="http://www.microsoft.com/DRM/XrML2/TM/v2"><tm:infoList tag="#global"><tm:infoStr name="licenseType">msft:sl/PKEYCONFIG/SIGNED</tm:infoStr><tm:infoStr name="licenseCategory">msft:sl/PKEYCONFIG/SIGNED</tm:infoStr><tm:infoStr name="licenseVersion">2.0</tm:infoStr><tm:infoBin name="pkeyConfigData"><?xml version="1.0" encoding="utf-8"?>
<pkc:ProductKeyConfiguration xmlns:pkc="http://www.microsoft.com/DRM/PKEY/Configuration/2.0">
	<pkc:Configurations>
		<pkc:Configuration>
			<pkc:ActConfigId>{6a8ed375-e507-49d7-9b38-1623b8e6ff0c}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerHomeStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Standard</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b4b3dccb-b321-4393-8123-3659ec75a192}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerHomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Premium</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{3b18e76c-2384-4029-a596-c939c91cb7be}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerHomeStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Standard - OEM SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e40d338b-76d2-4755-a8a0-b530d9d970bc}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerHomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Premium - OEM SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0d621b72-d593-4e42-bbab-1911c7326549}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerHomeStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Standard - OEM SLP COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{79295998-90ab-4eb2-a093-073ac441006f}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerHomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Premium - OEM SLP COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{725a3567-0181-498f-be72-31741bf08070}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerHomeStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Standard - OEM NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5cb0425f-a4d4-4d4a-8b5f-9ceb4211b322}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerHomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Premium - OEM NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{13d1b96c-1375-43a4-99e7-7e7fefe21f53}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerHomeStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Standard</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{26186aee-5833-4d48-b59d-a1a29c8cbc2d}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerHomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Premium</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>BusinessN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business N Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d0333dad-c14e-46f2-b62a-8b47a1b9768b}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic N Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{fd3bcb98-5c55-4b2d-ae32-a4515e3c17a3}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business - OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f758e09b-7c7c-492c-b78c-aba5bd4e3f5b}</pkc:ActConfigId>
			<pkc:RefGroupId>144</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f14a0fcc-9198-49d0-9b48-61398a545aae}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business - D-OEM (CHS &amp; RU) OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{92bc39aa-055e-4919-adca-763fcde047b8}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>BusinessN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business N OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e8d89889-a417-408a-8180-02a89339580d}</pkc:ActConfigId>
			<pkc:RefGroupId>144</pkc:RefGroupId>
			<pkc:EditionId>BusinessN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business N OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{fdc08872-563e-4e3a-ad19-981c2c58b4d9}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>BusinessN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business N OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9680dca9-c58d-4f58-817e-ff16ffc626c8}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic N OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9c5c23f2-a6c3-4c6c-b9b4-1f8796b63254}</pkc:ActConfigId>
			<pkc:RefGroupId>144</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic N OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{827661ef-a4de-4110-9b8a-4c7fdc42dc89}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic N OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{199086aa-6cb8-4e5b-b698-f2be56f1e8ee}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic - OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:ActConfigId>
			<pkc:RefGroupId>144</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic - D-OEM (CHS &amp; RU) OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bffdc375-bbd5-499d-8ef1-4f37b61c895f}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium - OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a4eec485-e375-48b4-8f51-80d13a4086b6}</pkc:ActConfigId>
			<pkc:RefGroupId>144</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b6795467-dc45-4acf-af87-e948ee3f15f4}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Premium - D-OEM (CHS &amp; RU) OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{851f81c4-16c6-4de8-a20a-dcebd6b76c89}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Starter - OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{94451d5d-8520-43d3-af38-4e54d817a407}</pkc:ActConfigId>
			<pkc:RefGroupId>144</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Starter - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{89e51a3c-76c0-4beb-a650-53d34c8f8186}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Starter - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5e802570-4657-4e84-bfbc-6a0e531b84af}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate - OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f79b5e33-4a4e-451c-9e8a-55dcc9bdb89d}</pkc:ActConfigId>
			<pkc:RefGroupId>144</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{33a7e8d3-e2ab-413b-96a6-27c83b21c695}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d584adf1-69e1-4710-98a3-89f37b940020}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>Enterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Enterprise - OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{212a64dc-43b1-4d3d-a30c-2fc69d2095c6}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista ALL Volume SKUs - CSVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{74e464f6-45db-41f6-9356-66260bdf3c65}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista ALL Volume SKUs - MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2c682dc2-8b68-4f63-a165-ae291d4cf138}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>BusinessN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business N - GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4f3d1606-3fea-4c01-be3c-8d671c401e3b}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business - GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{cfd8ff08-c0d7-452b-9f60-ef5c70c32094}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Enterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Enterprise - GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b51791c2-b562-4b73-97b0-735a0e4429a6}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Enterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Enterprise Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{afd5f68f-b70f-4000-a21d-28dbc8be8b07}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>OCUR</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista OCUR add-on Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Standard Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{15a581b4-f839-4d26-943c-b7e72f219849}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Standard OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Standard OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{56df4151-1f9f-41bf-acaa-2941c071872b}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Standard &amp; Enterprise CSVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Standard &amp; Enterprise MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{65ab7338-9ad0-43fe-af1b-190b577495e2}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerStandardV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Standard without Hyper-V Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0e18c71e-3a85-4063-b380-419652de3733}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerStandardV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Standard without Hyper-V OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2e063f49-6ce7-4099-be9e-8b1c3590f5c8}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerStandardV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Standard without Hyper-V OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{866e924e-c2a3-4872-aca1-6b48c13962d5}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Datacenter Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5762371d-a6fe-4fea-af1b-b9f0367d8e46}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Datacenter OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{28169020-83db-42d0-87bb-7709454c5f62}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Datacenter OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f209258f-33ca-4a14-a45c-5cafa7259ab5}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenterV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Datacenter without Hyper-V OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d020c729-07f0-4f8f-87ce-bf803275c786}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenterV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Datacenter without Hyper-V OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c90d1b4e-8aa8-439e-8b9e-b6d6b6a6d975}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Datacenter &amp; Itanium CSVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Datacenter &amp; Itanium MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{256cc990-1692-4ea8-965c-2d423d5dd24e}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 for Itanium-Based Systems nonSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{766d0cf7-accb-4fe9-b9a0-b4bfa8ae7550}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 for Itanium-Based Systems OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{32b40e5e-0c6d-4c6f-ab12-a031933fd2c6}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Enterprise Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{94dd1d84-9d70-45ff-ae30-6c1643e583ac}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Enterprise OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a6ad72e3-67a6-4d46-af1c-5f542c22ef7c}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Enterprise OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1ba5e036-e386-42c4-b7eb-16bdb4fa1945}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Enterprise without Hyper-V Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d063c01b-b1c3-442c-8cc4-4be55a1a01df}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Enterprise without Hyper-V OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{388afeb9-3b92-44a2-a3dd-1e68665f6d36}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Enterprise without Hyper-V OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a77a6806-f59e-4953-97d7-229317b8e6a6}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Windows Web Server 2008 Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bab219ac-3f91-4cdc-8339-b643cbdd6c49}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Windows Web Server 2008 OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8210c9d1-4686-4f46-ac2e-56cf4e6ba674}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Windows Web Server 2008 OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c448fa06-49d1-44ec-82bb-0085545c3b51}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Web &amp; Compute Cluster Server 2008 CSVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c1af4d90-d1bc-44ca-85d4-003ba33db3b9}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Enterprise GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8198490a-add0-47b2-b3ba-316b12d647b4}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 EnterpriseV GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ddfa9f7c-f09e-40b9-8c1a-be877a9a7f4b}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Web GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ad2542d4-9154-4c6d-8a44-30f11ee96989}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Standard GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2401e3d0-c50a-4b58-87b2-7e794b7d2607}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerStandardV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 StandardV GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{68b6e220-cf09-466b-92d3-45cd964b9509}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Datacenter GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{fd09ef77-5647-4eff-809c-af2b64659a45}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenterV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 DatacenterV GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{01ef176b-3e0d-422a-b4f8-4ea880035e8f}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Itanium GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Web &amp; Compute Cluster Server 2008 MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7afb1156-2c1d-40fc-b260-aab7442b62fe}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerComputeCluster</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 Compute Cluster GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{12d7799d-9db2-4378-abb8-efaca84a6133}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Starter OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{132ccb0c-51e9-49c4-b157-ccf977259947}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>BusinessN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business N Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate N - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{faba8d9b-3ad6-4529-b11d-d41ec9b5d47b}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0101b69a-85c8-4344-8196-7a16a7790bb5}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{776ec0e8-2a6f-4e55-94f2-b6b1fa9cf4c5}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium N - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{413036e1-7bcf-4a02-bab4-7b6916f17f87}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home PremiumN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Starter - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{55e6dada-345d-41ab-83f0-99ad84ac1d19}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium N OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d6a70f3f-2052-4633-a9aa-25ea0cdff672}</pkc:ActConfigId>
			<pkc:RefGroupId>158</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{3a1d44e2-bede-46fb-8a02-0cd485a1db8b}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b4b150d0-ec09-4f74-910d-371ed161b2ac}</pkc:ActConfigId>
			<pkc:RefGroupId>160</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d4f54950-26f2-4fb4-ba21-ffab16afcade}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>EnterpriseN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista EnterpriseN GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate N Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1f59edc8-ad79-4d96-a62d-c33ee78da2ec}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f00fa8e9-ac0f-4f43-a259-a26c110cbbf9}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{24d57dfd-f6e1-48f9-a045-0520a52f84c7}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Starter OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2bd10086-9094-4140-801e-3d8ec5b0ac25}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate N - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{56a13760-2b9c-406f-be8a-8f2ef22f10b5}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{70453a75-42cb-49ba-83d8-d9dc6295901b}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Starter Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7fbe00d4-bff2-47a3-99a7-6387fd509ae2}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista UltimateN - OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{829a4bc1-2a89-47ba-a638-0b8a206b0986}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{cd2e414a-e728-421e-a934-73506387d641}</pkc:ActConfigId>
			<pkc:RefGroupId>158</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c2f2d79e-121d-482c-b665-83f052c8cbcc}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Basic - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b13b0123-8661-4ee2-afb7-05c37481686b}</pkc:ActConfigId>
			<pkc:RefGroupId>162</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Ultimate - OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8f1c2cd6-4d70-4122-8eee-b4de3fb9ba17}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista UltimateN MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{90f4e13a-12fb-4840-b9ab-91cfb9fac5e2}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista UltimateN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a797d61e-1475-470b-86c8-f737a72c188d}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>StarterN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista StarterN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a3481201-436e-4fc9-88b4-34ccf7f81789}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c3505bd0-004a-49b9-84db-a1a4869eddf1}</pkc:ActConfigId>
			<pkc:RefGroupId>148</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium - OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Home Premium N Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1105ac4c-f808-42d2-a6ae-f46183169f6f}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Starter Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4871de8b-3adf-4455-a7d3-fd7b6c01c939}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista ALL Volume SKUs - CSVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{95a6eef2-89d4-4759-b65b-0a0748994b82}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>CodecPack</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista CODEC add-on Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e12dd57d-07d5-4f64-9139-a92489a626b0}</pkc:ActConfigId>
			<pkc:RefGroupId>154</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista Business OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{58c37517-42f8-4723-bb44-30b05791ff2a}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>EnterpriseN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista EnterpriseN  Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8df04457-07c8-4301-bce9-d61eb76cb2d6}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerHomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Premium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5bd23b19-aa71-4a5b-8b68-c8801c2baff6}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerHomeStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server Standard Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b86c7736-91ff-4de9-bfa9-b32b8a09acac}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessManagement</pkc:EditionId>
			<pkc:ProductDescription>Longhorn Medium Business Server Management Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d3f5642f-081d-40b2-a4b9-efd3054d4584}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessMessaging</pkc:EditionId>
			<pkc:ProductDescription>Longhorn Medium Business Server Messaging Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c6936a36-69f3-4994-9857-3069c7b9ec7a}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessSecurity</pkc:EditionId>
			<pkc:ProductDescription>Longhorn Medium Business Server Security Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{cc4c2cf8-ef29-4d8e-b168-2b65a3db3309}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSPremium</pkc:EditionId>
			<pkc:ProductDescription>Longhorn SBS Premium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b3827b27-bd38-4284-98af-e4f4d1c051a0}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSPrime</pkc:EditionId>
			<pkc:ProductDescription>Longhorn SBS Prime Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{96fd21ec-7c70-4c04-9fce-b034941c0473}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSPrime</pkc:EditionId>
			<pkc:ProductDescription>ProdKey3 Windows Server Foundation 00150 ProdAct 10 nonOA II OEM</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9f5cfb3d-6288-4f6f-9d57-fffd843d53e6}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSPrime</pkc:EditionId>
			<pkc:ProductDescription>ProdKey3 Windows Server Foundation 2008 00150 OEMAct/Preinstall PrePop OA II</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5dad0eff-3f6f-4310-8844-422f9dc7c84b}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Longhorn SBS Standard Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2be204da-24a0-4943-b66c-81e8464acd7e}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Enterprise  Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{60207eba-8b4a-486c-a013-023b4b742c2f}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageExpress</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Express Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{368856e9-43f7-4601-8358-e561f36c7dd8}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server  Standard Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4bf433fa-ab04-4c6c-b55b-00170e14b8cd}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageWorkgroup</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Workgroup Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f92f836d-4d3e-4e90-a08f-2d612d65e716}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSB</pkc:EditionId>
			<pkc:ProductDescription>Longhorn Server for Small Business Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{3059a9fd-b068-4f0d-acaf-66324dca67ac}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSBV</pkc:EditionId>
			<pkc:ProductDescription>Longhorn Server for Small Business V Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2cf1c8d6-ebe1-4ce9-83c6-c4877fae1355}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerHyper</pkc:EditionId>
			<pkc:ProductDescription>Hyper-V ProdAct All Programs Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c9ad502b-ef48-41d1-a2a0-38a38e82fed0}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerComputeCluster</pkc:EditionId>
			<pkc:ProductDescription>Longhorn Compute Cluster Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5e9f548a-c8a9-44e6-a6c2-3f8d0a7a99dd}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerComputeClusterV</pkc:EditionId>
			<pkc:ProductDescription>Longhorn Compute Cluster V Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6860916b-c83f-4d66-a28c-c6b78499e7d0}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSPremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server Premium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{58a6435c-0657-4912-b0f5-810215560e47}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server Standard OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d034a056-e1d5-43e0-9511-7586b6d335eb}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server Standard OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server Standard Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{79303950-2706-45d7-8157-2f00cdf0d1a4}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSB</pkc:EditionId>
			<pkc:ProductDescription>Windows Server for Small Business OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9f6afe16-133b-4ee3-9278-3d5d32dd2579}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSB</pkc:EditionId>
			<pkc:ProductDescription>Windows Server for Small Business OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9e52b173-d1b8-4cc7-8a68-fd2ab63e25e0}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSB</pkc:EditionId>
			<pkc:ProductDescription>Windows Server for Small Business Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{104434dc-1ca5-43dd-a2c1-aa662b5dc912}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSBV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server for Small Business OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7f8cb0c8-047f-4544-a308-0e3561354ea8}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSBV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server for Small Business OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7b5306ad-0d02-463c-8177-59087ff8a58b}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSBV</pkc:EditionId>
			<pkc:ProductDescription>Windows Server for Small Business Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{88a30fce-0fde-49b0-8cc6-4fbd568e7b5d}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerComputeCluster</pkc:EditionId>
			<pkc:ProductDescription>Windows Server HPC Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4e491fef-6f37-42a3-ab48-4314d83e3627}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerComputeCluster</pkc:EditionId>
			<pkc:ProductDescription>Windows Server HPC Retail virtual</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0447e96f-4062-4c1b-b068-98c8326016f2}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerComputeCluster</pkc:EditionId>
			<pkc:ProductDescription>Windows Server HPC OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9515b08e-d839-4df3-bfe7-daecde02d97e}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerComputeCluster</pkc:EditionId>
			<pkc:ProductDescription>Windows Server HPC OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{911e20cb-83ea-44ed-8799-073be1f77f22}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerComputeCluster</pkc:EditionId>
			<pkc:ProductDescription>Windows Server HPC OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessManagement</pkc:EditionId>
			<pkc:ProductDescription>Windows Medium Business Server Management  Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessMessaging</pkc:EditionId>
			<pkc:ProductDescription>Windows Medium Business Server Messaging  Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessSecurity</pkc:EditionId>
			<pkc:ProductDescription>Windows Medium Business Server Security  Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7c4ab58c-78f4-4403-bda2-d5bfb449ddf1}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessManagement</pkc:EditionId>
			<pkc:ProductDescription>Windows Medium Business Server Management OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{feb01ead-d438-4556-a5b3-2b6557da8737}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessMessaging</pkc:EditionId>
			<pkc:ProductDescription>Windows Medium Business Server Messaging OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c135db9b-0074-4ef9-a405-a415de4e31a5}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessSecurity</pkc:EditionId>
			<pkc:ProductDescription>Windows Medium Business Server Security OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1404ea26-d078-4786-886a-0da035b2cd5a}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessManagement</pkc:EditionId>
			<pkc:ProductDescription>Windows Medium Business Server Management OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c99b1d91-25f1-4024-a20c-0e9da8d15225}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessMessaging</pkc:EditionId>
			<pkc:ProductDescription>Windows Medium Business Server Messaging OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{74143dee-b000-419d-badc-b650f7e316e4}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessSecurity</pkc:EditionId>
			<pkc:ProductDescription>Windows Medium Business Server Security OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7139ded4-7373-4651-b44b-9de7ea72ccd4}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Standard - MSDN</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ce0df6b6-ff0f-463c-93ed-3cd71752a8ac}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageWorkgroup</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Workgroup - MSDN</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0dddb5b3-94b1-4b69-a916-6c82ea5542c5}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Enterprise - MSDN</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{374a5900-7184-43cd-a96f-abfcc30a1b27}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageExpress</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Express - MSDN</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8e87fd23-319d-4cd6-8aa2-c590b7b0a42c}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageExpress</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Express - OEM COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{3c73fddf-ec70-43b2-b642-abd2d575e102}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Standard - OEM COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{527803e5-f705-433b-a7f1-10b647e5369a}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageWorkgroup</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Workgroup - OEM COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{43329da1-7874-4e67-b612-3d59697b1677}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Enterprise - OEM COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b2b347e5-e754-468d-afc1-7b2187288814}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageExpress</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Express - OEM SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f6c23d59-6d32-4b41-acad-b0fa170733cb}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Standard - OEM SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a499fe43-12de-4873-8971-1cff6173cdaa}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageWorkgroup</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Workgroup - OEM SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{fdd923f8-4409-4a72-becd-d7e9aa59bca3}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Enterprise - OEM SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f6a8f9fe-e072-4cb4-9fe2-a8276a1f161a}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageExpress</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Express - OEM NSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5f4eb8c3-37e4-4a56-97c9-60ad9a03763d}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Standard - OEM NSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{abb3e789-58ae-42ae-b308-bb2c831db127}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageWorkgroup</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Workgroup - OEM NSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{416733c6-d43f-4ba1-b6e0-722aa4573cdf}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerStorageEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server Enterprise - OEM NSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e0872c5d-9308-4c2a-ba9b-22f04a9b9480}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Starter OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{136595fa-543f-4a64-8326-873935b7b7a1}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Ultimate OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{acc41c6f-dc9f-40ca-b0da-108c7a5f8d90}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Basic OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2d2d5664-88bd-4ebc-959a-dea6b1b80dc0}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Business OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f23dba60-517a-4184-bd26-066d9e3c19a9}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Basic OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{08efb8fe-c403-4019-a084-9da91108cead}</pkc:ActConfigId>
			<pkc:RefGroupId>158</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home PremiumN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7e0e0685-8eef-47b8-8b25-f03f9819eb17}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Business OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{da0483a8-c443-45fd-9b52-2bba9b2ee8ab}</pkc:ActConfigId>
			<pkc:RefGroupId>158</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Premium OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{121059c3-724a-48ba-b745-5ab6daad8e37}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Basic OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a7a4a974-ad47-420e-8e1a-83d28572058a}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Premium OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{657fd7f1-652f-4a7f-9cef-e45e60f8b4c7}</pkc:ActConfigId>
			<pkc:RefGroupId>166</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Basic OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{70449d13-fe2e-453e-a19f-68b031ff1a19}</pkc:ActConfigId>
			<pkc:RefGroupId>166</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 UltimateN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6b16d38b-7dac-4614-9948-b4a92ddba889}</pkc:ActConfigId>
			<pkc:RefGroupId>166</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Premium OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c6166b46-aba5-4374-8bdf-be06bde66223}</pkc:ActConfigId>
			<pkc:RefGroupId>166</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home PremiumN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4cb70ae9-faf0-4cc1-88e5-f9d1d388e39a}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Starter OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{95fac25a-4268-48c3-ae04-071ea19594fa}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Ultimate OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6f4429fd-9729-443a-abfc-a3daf21ba4b6}</pkc:ActConfigId>
			<pkc:RefGroupId>166</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Basic OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{11db994f-af86-4eb9-af35-fb4e3b0256f5}</pkc:ActConfigId>
			<pkc:RefGroupId>166</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Premium OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{920b06bf-f7d3-4291-80d3-5d3d91a8be4c}</pkc:ActConfigId>
			<pkc:RefGroupId>166</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Starter OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7fd7e3ea-1a64-4e14-abc6-541992c5ef64}</pkc:ActConfigId>
			<pkc:RefGroupId>166</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Ultimate OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e9528038-4625-4693-ac4d-43387ec18233}</pkc:ActConfigId>
			<pkc:RefGroupId>166</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 UltimateN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ab8e6bc4-0499-484e-8da1-761697126843}</pkc:ActConfigId>
			<pkc:RefGroupId>166</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home PremiumN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{24a6d36e-9110-4081-bec6-fa27c8e860d0}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Business Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{cdb090c3-053c-4cd1-9cb2-e35b1738747a}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Premium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5f44767a-daac-470f-8e93-294b3217f956}</pkc:ActConfigId>
			<pkc:RefGroupId>146</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Basic Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e05164a4-fb9a-471f-8c3a-6959b4cf1b72}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP2 Home Premium OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{86e0a073-040b-4e10-aaf1-55f75482b5a4}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>Business</pkc:EditionId>
			<pkc:ProductDescription>Windows Vista SP1 Business OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d188820a-cb63-4bad-a9a2-40b843ee23b7}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 All Volume Editions Volume:CSVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8fe15d04-fc66-40e6-bf34-942481e06fd8}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 DC and IA64 Volume:CSVLK (KMS_C)</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c99b641f-c4ea-4e63-bec3-5ed2ccd0f357}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Std and Ent Volume:CSVLK (KMS_B)</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f73d1bcd-0802-47dd-b2d9-81bf2f8c0744}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Web and CC Volume:CSVLK (KMS_A)</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{24259a22-3bf0-44af-a68b-1b858bce1894}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Win 8 RTM Enterprise;EnterpriseN;Professional;ProfessionalN Volume:CSVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7b37c913-252b-46be-ad80-b2b5ceade8af}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2012 RTM ServerDatacenter;ServerStandard;ServerMultiPointStandard;ServerMultiPointPremium Volume:CSVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{29d0b60f-66da-4858-bcaf-9eb513cd310d}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Win 8.1 RTM Client Volume SKUs - CSVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{dcb88f6f-b090-405b-850e-dabcccf3693f}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>n/a</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2012 R2 RTM All Volume SKUs - CSVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:CSVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year1</pkc:EditionId>
			<pkc:ProductDescription>Windows Server Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year2</pkc:EditionId>
			<pkc:ProductDescription>Windows Server Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year3</pkc:EditionId>
			<pkc:ProductDescription>Windows Server Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{32163ff8-e96d-40b1-973c-44b9bf096d83}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year4</pkc:EditionId>
			<pkc:ProductDescription>Windows Server Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{338554b7-6f0a-48b6-aef3-ff6b42f1398b}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year5</pkc:EditionId>
			<pkc:ProductDescription>Windows Server Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0ed79ef1-052c-4362-9cdc-5141491d06dd}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year6</pkc:EditionId>
			<pkc:ProductDescription>Windows Server Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-PA</pkc:EditionId>
			<pkc:ProductDescription>Windows Server Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{3ca9443e-6f68-4747-bb5e-7f0fbbd55ef0}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>Server-FES-ESU-Year1</pkc:EditionId>
			<pkc:ProductDescription>Windows Server For Embedded Systems Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{66c3d302-3a0e-4fca-9558-5a185996e592}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>Server-FES-ESU-Year2</pkc:EditionId>
			<pkc:ProductDescription>Windows Server For Embedded Systems Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c5958cad-5b44-4780-8a6c-aa0d7033d261}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>Server-FES-ESU-Year3</pkc:EditionId>
			<pkc:ProductDescription>Windows Server For Embedded Systems Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f2d2e88e-bc56-41ab-9546-e8da76eefe6b}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>Server-FES-ESU-Year4</pkc:EditionId>
			<pkc:ProductDescription>Windows Server For Embedded Systems Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{aa894c3f-dcb9-4907-a7b8-ffe1770b6c56}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>Server-FES-ESU-Year5</pkc:EditionId>
			<pkc:ProductDescription>Windows Server For Embedded Systems Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d9b408a5-e3a9-4063-92b2-87f400cd9efb}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>Server-FES-ESU-Year6</pkc:EditionId>
			<pkc:ProductDescription>Windows Server For Embedded Systems Extended Security Updates add-on MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{130ab21f-ca91-4aae-b67f-ac3b45534731}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year1</pkc:EditionId>
			<pkc:ProductDescription>Windows Srvs 2008 SP2 Extended Security Updates add-on Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a7e6fb3c-cb11-4832-bab0-deee887af138}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year2</pkc:EditionId>
			<pkc:ProductDescription>Windows Srvs 2008 SP2 Extended Security Updates add-on Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{151db6a5-3dfa-4c7f-b5ba-af8d7991adc9}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year3</pkc:EditionId>
			<pkc:ProductDescription>Windows Srvs 2008 SP2 Extended Security Updates add-on Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bf10cbf5-500e-4426-99d9-297874760c80}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year4</pkc:EditionId>
			<pkc:ProductDescription>Windows Srvs 2008 SP2 Extended Security Updates add-on Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{de04b282-b11d-4506-9d33-f8c0bf621bdf}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year5</pkc:EditionId>
			<pkc:ProductDescription>Windows Srvs 2008 SP2 Extended Security Updates add-on Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c7807891-4364-40b8-8093-afac81160d91}</pkc:ActConfigId>
			<pkc:RefGroupId>206</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-Year6</pkc:EditionId>
			<pkc:ProductDescription>Windows Srvs 2008 SP2 Extended Security Updates add-on Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d9205746-5f80-4062-ab75-eda24319d0fc}</pkc:ActConfigId>
			<pkc:RefGroupId>142</pkc:RefGroupId>
			<pkc:EditionId>Server-ESU-PA</pkc:EditionId>
			<pkc:ProductDescription>Windows Srvs 2008 SP2 Extended Security Updates add-on Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration>
	</pkc:Configurations>
	<pkc:KeyRanges>
		<pkc:KeyRange>
			<pkc:RefActConfigId>{6a8ed375-e507-49d7-9b38-1623b8e6ff0c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-87775</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>707999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b4b3dccb-b321-4393-8123-3659ec75a192}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-87776</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>708000000</pkc:Start>
			<pkc:End>717999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3b18e76c-2384-4029-a596-c939c91cb7be}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-91363</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15763010</pkc:Start>
			<pkc:End>15863009</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e40d338b-76d2-4755-a8a0-b530d9d970bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-91364</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>103676340</pkc:Start>
			<pkc:End>103776339</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0d621b72-d593-4e42-bbab-1911c7326549}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-91366</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>235000000</pkc:Start>
			<pkc:End>244999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{79295998-90ab-4eb2-a093-073ac441006f}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-91367</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>245000000</pkc:Start>
			<pkc:End>264999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{725a3567-0181-498f-be72-31741bf08070}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-89802</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>273000000</pkc:Start>
			<pkc:End>282999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5cb0425f-a4d4-4d4a-8b5f-9ceb4211b322}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-89803</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>283000000</pkc:Start>
			<pkc:End>302999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{13d1b96c-1375-43a4-99e7-7e7fefe21f53}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-18918</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>477999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26186aee-5833-4d48-b59d-a1a29c8cbc2d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-18917</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>355000000</pkc:Start>
			<pkc:End>355999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80003</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>14000000</pkc:Start>
			<pkc:End>14499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80003</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>447000000</pkc:Start>
			<pkc:End>448499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80005</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>9000000</pkc:Start>
			<pkc:End>9999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80007</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>25500000</pkc:Start>
			<pkc:End>25999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80008</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>8000000</pkc:Start>
			<pkc:End>8999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d0333dad-c14e-46f2-b62a-8b47a1b9768b}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80009</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>25000000</pkc:Start>
			<pkc:End>25499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80010</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>22500000</pkc:Start>
			<pkc:End>24999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80011</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21000000</pkc:Start>
			<pkc:End>22499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80012</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10000000</pkc:Start>
			<pkc:End>10995999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80013</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>11000000</pkc:Start>
			<pkc:End>13999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d0333dad-c14e-46f2-b62a-8b47a1b9768b}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80014</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>7000000</pkc:Start>
			<pkc:End>7999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80015</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15000000</pkc:Start>
			<pkc:End>20999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80016</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6000000</pkc:Start>
			<pkc:End>6999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c5c23f2-a6c3-4c6c-b9b4-1f8796b63254}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90729</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6000000</pkc:Start>
			<pkc:End>6109999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c5c23f2-a6c3-4c6c-b9b4-1f8796b63254}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90729</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>757000000</pkc:Start>
			<pkc:End>846999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{94451d5d-8520-43d3-af38-4e54d817a407}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90496</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>7000000</pkc:Start>
			<pkc:End>7999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{94451d5d-8520-43d3-af38-4e54d817a407}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90496</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426000000</pkc:Start>
			<pkc:End>445999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f79b5e33-4a4e-451c-9e8a-55dcc9bdb89d}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90724</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>8000000</pkc:Start>
			<pkc:End>9999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f79b5e33-4a4e-451c-9e8a-55dcc9bdb89d}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90724</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>446000000</pkc:Start>
			<pkc:End>465999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f758e09b-7c7c-492c-b78c-aba5bd4e3f5b}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90572</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>11000000</pkc:Start>
			<pkc:End>55999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f758e09b-7c7c-492c-b78c-aba5bd4e3f5b}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90572</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>466000000</pkc:Start>
			<pkc:End>485999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e8d89889-a417-408a-8180-02a89339580d}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90733</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>56000000</pkc:Start>
			<pkc:End>100999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e8d89889-a417-408a-8180-02a89339580d}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90733</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>756999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a4eec485-e375-48b4-8f51-80d13a4086b6}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90561</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>148000000</pkc:Start>
			<pkc:End>194999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a4eec485-e375-48b4-8f51-80d13a4086b6}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90561</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>486000000</pkc:Start>
			<pkc:End>505999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90546</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>310000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90546</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89e51a3c-76c0-4beb-a650-53d34c8f8186}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90494</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>334000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89e51a3c-76c0-4beb-a650-53d34c8f8186}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90494</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>456000000</pkc:Start>
			<pkc:End>475999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{33a7e8d3-e2ab-413b-96a6-27c83b21c695}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90577</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>5000000</pkc:Start>
			<pkc:End>5999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{33a7e8d3-e2ab-413b-96a6-27c83b21c695}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90577</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>476000000</pkc:Start>
			<pkc:End>495999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90528</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>8000000</pkc:Start>
			<pkc:End>12999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90528</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496000000</pkc:Start>
			<pkc:End>510999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90556</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>13000000</pkc:Start>
			<pkc:End>17999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90556</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>516000000</pkc:Start>
			<pkc:End>517499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90557</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>18000000</pkc:Start>
			<pkc:End>22999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90557</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>536000000</pkc:Start>
			<pkc:End>538499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{827661ef-a4de-4110-9b8a-4c7fdc42dc89}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90727</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>33000000</pkc:Start>
			<pkc:End>37999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{827661ef-a4de-4110-9b8a-4c7fdc42dc89}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90727</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436000000</pkc:Start>
			<pkc:End>445999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b6795467-dc45-4acf-af87-e948ee3f15f4}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90555</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>38000000</pkc:Start>
			<pkc:End>38999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b6795467-dc45-4acf-af87-e948ee3f15f4}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90555</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>556000000</pkc:Start>
			<pkc:End>575999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90567</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>39000000</pkc:Start>
			<pkc:End>39999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90567</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>576000000</pkc:Start>
			<pkc:End>595994999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fdc08872-563e-4e3a-ad19-981c2c58b4d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90731</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>40000000</pkc:Start>
			<pkc:End>40999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fdc08872-563e-4e3a-ad19-981c2c58b4d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90731</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>446000000</pkc:Start>
			<pkc:End>455999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90553</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>41000000</pkc:Start>
			<pkc:End>41999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90553</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>596000000</pkc:Start>
			<pkc:End>615999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89e51a3c-76c0-4beb-a650-53d34c8f8186}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90497</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>42000000</pkc:Start>
			<pkc:End>42999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89e51a3c-76c0-4beb-a650-53d34c8f8186}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90497</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>616000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{33a7e8d3-e2ab-413b-96a6-27c83b21c695}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90726</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>44000000</pkc:Start>
			<pkc:End>44999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{33a7e8d3-e2ab-413b-96a6-27c83b21c695}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90726</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>656999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{827661ef-a4de-4110-9b8a-4c7fdc42dc89}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90730</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>45000000</pkc:Start>
			<pkc:End>45999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{827661ef-a4de-4110-9b8a-4c7fdc42dc89}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90730</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>686999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90575</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>46000000</pkc:Start>
			<pkc:End>65999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90575</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>687000000</pkc:Start>
			<pkc:End>706998799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fdc08872-563e-4e3a-ad19-981c2c58b4d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90734</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>66000000</pkc:Start>
			<pkc:End>85999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fdc08872-563e-4e3a-ad19-981c2c58b4d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90734</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>707000000</pkc:Start>
			<pkc:End>726999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f14a0fcc-9198-49d0-9b48-61398a545aae}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90574</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>86000000</pkc:Start>
			<pkc:End>96209999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f14a0fcc-9198-49d0-9b48-61398a545aae}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90574</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>727000000</pkc:Start>
			<pkc:End>746999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b6795467-dc45-4acf-af87-e948ee3f15f4}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90563</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>131000000</pkc:Start>
			<pkc:End>177999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b6795467-dc45-4acf-af87-e948ee3f15f4}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90563</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>747000000</pkc:Start>
			<pkc:End>766999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90564</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>178000000</pkc:Start>
			<pkc:End>224999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90564</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>767000000</pkc:Start>
			<pkc:End>782999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92bc39aa-055e-4919-adca-763fcde047b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90732</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>321100000</pkc:Start>
			<pkc:End>321199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9680dca9-c58d-4f58-817e-ff16ffc626c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90728</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>321200000</pkc:Start>
			<pkc:End>321299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e802570-4657-4e84-bfbc-6a0e531b84af}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90722</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>321300000</pkc:Start>
			<pkc:End>321399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fd3bcb98-5c55-4b2d-ae32-a4515e3c17a3}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90569</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>321400000</pkc:Start>
			<pkc:End>321499900</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bffdc375-bbd5-499d-8ef1-4f37b61c895f}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90558</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>321500000</pkc:Start>
			<pkc:End>321599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{199086aa-6cb8-4e5b-b698-f2be56f1e8ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90543</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>321600000</pkc:Start>
			<pkc:End>321699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{851f81c4-16c6-4de8-a20a-dcebd6b76c89}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90495</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>322000400</pkc:Start>
			<pkc:End>322100399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90546</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>507500000</pkc:Start>
			<pkc:End>530999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90548</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>324000000</pkc:Start>
			<pkc:End>328999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90548</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>897000000</pkc:Start>
			<pkc:End>906999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90549</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>329000000</pkc:Start>
			<pkc:End>333999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90549</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>907000000</pkc:Start>
			<pkc:End>916999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d584adf1-69e1-4710-98a3-89f37b940020}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-95693</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337000000</pkc:Start>
			<pkc:End>337999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-96325</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>338000000</pkc:Start>
			<pkc:End>339599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-96325</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928980000</pkc:Start>
			<pkc:End>936999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f14a0fcc-9198-49d0-9b48-61398a545aae}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-96329</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>336999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f14a0fcc-9198-49d0-9b48-61398a545aae}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-96329</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>827000000</pkc:Start>
			<pkc:End>827999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{212a64dc-43b1-4d3d-a30c-2fc69d2095c6}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-89083</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>26000000</pkc:Start>
			<pkc:End>35999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{74e464f6-45db-41f6-9356-66260bdf3c65}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-89092</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>36000000</pkc:Start>
			<pkc:End>235999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4f3d1606-3fea-4c01-be3c-8d671c401e3b}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-89084</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236020000</pkc:Start>
			<pkc:End>236020009</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2c682dc2-8b68-4f63-a165-ae291d4cf138}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-89086</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236020010</pkc:Start>
			<pkc:End>236020019</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfd8ff08-c0d7-452b-9f60-ef5c70c32094}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-89089</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236020020</pkc:Start>
			<pkc:End>236020029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4f3d1606-3fea-4c01-be3c-8d671c401e3b}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-89662</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236020030</pkc:Start>
			<pkc:End>236020039</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2c682dc2-8b68-4f63-a165-ae291d4cf138}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-89663</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236020040</pkc:Start>
			<pkc:End>236020049</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfd8ff08-c0d7-452b-9f60-ef5c70c32094}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-89664</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236020050</pkc:Start>
			<pkc:End>236020059</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b51791c2-b562-4b73-97b0-735a0e4429a6}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-89098</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236000000</pkc:Start>
			<pkc:End>236009999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b51791c2-b562-4b73-97b0-735a0e4429a6}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-89099</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236010000</pkc:Start>
			<pkc:End>236019999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-00537</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>257000000</pkc:Start>
			<pkc:End>276999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-00538</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU2</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>237000000</pkc:Start>
			<pkc:End>256999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-00539</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>293000000</pkc:Start>
			<pkc:End>296999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-00540</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU2</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>289000000</pkc:Start>
			<pkc:End>292999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-00541</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>283000000</pkc:Start>
			<pkc:End>288999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-00548</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>305000000</pkc:Start>
			<pkc:End>306999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-00550</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU5</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>303000000</pkc:Start>
			<pkc:End>304999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02171</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>313000000</pkc:Start>
			<pkc:End>313999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02172</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>297000000</pkc:Start>
			<pkc:End>299999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d0333dad-c14e-46f2-b62a-8b47a1b9768b}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02173</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>316000000</pkc:Start>
			<pkc:End>316999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d0333dad-c14e-46f2-b62a-8b47a1b9768b}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02174</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>312000000</pkc:Start>
			<pkc:End>312999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02175</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>300000000</pkc:Start>
			<pkc:End>302499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02176</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>277000000</pkc:Start>
			<pkc:End>282999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02177</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>311000000</pkc:Start>
			<pkc:End>311499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02178</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>307000000</pkc:Start>
			<pkc:End>307699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02179</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>315000000</pkc:Start>
			<pkc:End>315999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02190</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>310000000</pkc:Start>
			<pkc:End>310999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02191</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>314000000</pkc:Start>
			<pkc:End>314999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02193</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>309000000</pkc:Start>
			<pkc:End>309999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04106</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>317000000</pkc:Start>
			<pkc:End>327999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d0333dad-c14e-46f2-b62a-8b47a1b9768b}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04107</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>341999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d0333dad-c14e-46f2-b62a-8b47a1b9768b}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04107</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>329000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04108</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>342000000</pkc:Start>
			<pkc:End>352999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04109</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>354000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04110</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>366000000</pkc:Start>
			<pkc:End>377499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04111</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>378000000</pkc:Start>
			<pkc:End>388999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04118</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>414000000</pkc:Start>
			<pkc:End>416999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04118</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>418000000</pkc:Start>
			<pkc:End>418979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d0333dad-c14e-46f2-b62a-8b47a1b9768b}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04119</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>419000000</pkc:Start>
			<pkc:End>420979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04120</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>421000000</pkc:Start>
			<pkc:End>423999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04120</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425000000</pkc:Start>
			<pkc:End>425979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04121</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426000000</pkc:Start>
			<pkc:End>426109999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04122</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>431000000</pkc:Start>
			<pkc:End>432979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04123</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>433000000</pkc:Start>
			<pkc:End>433999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04123</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>437979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{afd5f68f-b70f-4000-a21d-28dbc8be8b07}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04483</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>445000000</pkc:Start>
			<pkc:End>445999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{afd5f68f-b70f-4000-a21d-28dbc8be8b07}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04484</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>446000000</pkc:Start>
			<pkc:End>446999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{afd5f68f-b70f-4000-a21d-28dbc8be8b07}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04484</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>467000000</pkc:Start>
			<pkc:End>468999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{74e464f6-45db-41f6-9356-66260bdf3c65}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-06747</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302500000</pkc:Start>
			<pkc:End>302509999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-11751</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>408000000</pkc:Start>
			<pkc:End>414999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-11751</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>787000000</pkc:Start>
			<pkc:End>801999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-11752</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>415000000</pkc:Start>
			<pkc:End>421999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-11752</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>802000000</pkc:Start>
			<pkc:End>816999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-11753</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>422000000</pkc:Start>
			<pkc:End>428999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-11753</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847000000</pkc:Start>
			<pkc:End>861999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-11757</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>429000000</pkc:Start>
			<pkc:End>435999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-11757</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>862000000</pkc:Start>
			<pkc:End>876999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-75192</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>595995000</pkc:Start>
			<pkc:End>595999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80003</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>448720000</pkc:Start>
			<pkc:End>466239999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04121</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426417000</pkc:Start>
			<pkc:End>427548999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-90615</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426246000</pkc:Start>
			<pkc:End>426336999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-90619</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426166000</pkc:Start>
			<pkc:End>426245999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-90616</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>448500000</pkc:Start>
			<pkc:End>448719999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-84419</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426141000</pkc:Start>
			<pkc:End>426165999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-85689</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>517500000</pkc:Start>
			<pkc:End>535999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-85689</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>538500000</pkc:Start>
			<pkc:End>555999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-85689</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>783000000</pkc:Start>
			<pkc:End>786999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-10422</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>328000000</pkc:Start>
			<pkc:End>328999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-10423</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>353000000</pkc:Start>
			<pkc:End>353999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-10424</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>365000000</pkc:Start>
			<pkc:End>365999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-10425</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>389000000</pkc:Start>
			<pkc:End>389999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02178</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>307720000</pkc:Start>
			<pkc:End>308499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-83251</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>307700000</pkc:Start>
			<pkc:End>307719999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-83250</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>311500000</pkc:Start>
			<pkc:End>311510999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90545</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>195000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90545</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>309999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a4eec485-e375-48b4-8f51-80d13a4086b6}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90560</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>101000000</pkc:Start>
			<pkc:End>117999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f758e09b-7c7c-492c-b78c-aba5bd4e3f5b}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90571</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10000000</pkc:Start>
			<pkc:End>10999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0e18c71e-3a85-4063-b380-419652de3733}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22131</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29035000</pkc:Start>
			<pkc:End>29037499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0e18c71e-3a85-4063-b380-419652de3733}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22132</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29037500</pkc:Start>
			<pkc:End>29039999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0e18c71e-3a85-4063-b380-419652de3733}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22133:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29040000</pkc:Start>
			<pkc:End>29042499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0e18c71e-3a85-4063-b380-419652de3733}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22134:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29042500</pkc:Start>
			<pkc:End>29044999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8210c9d1-4686-4f46-ac2e-56cf4e6ba674}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22096</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>30120000</pkc:Start>
			<pkc:End>30519999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8210c9d1-4686-4f46-ac2e-56cf4e6ba674}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22097:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>30520000</pkc:Start>
			<pkc:End>30919999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{15a581b4-f839-4d26-943c-b7e72f219849}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22127</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29025000</pkc:Start>
			<pkc:End>29027499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{15a581b4-f839-4d26-943c-b7e72f219849}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22128</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29027500</pkc:Start>
			<pkc:End>29029999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{15a581b4-f839-4d26-943c-b7e72f219849}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22129:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29030000</pkc:Start>
			<pkc:End>29032499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{15a581b4-f839-4d26-943c-b7e72f219849}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22130:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29032500</pkc:Start>
			<pkc:End>29034999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{388afeb9-3b92-44a2-a3dd-1e68665f6d36}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22084</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>30920000</pkc:Start>
			<pkc:End>31369999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{388afeb9-3b92-44a2-a3dd-1e68665f6d36}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22085:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>31370000</pkc:Start>
			<pkc:End>31819999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1ba5e036-e386-42c4-b7eb-16bdb4fa1945}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19720</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>86100000</pkc:Start>
			<pkc:End>86199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1ba5e036-e386-42c4-b7eb-16bdb4fa1945}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19722</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>86050000</pkc:Start>
			<pkc:End>86099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1ba5e036-e386-42c4-b7eb-16bdb4fa1945}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20014:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>86200000</pkc:Start>
			<pkc:End>86299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1ba5e036-e386-42c4-b7eb-16bdb4fa1945}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20066:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>86000000</pkc:Start>
			<pkc:End>86049999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{256cc990-1692-4ea8-965c-2d423d5dd24e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22086</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29050000</pkc:Start>
			<pkc:End>29099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{256cc990-1692-4ea8-965c-2d423d5dd24e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22087:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29100000</pkc:Start>
			<pkc:End>29149999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{28169020-83db-42d0-87bb-7709454c5f62}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22098:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29470000</pkc:Start>
			<pkc:End>29594999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{28169020-83db-42d0-87bb-7709454c5f62}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22102</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29595000</pkc:Start>
			<pkc:End>29719999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e063f49-6ce7-4099-be9e-8b1c3590f5c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22111</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>33870000</pkc:Start>
			<pkc:End>34719999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e063f49-6ce7-4099-be9e-8b1c3590f5c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22112</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>53470000</pkc:Start>
			<pkc:End>56969999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e063f49-6ce7-4099-be9e-8b1c3590f5c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22113:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34720000</pkc:Start>
			<pkc:End>35569999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e063f49-6ce7-4099-be9e-8b1c3590f5c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22114:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>56970000</pkc:Start>
			<pkc:End>60469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32b40e5e-0c6d-4c6f-ab12-a031933fd2c6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19719</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>84540000</pkc:Start>
			<pkc:End>84900999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32b40e5e-0c6d-4c6f-ab12-a031933fd2c6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19719</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>83100000</pkc:Start>
			<pkc:End>83299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32b40e5e-0c6d-4c6f-ab12-a031933fd2c6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19721</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>83000000</pkc:Start>
			<pkc:End>83099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32b40e5e-0c6d-4c6f-ab12-a031933fd2c6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20002:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>85560000</pkc:Start>
			<pkc:End>85920999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32b40e5e-0c6d-4c6f-ab12-a031933fd2c6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20002:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>84100000</pkc:Start>
			<pkc:End>84299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32b40e5e-0c6d-4c6f-ab12-a031933fd2c6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20031:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>84000000</pkc:Start>
			<pkc:End>84099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{388afeb9-3b92-44a2-a3dd-1e68665f6d36}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22105</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29270000</pkc:Start>
			<pkc:End>29369999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{388afeb9-3b92-44a2-a3dd-1e68665f6d36}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22106:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29370000</pkc:Start>
			<pkc:End>29469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23862</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81210000</pkc:Start>
			<pkc:End>81214999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23865</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81307000</pkc:Start>
			<pkc:End>81326999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23870</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81327000</pkc:Start>
			<pkc:End>81346999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23873</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81347000</pkc:Start>
			<pkc:End>81366999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23876</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81367000</pkc:Start>
			<pkc:End>81386999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23879</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81387000</pkc:Start>
			<pkc:End>81406999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23882</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81407000</pkc:Start>
			<pkc:End>81426999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23885</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>359000000</pkc:Start>
			<pkc:End>360499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23888</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>101000000</pkc:Start>
			<pkc:End>103499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23891</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>396000000</pkc:Start>
			<pkc:End>397499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23894</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>103500000</pkc:Start>
			<pkc:End>104999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23897</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>181000000</pkc:Start>
			<pkc:End>185999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23900</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>83540000</pkc:Start>
			<pkc:End>83659999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23903</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>84300000</pkc:Start>
			<pkc:End>84419999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24090</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81427000</pkc:Start>
			<pkc:End>81446999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24214</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>221999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24225</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>134999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24227</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>88000000</pkc:Start>
			<pkc:End>88499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24228</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>88500000</pkc:Start>
			<pkc:End>88999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24714</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>360500000</pkc:Start>
			<pkc:End>361999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24717</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>864000000</pkc:Start>
			<pkc:End>938999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56df4151-1f9f-41bf-acaa-2941c071872b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23858</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>358999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56df4151-1f9f-41bf-acaa-2941c071872b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24230</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>85320000</pkc:Start>
			<pkc:End>85439999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5762371d-a6fe-4fea-af1b-b9f0367d8e46}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22117</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>29002499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5762371d-a6fe-4fea-af1b-b9f0367d8e46}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22118:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29002500</pkc:Start>
			<pkc:End>29004999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19709</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000005</pkc:Start>
			<pkc:End>29999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19710:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>30000000</pkc:Start>
			<pkc:End>30999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19711</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87000007</pkc:Start>
			<pkc:End>87099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19712:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87100000</pkc:Start>
			<pkc:End>87199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19717</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>79000005</pkc:Start>
			<pkc:End>79499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19718:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>79500000</pkc:Start>
			<pkc:End>79999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{65ab7338-9ad0-43fe-af1b-190b577495e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19713</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>80000000</pkc:Start>
			<pkc:End>80499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{65ab7338-9ad0-43fe-af1b-190b577495e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19714:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>80500000</pkc:Start>
			<pkc:End>80999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{65ab7338-9ad0-43fe-af1b-190b577495e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19715</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87200000</pkc:Start>
			<pkc:End>87249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{65ab7338-9ad0-43fe-af1b-190b577495e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19716:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87250000</pkc:Start>
			<pkc:End>87299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{28169020-83db-42d0-87bb-7709454c5f62}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22078</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>37370000</pkc:Start>
			<pkc:End>38619999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{28169020-83db-42d0-87bb-7709454c5f62}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22079:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>38620000</pkc:Start>
			<pkc:End>39869999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{766d0cf7-accb-4fe9-b9a0-b4bfa8ae7550}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22125</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29020000</pkc:Start>
			<pkc:End>29022499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{766d0cf7-accb-4fe9-b9a0-b4bfa8ae7550}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22126:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29022500</pkc:Start>
			<pkc:End>29024999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a6ad72e3-67a6-4d46-af1c-5f542c22ef7c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22082</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>35570000</pkc:Start>
			<pkc:End>36469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a6ad72e3-67a6-4d46-af1c-5f542c22ef7c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22083:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>36470000</pkc:Start>
			<pkc:End>37369999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22107</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>43070000</pkc:Start>
			<pkc:End>44769999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22108</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>73470000</pkc:Start>
			<pkc:End>80469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22109:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>44770000</pkc:Start>
			<pkc:End>46469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22110:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>80470000</pkc:Start>
			<pkc:End>87469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8210c9d1-4686-4f46-ac2e-56cf4e6ba674}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22115</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>31820000</pkc:Start>
			<pkc:End>32269999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8210c9d1-4686-4f46-ac2e-56cf4e6ba674}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22116:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>32270000</pkc:Start>
			<pkc:End>32719999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{866e924e-c2a3-4872-aca1-6b48c13962d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23949</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>86300000</pkc:Start>
			<pkc:End>86449999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{866e924e-c2a3-4872-aca1-6b48c13962d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23950:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87300000</pkc:Start>
			<pkc:End>87449999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{94dd1d84-9d70-45ff-ae30-6c1643e583ac}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22121</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29010000</pkc:Start>
			<pkc:End>29012499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{94dd1d84-9d70-45ff-ae30-6c1643e583ac}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22122:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29012500</pkc:Start>
			<pkc:End>29014999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a6ad72e3-67a6-4d46-af1c-5f542c22ef7c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22103</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29720000</pkc:Start>
			<pkc:End>29919999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a6ad72e3-67a6-4d46-af1c-5f542c22ef7c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22104:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29920000</pkc:Start>
			<pkc:End>30119999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a77a6806-f59e-4953-97d7-229317b8e6a6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19723</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81100000</pkc:Start>
			<pkc:End>81199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a77a6806-f59e-4953-97d7-229317b8e6a6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19725:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>85100000</pkc:Start>
			<pkc:End>85199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a77a6806-f59e-4953-97d7-229317b8e6a6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19726</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81000000</pkc:Start>
			<pkc:End>81099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a77a6806-f59e-4953-97d7-229317b8e6a6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19727:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>85000000</pkc:Start>
			<pkc:End>85099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22088</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87470000</pkc:Start>
			<pkc:End>101469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22089:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>46470000</pkc:Start>
			<pkc:End>49969999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22090:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>125999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22091</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>49970000</pkc:Start>
			<pkc:End>53469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bab219ac-3f91-4cdc-8339-b643cbdd6c49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22135</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29045000</pkc:Start>
			<pkc:End>29047499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bab219ac-3f91-4cdc-8339-b643cbdd6c49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22136:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29047500</pkc:Start>
			<pkc:End>29049999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23861</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81205000</pkc:Start>
			<pkc:End>81209999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23864</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>90000000</pkc:Start>
			<pkc:End>90999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23867</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>91000000</pkc:Start>
			<pkc:End>91999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23869</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>92000000</pkc:Start>
			<pkc:End>92999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23872</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>93000000</pkc:Start>
			<pkc:End>93999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23875</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>94000000</pkc:Start>
			<pkc:End>94999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23878</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>95000000</pkc:Start>
			<pkc:End>95999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23881</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>89000000</pkc:Start>
			<pkc:End>89999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23884</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>108000000</pkc:Start>
			<pkc:End>109499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23887</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>98500000</pkc:Start>
			<pkc:End>100999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23890</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>394500000</pkc:Start>
			<pkc:End>395999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23893</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>105000000</pkc:Start>
			<pkc:End>106499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23896</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>186000000</pkc:Start>
			<pkc:End>190999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23899</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>83420000</pkc:Start>
			<pkc:End>83539999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23902</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>83780000</pkc:Start>
			<pkc:End>83899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24207</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>85200000</pkc:Start>
			<pkc:End>85319999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24210</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>222000000</pkc:Start>
			<pkc:End>244999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24224</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>135000000</pkc:Start>
			<pkc:End>157999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24716</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>363500000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24720</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>774999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e063f49-6ce7-4099-be9e-8b1c3590f5c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22092</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>39870000</pkc:Start>
			<pkc:End>41469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e063f49-6ce7-4099-be9e-8b1c3590f5c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22093</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>60470000</pkc:Start>
			<pkc:End>66969999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e063f49-6ce7-4099-be9e-8b1c3590f5c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22094:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>41470000</pkc:Start>
			<pkc:End>43069999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e063f49-6ce7-4099-be9e-8b1c3590f5c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22095:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>66970000</pkc:Start>
			<pkc:End>73469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c448fa06-49d1-44ec-82bb-0085545c3b51}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23859</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>380999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c448fa06-49d1-44ec-82bb-0085545c3b51}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24229</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>84420000</pkc:Start>
			<pkc:End>84539999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c90d1b4e-8aa8-439e-8b9e-b6d6b6a6d975}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23857</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>381000000</pkc:Start>
			<pkc:End>392999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c90d1b4e-8aa8-439e-8b9e-b6d6b6a6d975}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24231</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>85440000</pkc:Start>
			<pkc:End>85559999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d020c729-07f0-4f8f-87ce-bf803275c786}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22099</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29150000</pkc:Start>
			<pkc:End>29209999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d020c729-07f0-4f8f-87ce-bf803275c786}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22100:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29210000</pkc:Start>
			<pkc:End>29269999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d063c01b-b1c3-442c-8cc4-4be55a1a01df}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22123</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29015000</pkc:Start>
			<pkc:End>29017499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d063c01b-b1c3-442c-8cc4-4be55a1a01df}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22124:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29017500</pkc:Start>
			<pkc:End>29019999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d020c729-07f0-4f8f-87ce-bf803275c786}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22080</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>32720000</pkc:Start>
			<pkc:End>33294999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d020c729-07f0-4f8f-87ce-bf803275c786}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22081:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>33295000</pkc:Start>
			<pkc:End>33869999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23860</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81200000</pkc:Start>
			<pkc:End>81204999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23863</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81215000</pkc:Start>
			<pkc:End>81227999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23866</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81293000</pkc:Start>
			<pkc:End>81306999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23868</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81228000</pkc:Start>
			<pkc:End>81240999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23871</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81241000</pkc:Start>
			<pkc:End>81253999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23874</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81254000</pkc:Start>
			<pkc:End>81266999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23877</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81267000</pkc:Start>
			<pkc:End>81279999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23880</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81280000</pkc:Start>
			<pkc:End>81292999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23883</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>106500000</pkc:Start>
			<pkc:End>107999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23886</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>96000000</pkc:Start>
			<pkc:End>98499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23889</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>393000000</pkc:Start>
			<pkc:End>394499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23892</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>397500000</pkc:Start>
			<pkc:End>398999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23895</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>191000000</pkc:Start>
			<pkc:End>195999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23898</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>83300000</pkc:Start>
			<pkc:End>83419999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23901</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>83660000</pkc:Start>
			<pkc:End>83779999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24209</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>245000000</pkc:Start>
			<pkc:End>267999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24223</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>158000000</pkc:Start>
			<pkc:End>180999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24715</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>362000000</pkc:Start>
			<pkc:End>363499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24719</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>863999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f209258f-33ca-4a14-a45c-5cafa7259ab5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22119</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29005000</pkc:Start>
			<pkc:End>29007499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f209258f-33ca-4a14-a45c-5cafa7259ab5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22120:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29007500</pkc:Start>
			<pkc:End>29009999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7afb1156-2c1d-40fc-b260-aab7442b62fe}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-31015</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>82250000</pkc:Start>
			<pkc:End>82250010</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ad2542d4-9154-4c6d-8a44-30f11ee96989}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-31016</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>82250011</pkc:Start>
			<pkc:End>82250021</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8198490a-add0-47b2-b3ba-316b12d647b4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-31017</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>82250022</pkc:Start>
			<pkc:End>82250032</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2401e3d0-c50a-4b58-87b2-7e794b7d2607}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-31018</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>82250033</pkc:Start>
			<pkc:End>82250043</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{68b6e220-cf09-466b-92d3-45cd964b9509}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-31019</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>82250044</pkc:Start>
			<pkc:End>82250054</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fd09ef77-5647-4eff-809c-af2b64659a45}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-31020</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>82250055</pkc:Start>
			<pkc:End>82250065</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01ef176b-3e0d-422a-b4f8-4ea880035e8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-31021</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>82250066</pkc:Start>
			<pkc:End>82250076</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ddfa9f7c-f09e-40b9-8c1a-be877a9a7f4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-31022</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>82250077</pkc:Start>
			<pkc:End>82250087</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1af4d90-d1bc-44ca-85d4-003ba33db3b9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-31031</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>82250088</pkc:Start>
			<pkc:End>82250098</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23980</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>498999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23980</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>549000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23980</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>887000000</pkc:Start>
			<pkc:End>908999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23985</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>341400000</pkc:Start>
			<pkc:End>342399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23986</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>343400000</pkc:Start>
			<pkc:End>344399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23987</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>841999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23988</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>201349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24000</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>349500000</pkc:Start>
			<pkc:End>350999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24001</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>363700000</pkc:Start>
			<pkc:End>368499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{12d7799d-9db2-4378-abb8-efaca84a6133}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-25575</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>364000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{12d7799d-9db2-4378-abb8-efaca84a6133}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-28745</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>336999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{132ccb0c-51e9-49c4-b157-ccf977259947}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-25403</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>211980000</pkc:Start>
			<pkc:End>212079999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23979</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937000000</pkc:Start>
			<pkc:End>973999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24005</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>346800000</pkc:Start>
			<pkc:End>347999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24005</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>613500000</pkc:Start>
			<pkc:End>616899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24007</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>499000000</pkc:Start>
			<pkc:End>548999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{faba8d9b-3ad6-4529-b11d-d41ec9b5d47b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-25399</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>200000000</pkc:Start>
			<pkc:End>205999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{faba8d9b-3ad6-4529-b11d-d41ec9b5d47b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-25401</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>206000000</pkc:Start>
			<pkc:End>206999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{faba8d9b-3ad6-4529-b11d-d41ec9b5d47b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-25402</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>211420000</pkc:Start>
			<pkc:End>211979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{faba8d9b-3ad6-4529-b11d-d41ec9b5d47b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27313</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>521000000</pkc:Start>
			<pkc:End>538499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{faba8d9b-3ad6-4529-b11d-d41ec9b5d47b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27314</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>280000000</pkc:Start>
			<pkc:End>288999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{faba8d9b-3ad6-4529-b11d-d41ec9b5d47b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27315</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>207100000</pkc:Start>
			<pkc:End>208249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0101b69a-85c8-4344-8196-7a16a7790bb5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23981</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>289000000</pkc:Start>
			<pkc:End>322999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0101b69a-85c8-4344-8196-7a16a7790bb5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23982</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>238080000</pkc:Start>
			<pkc:End>264079999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{776ec0e8-2a6f-4e55-94f2-b6b1fa9cf4c5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24002</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>749999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{776ec0e8-2a6f-4e55-94f2-b6b1fa9cf4c5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24004</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>600999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-78544</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>470600000</pkc:Start>
			<pkc:End>470999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-78544</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>499702000</pkc:Start>
			<pkc:End>501201999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22760</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495060000</pkc:Start>
			<pkc:End>495559999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22760</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>571835000</pkc:Start>
			<pkc:End>571954999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22761</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>487720000</pkc:Start>
			<pkc:End>488419999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22761</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>571955000</pkc:Start>
			<pkc:End>572254999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22762</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>492270000</pkc:Start>
			<pkc:End>493769999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22763</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>491920000</pkc:Start>
			<pkc:End>492119999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22763</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>572255000</pkc:Start>
			<pkc:End>572294999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22764</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>493770000</pkc:Start>
			<pkc:End>493869999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22764</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>572295000</pkc:Start>
			<pkc:End>572329999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22765</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>492220000</pkc:Start>
			<pkc:End>492269999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22765</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503000000</pkc:Start>
			<pkc:End>503049999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22765</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>572330000</pkc:Start>
			<pkc:End>572364999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22766</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>493870000</pkc:Start>
			<pkc:End>493909999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22766</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551740000</pkc:Start>
			<pkc:End>551799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22766</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>572365000</pkc:Start>
			<pkc:End>572399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22767</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>492120000</pkc:Start>
			<pkc:End>492219999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22767</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>572400000</pkc:Start>
			<pkc:End>572434999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23181</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474858000</pkc:Start>
			<pkc:End>475607999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23181</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>573185000</pkc:Start>
			<pkc:End>573434999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23182</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>475608000</pkc:Start>
			<pkc:End>475807999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23183</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>475808000</pkc:Start>
			<pkc:End>476007999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23571</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495828000</pkc:Start>
			<pkc:End>495837999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23571</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503750000</pkc:Start>
			<pkc:End>503799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23573</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495924000</pkc:Start>
			<pkc:End>495943999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23573</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503800000</pkc:Start>
			<pkc:End>503849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23574</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495659000</pkc:Start>
			<pkc:End>495664999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23574</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503850000</pkc:Start>
			<pkc:End>503899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23575</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495665000</pkc:Start>
			<pkc:End>495670999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23575</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503900000</pkc:Start>
			<pkc:End>503949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23586</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495810000</pkc:Start>
			<pkc:End>495818999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23586</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504200000</pkc:Start>
			<pkc:End>504249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23587</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495695000</pkc:Start>
			<pkc:End>495700999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23587</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504250000</pkc:Start>
			<pkc:End>504299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23588</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495701000</pkc:Start>
			<pkc:End>495706999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23588</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504300000</pkc:Start>
			<pkc:End>504349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23589</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495707000</pkc:Start>
			<pkc:End>495712999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23589</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504350000</pkc:Start>
			<pkc:End>504399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23598</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495858000</pkc:Start>
			<pkc:End>495869999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23598</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>502750000</pkc:Start>
			<pkc:End>502779999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23599</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495725000</pkc:Start>
			<pkc:End>495730999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23599</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504550000</pkc:Start>
			<pkc:End>504599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23600</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495731000</pkc:Start>
			<pkc:End>495736999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23600</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552450000</pkc:Start>
			<pkc:End>552499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23601</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495737000</pkc:Start>
			<pkc:End>495742999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23601</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552400000</pkc:Start>
			<pkc:End>552449999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23602</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495564000</pkc:Start>
			<pkc:End>495564999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23602</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552350000</pkc:Start>
			<pkc:End>552399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23604</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496492000</pkc:Start>
			<pkc:End>496701999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23604</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>573909500</pkc:Start>
			<pkc:End>573949499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23605</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495819000</pkc:Start>
			<pkc:End>495827999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23605</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552300000</pkc:Start>
			<pkc:End>552349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23606</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495743000</pkc:Start>
			<pkc:End>495748999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23606</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552250000</pkc:Start>
			<pkc:End>552299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23607</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495749000</pkc:Start>
			<pkc:End>495754999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23607</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552200000</pkc:Start>
			<pkc:End>552249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23608</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495584000</pkc:Start>
			<pkc:End>495586999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23608</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552150000</pkc:Start>
			<pkc:End>552199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23610</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495576000</pkc:Start>
			<pkc:End>495578499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23610</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552100000</pkc:Start>
			<pkc:End>552149999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23611</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495755000</pkc:Start>
			<pkc:End>495760999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23611</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552050000</pkc:Start>
			<pkc:End>552099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23612</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495761000</pkc:Start>
			<pkc:End>495766999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23612</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552000000</pkc:Start>
			<pkc:End>552049999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23613</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495767000</pkc:Start>
			<pkc:End>495772999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23613</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551950000</pkc:Start>
			<pkc:End>551999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23614</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495565000</pkc:Start>
			<pkc:End>495565999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23614</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551900000</pkc:Start>
			<pkc:End>551949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24834</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496122000</pkc:Start>
			<pkc:End>496161999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24834</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>529000000</pkc:Start>
			<pkc:End>532999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24836</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495944000</pkc:Start>
			<pkc:End>495963999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24836</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>537000000</pkc:Start>
			<pkc:End>538999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24837</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495587000</pkc:Start>
			<pkc:End>495589999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24837</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>551499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24838</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495590000</pkc:Start>
			<pkc:End>495592999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24838</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>549500000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27362</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>852999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27657</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>682000000</pkc:Start>
			<pkc:End>694499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27658</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>642999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27660</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>643000000</pkc:Start>
			<pkc:End>648999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4871de8b-3adf-4455-a7d3-fd7b6c01c939}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-28742</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>394000000</pkc:Start>
			<pkc:End>416999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{413036e1-7bcf-4a02-bab4-7b6916f17f87}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27342</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>211150000</pkc:Start>
			<pkc:End>211284999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23947</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>663999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23948</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>336399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23948</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>411350000</pkc:Start>
			<pkc:End>412571999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23953</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>345600000</pkc:Start>
			<pkc:End>346799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23953</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>640100000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23953</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>951600000</pkc:Start>
			<pkc:End>965399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23954</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>339199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23954</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-25573</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>308000000</pkc:Start>
			<pkc:End>329999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-25574</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>601000000</pkc:Start>
			<pkc:End>613499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27347</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>204900000</pkc:Start>
			<pkc:End>206049999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27348</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>206200000</pkc:Start>
			<pkc:End>212199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-68826</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10996000</pkc:Start>
			<pkc:End>10999699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-68826</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>568137000</pkc:Start>
			<pkc:End>568736999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-68826</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302560000</pkc:Start>
			<pkc:End>302630999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23456</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>480569000</pkc:Start>
			<pkc:End>480572499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23456</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503050000</pkc:Start>
			<pkc:End>503099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23457</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>478032000</pkc:Start>
			<pkc:End>478033999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23457</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503100000</pkc:Start>
			<pkc:End>503149999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{55e6dada-345d-41ab-83f0-99ad84ac1d19}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24003</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>177000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{55e6dada-345d-41ab-83f0-99ad84ac1d19}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24003</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>323000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{55e6dada-345d-41ab-83f0-99ad84ac1d19}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24003</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>899000000</pkc:Start>
			<pkc:End>979999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d6a70f3f-2052-4633-a9aa-25ea0cdff672}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23990</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d6a70f3f-2052-4633-a9aa-25ea0cdff672}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23990</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d6a70f3f-2052-4633-a9aa-25ea0cdff672}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23990</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d6a70f3f-2052-4633-a9aa-25ea0cdff672}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23990</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>665999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d6a70f3f-2052-4633-a9aa-25ea0cdff672}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23990</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>699999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3a1d44e2-bede-46fb-8a02-0cd485a1db8b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-28741</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>209500000</pkc:Start>
			<pkc:End>209599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3a1d44e2-bede-46fb-8a02-0cd485a1db8b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-28831</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>209800000</pkc:Start>
			<pkc:End>209899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3a1d44e2-bede-46fb-8a02-0cd485a1db8b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-28832</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>209900000</pkc:Start>
			<pkc:End>209999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b4b150d0-ec09-4f74-910d-371ed161b2ac}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23959</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b4b150d0-ec09-4f74-910d-371ed161b2ac}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23959</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b4b150d0-ec09-4f74-910d-371ed161b2ac}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23959</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b4b150d0-ec09-4f74-910d-371ed161b2ac}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23959</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>665999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b4b150d0-ec09-4f74-910d-371ed161b2ac}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23959</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>950999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20902</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495599000</pkc:Start>
			<pkc:End>495604999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20902</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>539000000</pkc:Start>
			<pkc:End>540999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22741</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>487610000</pkc:Start>
			<pkc:End>487629999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22741</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>533000000</pkc:Start>
			<pkc:End>536999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23172</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>482967000</pkc:Start>
			<pkc:End>482980999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23172</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551620000</pkc:Start>
			<pkc:End>551739999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24829</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495568000</pkc:Start>
			<pkc:End>495568999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24829</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>549300000</pkc:Start>
			<pkc:End>549399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27358</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>560100000</pkc:Start>
			<pkc:End>564099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92d8977c-d506-4e63-b500-6d39283b6cd5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27359</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>564100000</pkc:Start>
			<pkc:End>568099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23965</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>383800000</pkc:Start>
			<pkc:End>394099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23965</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>410000000</pkc:Start>
			<pkc:End>411199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23966</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>394100000</pkc:Start>
			<pkc:End>406599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23966</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>409500000</pkc:Start>
			<pkc:End>409999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23966</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>414072000</pkc:Start>
			<pkc:End>414421999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23967</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>351000000</pkc:Start>
			<pkc:End>352799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23967</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>409300000</pkc:Start>
			<pkc:End>409499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23967</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>414422000</pkc:Start>
			<pkc:End>414621999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23968</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>348000000</pkc:Start>
			<pkc:End>349499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23975</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>342400000</pkc:Start>
			<pkc:End>343399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23976</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339200000</pkc:Start>
			<pkc:End>339849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23977</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>307999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23978</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>356000000</pkc:Start>
			<pkc:End>359099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d4f54950-26f2-4fb4-ba21-ffab16afcade}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-32498</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>430979800</pkc:Start>
			<pkc:End>430979809</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d4f54950-26f2-4fb4-ba21-ffab16afcade}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-32499</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>430979810</pkc:Start>
			<pkc:End>430979819</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20901</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495593000</pkc:Start>
			<pkc:End>495598999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20901</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>548700000</pkc:Start>
			<pkc:End>549299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22768</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>482952000</pkc:Start>
			<pkc:End>482957999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22768</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>544500000</pkc:Start>
			<pkc:End>545699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23184</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>476008000</pkc:Start>
			<pkc:End>476021999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23184</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551500000</pkc:Start>
			<pkc:End>551619999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24839</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495571000</pkc:Start>
			<pkc:End>495571999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24839</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>502900000</pkc:Start>
			<pkc:End>502949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27360</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>559100000</pkc:Start>
			<pkc:End>560099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27361</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>308550000</pkc:Start>
			<pkc:End>308599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27363</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>670899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1f59edc8-ad79-4d96-a62d-c33ee78da2ec}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27539</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>208250000</pkc:Start>
			<pkc:End>209399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1f59edc8-ad79-4d96-a62d-c33ee78da2ec}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27540</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>279999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1f59edc8-ad79-4d96-a62d-c33ee78da2ec}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27541</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>450500000</pkc:Start>
			<pkc:End>460999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f00fa8e9-ac0f-4f43-a259-a26c110cbbf9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27355</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>764999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f00fa8e9-ac0f-4f43-a259-a26c110cbbf9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-29459</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496000000</pkc:Start>
			<pkc:End>508499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f00fa8e9-ac0f-4f43-a259-a26c110cbbf9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-29460</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>393999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24d57dfd-f6e1-48f9-a045-0520a52f84c7}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23951</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>362999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24d57dfd-f6e1-48f9-a045-0520a52f84c7}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23952</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>461000000</pkc:Start>
			<pkc:End>466999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24d57dfd-f6e1-48f9-a045-0520a52f84c7}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27349</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>508500000</pkc:Start>
			<pkc:End>520999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2bd10086-9094-4140-801e-3d8ec5b0ac25}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24006</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>898999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56a13760-2b9c-406f-be8a-8f2ef22f10b5}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27652</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>210000000</pkc:Start>
			<pkc:End>210999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{70453a75-42cb-49ba-83d8-d9dc6295901b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27189</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>671000000</pkc:Start>
			<pkc:End>681999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{70453a75-42cb-49ba-83d8-d9dc6295901b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27192</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>553500000</pkc:Start>
			<pkc:End>558099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{70453a75-42cb-49ba-83d8-d9dc6295901b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27199</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>552500000</pkc:Start>
			<pkc:End>553499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{70453a75-42cb-49ba-83d8-d9dc6295901b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27202</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>558100000</pkc:Start>
			<pkc:End>559099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1105ac4c-f808-42d2-a6ae-f46183169f6f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27654</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>209400000</pkc:Start>
			<pkc:End>209499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1105ac4c-f808-42d2-a6ae-f46183169f6f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-28828</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>209600000</pkc:Start>
			<pkc:End>209699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1105ac4c-f808-42d2-a6ae-f46183169f6f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-28829</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>209700000</pkc:Start>
			<pkc:End>209799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7fbe00d4-bff2-47a3-99a7-6387fd509ae2}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27343</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>211285000</pkc:Start>
			<pkc:End>211419999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{829a4bc1-2a89-47ba-a638-0b8a206b0986}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-25400</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>201400000</pkc:Start>
			<pkc:End>204699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cd2e414a-e728-421e-a934-73506387d641}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23957</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>830999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c2f2d79e-121d-482c-b665-83f052c8cbcc}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23958</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>495999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c2f2d79e-121d-482c-b665-83f052c8cbcc}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23960</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>615999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23955</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>406600000</pkc:Start>
			<pkc:End>408999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23955</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926000000</pkc:Start>
			<pkc:End>943599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23956</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>447009999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23956</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>909350000</pkc:Start>
			<pkc:End>925999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23961</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368500000</pkc:Start>
			<pkc:End>375699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23962</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339850000</pkc:Start>
			<pkc:End>340699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23962</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>411200000</pkc:Start>
			<pkc:End>411349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23963</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>842000000</pkc:Start>
			<pkc:End>886999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23964</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>375700000</pkc:Start>
			<pkc:End>383799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23998</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>340700000</pkc:Start>
			<pkc:End>341399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23998</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>409000000</pkc:Start>
			<pkc:End>409299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23999</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>359100000</pkc:Start>
			<pkc:End>363699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b13b0123-8661-4ee2-afb7-05c37481686b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23983</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b13b0123-8661-4ee2-afb7-05c37481686b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23983</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b13b0123-8661-4ee2-afb7-05c37481686b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23983</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b13b0123-8661-4ee2-afb7-05c37481686b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23983</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>665999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b13b0123-8661-4ee2-afb7-05c37481686b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23983</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>675000000</pkc:Start>
			<pkc:End>950999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23989</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>344400000</pkc:Start>
			<pkc:End>345599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23991</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>352800000</pkc:Start>
			<pkc:End>355999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23991</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>750000000</pkc:Start>
			<pkc:End>783799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27142</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>204700000</pkc:Start>
			<pkc:End>204799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27143</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>204800000</pkc:Start>
			<pkc:End>204899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27353</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>206050000</pkc:Start>
			<pkc:End>206199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27354</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>212200000</pkc:Start>
			<pkc:End>215199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-29461</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>215200000</pkc:Start>
			<pkc:End>215849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-29462</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426000000</pkc:Start>
			<pkc:End>426999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8f1c2cd6-4d70-4122-8eee-b4de3fb9ba17}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-29267</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>211100000</pkc:Start>
			<pkc:End>211149999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90f4e13a-12fb-4840-b9ab-91cfb9fac5e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27659</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>363000000</pkc:Start>
			<pkc:End>363999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a797d61e-1475-470b-86c8-f737a72c188d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27215</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>207000000</pkc:Start>
			<pkc:End>207099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a797d61e-1475-470b-86c8-f737a72c188d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-28830</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>211000000</pkc:Start>
			<pkc:End>211049999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3a1d44e2-bede-46fb-8a02-0cd485a1db8b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-28833</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>211050000</pkc:Start>
			<pkc:End>211099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-78545</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>471000000</pkc:Start>
			<pkc:End>471199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-78545</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>501202000</pkc:Start>
			<pkc:End>502701999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22714</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>482320500</pkc:Start>
			<pkc:End>482820499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22714</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>568850000</pkc:Start>
			<pkc:End>568959999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22715</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>480582500</pkc:Start>
			<pkc:End>481082499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22715</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>568960000</pkc:Start>
			<pkc:End>569109999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22717</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>481320500</pkc:Start>
			<pkc:End>482320499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22717</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>569110000</pkc:Start>
			<pkc:End>569259999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22718</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>481082500</pkc:Start>
			<pkc:End>481232499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22719</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>482820500</pkc:Start>
			<pkc:End>482845499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22719</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504600000</pkc:Start>
			<pkc:End>504699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22720</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>481302500</pkc:Start>
			<pkc:End>481309499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22720</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504700000</pkc:Start>
			<pkc:End>504849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22721</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>482845500</pkc:Start>
			<pkc:End>482859499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22721</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504850000</pkc:Start>
			<pkc:End>504999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22722</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>481232500</pkc:Start>
			<pkc:End>481302499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22722</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>569260000</pkc:Start>
			<pkc:End>569324999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23162</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>473879000</pkc:Start>
			<pkc:End>474628999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23162</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>572435000</pkc:Start>
			<pkc:End>572684999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23163</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>472379000</pkc:Start>
			<pkc:End>473878999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23164</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474629000</pkc:Start>
			<pkc:End>474828999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23549</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495785000</pkc:Start>
			<pkc:End>495792999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23549</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503150000</pkc:Start>
			<pkc:End>503199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23550</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495895000</pkc:Start>
			<pkc:End>495908999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23550</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>502860000</pkc:Start>
			<pkc:End>502899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23551</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495605000</pkc:Start>
			<pkc:End>495610999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23551</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503200000</pkc:Start>
			<pkc:End>503249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23552</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495611000</pkc:Start>
			<pkc:End>495616999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23552</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503250000</pkc:Start>
			<pkc:End>503299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23553</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495793000</pkc:Start>
			<pkc:End>495800999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23553</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503300000</pkc:Start>
			<pkc:End>503349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23554</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495617000</pkc:Start>
			<pkc:End>495622999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23554</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503350000</pkc:Start>
			<pkc:End>503399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23555</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495623000</pkc:Start>
			<pkc:End>495628999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23555</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503400000</pkc:Start>
			<pkc:End>503449999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23556</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495629000</pkc:Start>
			<pkc:End>495634999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23556</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503450000</pkc:Start>
			<pkc:End>503499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24813</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496352000</pkc:Start>
			<pkc:End>496491999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24813</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>505000000</pkc:Start>
			<pkc:End>515999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24814</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496207000</pkc:Start>
			<pkc:End>496276999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24814</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>523000000</pkc:Start>
			<pkc:End>528999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24817</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495870000</pkc:Start>
			<pkc:End>495882499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24817</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>546600000</pkc:Start>
			<pkc:End>547499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24817</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>568800000</pkc:Start>
			<pkc:End>568849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24821</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495882500</pkc:Start>
			<pkc:End>495894999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24821</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>545700000</pkc:Start>
			<pkc:End>546599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24821</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>568100000</pkc:Start>
			<pkc:End>568136999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24821</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>568737000</pkc:Start>
			<pkc:End>568799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24822</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495574000</pkc:Start>
			<pkc:End>495575999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24822</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>549400000</pkc:Start>
			<pkc:End>549499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-78542</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>470000000</pkc:Start>
			<pkc:End>470399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-78542</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496702000</pkc:Start>
			<pkc:End>498201999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22746</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>479034000</pkc:Start>
			<pkc:End>479733999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22746</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>570445000</pkc:Start>
			<pkc:End>570744999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22747</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>476037000</pkc:Start>
			<pkc:End>476736999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22747</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>570745000</pkc:Start>
			<pkc:End>571044999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22748</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>478034000</pkc:Start>
			<pkc:End>479033999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22748</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>571045000</pkc:Start>
			<pkc:End>571244999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22749</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>476737000</pkc:Start>
			<pkc:End>477336999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22749</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>571245000</pkc:Start>
			<pkc:End>571644999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22750</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>480514000</pkc:Start>
			<pkc:End>480563999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22750</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>502950000</pkc:Start>
			<pkc:End>502999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22750</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>571645000</pkc:Start>
			<pkc:End>571679999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22751</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477987000</pkc:Start>
			<pkc:End>478016999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22751</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551800000</pkc:Start>
			<pkc:End>551899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22752</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>480434000</pkc:Start>
			<pkc:End>480513999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22752</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>571680000</pkc:Start>
			<pkc:End>571734999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22753</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477337000</pkc:Start>
			<pkc:End>477736999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22753</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>571735000</pkc:Start>
			<pkc:End>571834999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23175</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>471200000</pkc:Start>
			<pkc:End>471949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23175</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>572935000</pkc:Start>
			<pkc:End>573184999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23176</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>471950000</pkc:Start>
			<pkc:End>472149999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23177</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>472150000</pkc:Start>
			<pkc:End>472349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23454</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>479734000</pkc:Start>
			<pkc:End>480433999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23454</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>573435000</pkc:Start>
			<pkc:End>573734999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23455</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477737000</pkc:Start>
			<pkc:End>477986999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23455</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>573735000</pkc:Start>
			<pkc:End>573804999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23565</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302510000</pkc:Start>
			<pkc:End>302559999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23565</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>573865000</pkc:Start>
			<pkc:End>573909499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23566</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>308500000</pkc:Start>
			<pkc:End>308549999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23567</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495578500</pkc:Start>
			<pkc:End>495583999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23567</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503600000</pkc:Start>
			<pkc:End>503649999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23568</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495653000</pkc:Start>
			<pkc:End>495658999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23568</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503650000</pkc:Start>
			<pkc:End>503699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23570</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495909000</pkc:Start>
			<pkc:End>495923999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23570</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503700000</pkc:Start>
			<pkc:End>503749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23580</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495838000</pkc:Start>
			<pkc:End>495847999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23580</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>502780000</pkc:Start>
			<pkc:End>502819999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23582</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495683000</pkc:Start>
			<pkc:End>495688999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23582</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504050000</pkc:Start>
			<pkc:End>504099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23583</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495689000</pkc:Start>
			<pkc:End>495694999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23583</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504100000</pkc:Start>
			<pkc:End>504149999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-78543</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>470400000</pkc:Start>
			<pkc:End>470599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-78543</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>498202000</pkc:Start>
			<pkc:End>499701999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22732</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>485000000</pkc:Start>
			<pkc:End>486999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22734</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>483000000</pkc:Start>
			<pkc:End>484999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22734</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>569325000</pkc:Start>
			<pkc:End>569674999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22735</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>488420000</pkc:Start>
			<pkc:End>491919999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22735</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>569675000</pkc:Start>
			<pkc:End>570174999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22736</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>487000000</pkc:Start>
			<pkc:End>487349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22736</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>570175000</pkc:Start>
			<pkc:End>570264999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22737</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>487650000</pkc:Start>
			<pkc:End>487719999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22737</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>570265000</pkc:Start>
			<pkc:End>570329999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22738</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>487530000</pkc:Start>
			<pkc:End>487609999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22738</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>570330000</pkc:Start>
			<pkc:End>570384999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22739</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>482870500</pkc:Start>
			<pkc:End>482945499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22739</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>570385000</pkc:Start>
			<pkc:End>570444999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22740</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>487350000</pkc:Start>
			<pkc:End>487529999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23169</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>493910000</pkc:Start>
			<pkc:End>494659999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23169</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>572685000</pkc:Start>
			<pkc:End>572934999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23170</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>494660000</pkc:Start>
			<pkc:End>494859999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23171</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>494860000</pkc:Start>
			<pkc:End>495059999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23561</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495964000</pkc:Start>
			<pkc:End>495990999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23561</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>573805000</pkc:Start>
			<pkc:End>573827999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23562</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496162000</pkc:Start>
			<pkc:End>496206999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23562</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>502702000</pkc:Start>
			<pkc:End>502719999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23562</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>573828000</pkc:Start>
			<pkc:End>573864999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23563</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495641000</pkc:Start>
			<pkc:End>495646999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23563</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503500000</pkc:Start>
			<pkc:End>503549999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23564</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495647000</pkc:Start>
			<pkc:End>495652999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23564</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503550000</pkc:Start>
			<pkc:End>503599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23576</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495991000</pkc:Start>
			<pkc:End>496018999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23576</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236022071</pkc:Start>
			<pkc:End>236044070</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23577</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495671000</pkc:Start>
			<pkc:End>495676999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23577</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>503950000</pkc:Start>
			<pkc:End>503999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23578</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495677000</pkc:Start>
			<pkc:End>495682999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23578</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504000000</pkc:Start>
			<pkc:End>504049999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23579</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496019000</pkc:Start>
			<pkc:End>496046999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23592</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496082000</pkc:Start>
			<pkc:End>496121999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23592</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>502720000</pkc:Start>
			<pkc:End>502749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23593</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495848000</pkc:Start>
			<pkc:End>495857999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23593</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>502820000</pkc:Start>
			<pkc:End>502859999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23594</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495713000</pkc:Start>
			<pkc:End>495718999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23594</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504400000</pkc:Start>
			<pkc:End>504449999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23595</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495719000</pkc:Start>
			<pkc:End>495724999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23595</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504450000</pkc:Start>
			<pkc:End>504499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23596</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495563000</pkc:Start>
			<pkc:End>495563999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23596</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>504500000</pkc:Start>
			<pkc:End>504549999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24825</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496277000</pkc:Start>
			<pkc:End>496351999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24825</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>516000000</pkc:Start>
			<pkc:End>522999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24826</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>496047000</pkc:Start>
			<pkc:End>496081999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24826</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>541000000</pkc:Start>
			<pkc:End>544499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24827</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495773000</pkc:Start>
			<pkc:End>495778999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24827</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>548100000</pkc:Start>
			<pkc:End>548699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24828</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>495779000</pkc:Start>
			<pkc:End>495784999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24828</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>547500000</pkc:Start>
			<pkc:End>548099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a3481201-436e-4fc9-88b4-34ccf7f81789}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23970</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>212080000</pkc:Start>
			<pkc:End>238079999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a3481201-436e-4fc9-88b4-34ccf7f81789}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23972</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>450499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a3481201-436e-4fc9-88b4-34ccf7f81789}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23974</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>176999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c3505bd0-004a-49b9-84db-a1a4869eddf1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23973</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>99000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c3505bd0-004a-49b9-84db-a1a4869eddf1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23973</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c3505bd0-004a-49b9-84db-a1a4869eddf1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23973</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c3505bd0-004a-49b9-84db-a1a4869eddf1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23973</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>665999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c3505bd0-004a-49b9-84db-a1a4869eddf1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23973</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>759999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{199086aa-6cb8-4e5b-b698-f2be56f1e8ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90519</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>225000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{199086aa-6cb8-4e5b-b698-f2be56f1e8ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90519</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>320999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bffdc375-bbd5-499d-8ef1-4f37b61c895f}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90550</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>322100400</pkc:Start>
			<pkc:End>322110399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1f59edc8-ad79-4d96-a62d-c33ee78da2ec}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27541</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>616000000</pkc:Start>
			<pkc:End>622999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22684</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426337000</pkc:Start>
			<pkc:End>426416999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4871de8b-3adf-4455-a7d3-fd7b6c01c939}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-25290</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>199999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23962</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>412572000</pkc:Start>
			<pkc:End>412721999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23965</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>412722000</pkc:Start>
			<pkc:End>413921999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90552</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>323000000</pkc:Start>
			<pkc:End>323999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-78750</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>427549000</pkc:Start>
			<pkc:End>427664999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-50091</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>427665000</pkc:Start>
			<pkc:End>427699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-49267</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>427700000</pkc:Start>
			<pkc:End>429699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-50638</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>429700000</pkc:Start>
			<pkc:End>430885799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-67732</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>430885800</pkc:Start>
			<pkc:End>430886999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-67730</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>430887000</pkc:Start>
			<pkc:End>430966999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-67731</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>430967000</pkc:Start>
			<pkc:End>430979799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-78776</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>466240000</pkc:Start>
			<pkc:End>466499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40018</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>466500000</pkc:Start>
			<pkc:End>466999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-72502</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426110000</pkc:Start>
			<pkc:End>426120999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-72508</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426121000</pkc:Start>
			<pkc:End>426140999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40012</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>430980000</pkc:Start>
			<pkc:End>430989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40013</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>430990000</pkc:Start>
			<pkc:End>430999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f758e09b-7c7c-492c-b78c-aba5bd4e3f5b}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90572</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>531000000</pkc:Start>
			<pkc:End>605949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04121</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>430979820</pkc:Start>
			<pkc:End>430979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95a6eef2-89d4-4759-b65b-0a0748994b82}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04475</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236020060</pkc:Start>
			<pkc:End>236020069</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-68085</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10999700</pkc:Start>
			<pkc:End>10999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-02177</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>311511000</pkc:Start>
			<pkc:End>311999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40006</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>418980000</pkc:Start>
			<pkc:End>418989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40007</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>418990000</pkc:Start>
			<pkc:End>418999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-61757</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>424000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-67852</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>434000000</pkc:Start>
			<pkc:End>434728999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-68087</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>434729000</pkc:Start>
			<pkc:End>434792999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-61758</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436000000</pkc:Start>
			<pkc:End>436999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40016</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437980000</pkc:Start>
			<pkc:End>437989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40010</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425980000</pkc:Start>
			<pkc:End>425989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95c6e80a-0ff8-4bd0-95f2-c4a39b79d09e}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-61756</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>417000000</pkc:Start>
			<pkc:End>417999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40011</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425990000</pkc:Start>
			<pkc:End>425999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40017</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437990000</pkc:Start>
			<pkc:End>437999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-68088</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>434793000</pkc:Start>
			<pkc:End>434999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-68086</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>435000000</pkc:Start>
			<pkc:End>435999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{12d7799d-9db2-4378-abb8-efaca84a6133}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-25575</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>765000000</pkc:Start>
			<pkc:End>784999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e12dd57d-07d5-4f64-9139-a92489a626b0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23984</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426000000</pkc:Start>
			<pkc:End>435999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23581</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>308600000</pkc:Start>
			<pkc:End>308699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{58c37517-42f8-4723-bb44-30b05791ff2a}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20900</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>308700000</pkc:Start>
			<pkc:End>308799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8df04457-07c8-4301-bce9-d61eb76cb2d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19717</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>79000000</pkc:Start>
			<pkc:End>79000000</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5bd23b19-aa71-4a5b-8b68-c8801c2baff6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19717</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>79000001</pkc:Start>
			<pkc:End>79000001</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b86c7736-91ff-4de9-bfa9-b32b8a09acac}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19717</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>79000002</pkc:Start>
			<pkc:End>79000002</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d3f5642f-081d-40b2-a4b9-efd3054d4584}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19717</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>79000003</pkc:Start>
			<pkc:End>79000003</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c6936a36-69f3-4994-9857-3069c7b9ec7a}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19717</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>79000004</pkc:Start>
			<pkc:End>79000004</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cc4c2cf8-ef29-4d8e-b168-2b65a3db3309}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19711</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87000000</pkc:Start>
			<pkc:End>87000000</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b3827b27-bd38-4284-98af-e4f4d1c051a0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19711</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87000001</pkc:Start>
			<pkc:End>87000001</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5dad0eff-3f6f-4310-8844-422f9dc7c84b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19711</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87000002</pkc:Start>
			<pkc:End>87000002</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2be204da-24a0-4943-b66c-81e8464acd7e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19711</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87000003</pkc:Start>
			<pkc:End>87000003</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{60207eba-8b4a-486c-a013-023b4b742c2f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19711</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87000004</pkc:Start>
			<pkc:End>87000004</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{368856e9-43f7-4601-8358-e561f36c7dd8}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19709</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>29000000</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4bf433fa-ab04-4c6c-b55b-00170e14b8cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19709</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000001</pkc:Start>
			<pkc:End>29000001</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{374a5900-7184-43cd-a96f-abfcc30a1b27}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27088</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>46500000</pkc:Start>
			<pkc:End>47749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7139ded4-7373-4651-b44b-9de7ea72ccd4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27089</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>38000000</pkc:Start>
			<pkc:End>39249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ce0df6b6-ff0f-463c-93ed-3cd71752a8ac}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27090</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>47750000</pkc:Start>
			<pkc:End>48999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0dddb5b3-94b1-4b69-a916-6c82ea5542c5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27091</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>39250000</pkc:Start>
			<pkc:End>40499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e87fd23-319d-4cd6-8aa2-c590b7b0a42c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27096</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>53500000</pkc:Start>
			<pkc:End>55749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3c73fddf-ec70-43b2-b642-abd2d575e102}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27097</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>49000000</pkc:Start>
			<pkc:End>51249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{527803e5-f705-433b-a7f1-10b647e5369a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27098</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>55750000</pkc:Start>
			<pkc:End>57999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{43329da1-7874-4e67-b612-3d59697b1677}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27099</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>51250000</pkc:Start>
			<pkc:End>53499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b2b347e5-e754-468d-afc1-7b2187288814}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27092</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20011000</pkc:Start>
			<pkc:End>20015999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f6c23d59-6d32-4b41-acad-b0fa170733cb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27093</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20001000</pkc:Start>
			<pkc:End>20005999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a499fe43-12de-4873-8971-1cff6173cdaa}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27094</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20016000</pkc:Start>
			<pkc:End>20020999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fdd923f8-4409-4a72-becd-d7e9aa59bca3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27095</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20006000</pkc:Start>
			<pkc:End>20010999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f6a8f9fe-e072-4cb4-9fe2-a8276a1f161a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27100</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>43500000</pkc:Start>
			<pkc:End>44999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5f4eb8c3-37e4-4a56-97c9-60ad9a03763d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27101</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>40500000</pkc:Start>
			<pkc:End>41999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{abb3e789-58ae-42ae-b308-bb2c831db127}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27102</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>45000000</pkc:Start>
			<pkc:End>46499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{416733c6-d43f-4ba1-b6e0-722aa4573cdf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-27103</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>42000000</pkc:Start>
			<pkc:End>43499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f92f836d-4d3e-4e90-a08f-2d612d65e716}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19709</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000002</pkc:Start>
			<pkc:End>29000002</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3059a9fd-b068-4f0d-acaf-66324dca67ac}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19709</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000003</pkc:Start>
			<pkc:End>29000003</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2cf1c8d6-ebe1-4ce9-83c6-c4877fae1355}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19709</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000004</pkc:Start>
			<pkc:End>29000004</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c9ad502b-ef48-41d1-a2a0-38a38e82fed0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19711</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87000005</pkc:Start>
			<pkc:End>87000005</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e9f548a-c8a9-44e6-a6c2-3f8d0a7a99dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19711</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87000006</pkc:Start>
			<pkc:End>87000006</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-60317</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>909000000</pkc:Start>
			<pkc:End>909349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27363</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>670905000</pkc:Start>
			<pkc:End>670999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1eefed20-8ac0-478c-8774-70cd44782ea1}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-65598</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>670900000</pkc:Start>
			<pkc:End>670904999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27362</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>853635000</pkc:Start>
			<pkc:End>853999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-65599</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>853250000</pkc:Start>
			<pkc:End>853634999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-64791</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>853000000</pkc:Start>
			<pkc:End>853249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-60318</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>413922000</pkc:Start>
			<pkc:End>414071999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f14a0fcc-9198-49d0-9b48-61398a545aae}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-96329</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>829960000</pkc:Start>
			<pkc:End>846999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f14a0fcc-9198-49d0-9b48-61398a545aae}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-73619</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>828000000</pkc:Start>
			<pkc:End>828159999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f14a0fcc-9198-49d0-9b48-61398a545aae}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-73620</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>828160000</pkc:Start>
			<pkc:End>829959999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90528</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>511550000</pkc:Start>
			<pkc:End>515999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-72462</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>511000000</pkc:Start>
			<pkc:End>511249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-72451</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>511250000</pkc:Start>
			<pkc:End>511549999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{104434dc-1ca5-43dd-a2c1-aa662b5dc912}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85678</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>454000000</pkc:Start>
			<pkc:End>456999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{104434dc-1ca5-43dd-a2c1-aa662b5dc912}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85679</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>457000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{58a6435c-0657-4912-b0f5-810215560e47}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85682</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>286000000</pkc:Start>
			<pkc:End>290999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{58a6435c-0657-4912-b0f5-810215560e47}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85683</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>291000000</pkc:Start>
			<pkc:End>295999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{58a6435c-0657-4912-b0f5-810215560e47}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85680</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426000000</pkc:Start>
			<pkc:End>432999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{58a6435c-0657-4912-b0f5-810215560e47}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85681</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>443999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{79303950-2706-45d7-8157-2f00cdf0d1a4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85676</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>467000000</pkc:Start>
			<pkc:End>469999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{79303950-2706-45d7-8157-2f00cdf0d1a4}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85677</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>451000000</pkc:Start>
			<pkc:End>453999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7f8cb0c8-047f-4544-a308-0e3561354ea8}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85672</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302411000</pkc:Start>
			<pkc:End>302411999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f6afe16-133b-4ee3-9278-3d5d32dd2579}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85670</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302410000</pkc:Start>
			<pkc:End>302410999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d034a056-e1d5-43e0-9511-7586b6d335eb}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85673</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302412000</pkc:Start>
			<pkc:End>302412999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d034a056-e1d5-43e0-9511-7586b6d335eb}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85674</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302413000</pkc:Start>
			<pkc:End>302413999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89497</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302406000</pkc:Start>
			<pkc:End>302406999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89498</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302407000</pkc:Start>
			<pkc:End>302407999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89495</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302404000</pkc:Start>
			<pkc:End>302404999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89496</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302405000</pkc:Start>
			<pkc:End>302405999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86149</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>301000000</pkc:Start>
			<pkc:End>301699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86150</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>301700000</pkc:Start>
			<pkc:End>302399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86155</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>377999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86159</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>378000000</pkc:Start>
			<pkc:End>387999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86151</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>348999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86152</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>349000000</pkc:Start>
			<pkc:End>358999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86153</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>336499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86157</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336500000</pkc:Start>
			<pkc:End>336999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85348</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85349</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>275999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85343</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>408000000</pkc:Start>
			<pkc:End>414999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fe34a6c-50a1-4cfb-9013-3fdf51127f04}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85345</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>415000000</pkc:Start>
			<pkc:End>421999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6860916b-c83f-4d66-a28c-c6b78499e7d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89499</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302408000</pkc:Start>
			<pkc:End>302408999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6860916b-c83f-4d66-a28c-c6b78499e7d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89500</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302409000</pkc:Start>
			<pkc:End>302409999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6860916b-c83f-4d66-a28c-c6b78499e7d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86156</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>388000000</pkc:Start>
			<pkc:End>397999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6860916b-c83f-4d66-a28c-c6b78499e7d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86160</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>398000000</pkc:Start>
			<pkc:End>407999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6860916b-c83f-4d66-a28c-c6b78499e7d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86154</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>201000000</pkc:Start>
			<pkc:End>201499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6860916b-c83f-4d66-a28c-c6b78499e7d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-86158</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>201500000</pkc:Start>
			<pkc:End>201999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6860916b-c83f-4d66-a28c-c6b78499e7d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85350</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>276000000</pkc:Start>
			<pkc:End>280999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6860916b-c83f-4d66-a28c-c6b78499e7d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85351</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>281000000</pkc:Start>
			<pkc:End>285999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{96fd21ec-7c70-4c04-9fce-b034941c0473}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85684</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>296000000</pkc:Start>
			<pkc:End>300999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{96fd21ec-7c70-4c04-9fce-b034941c0473}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85685</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>446000000</pkc:Start>
			<pkc:End>450999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f5cfb3d-6288-4f6f-9d57-fffd843d53e6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85675</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302414000</pkc:Start>
			<pkc:End>302414999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7b5306ad-0d02-463c-8177-59087ff8a58b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89503</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302402000</pkc:Start>
			<pkc:End>302402999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7b5306ad-0d02-463c-8177-59087ff8a58b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89504</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302403000</pkc:Start>
			<pkc:End>302403999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7b5306ad-0d02-463c-8177-59087ff8a58b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85354</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>461000000</pkc:Start>
			<pkc:End>463999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7b5306ad-0d02-463c-8177-59087ff8a58b}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85355</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>464000000</pkc:Start>
			<pkc:End>466999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e52b173-d1b8-4cc7-8a68-fd2ab63e25e0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89501</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302400000</pkc:Start>
			<pkc:End>302400999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e52b173-d1b8-4cc7-8a68-fd2ab63e25e0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89502</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302401000</pkc:Start>
			<pkc:End>302401999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e52b173-d1b8-4cc7-8a68-fd2ab63e25e0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85352</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>422000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e52b173-d1b8-4cc7-8a68-fd2ab63e25e0}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-85353</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>433000000</pkc:Start>
			<pkc:End>435999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{88a30fce-0fde-49b0-8cc6-4fbd568e7b5d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-78817</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>268620000</pkc:Start>
			<pkc:End>268919999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4e491fef-6f37-42a3-ab48-4314d83e3627}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-93835:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>86450000</pkc:Start>
			<pkc:End>86599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0447e96f-4062-4c1b-b068-98c8326016f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-59333</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>101970000</pkc:Start>
			<pkc:End>101984999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9515b08e-d839-4df3-bfe7-daecde02d97e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-59337</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>303318000</pkc:Start>
			<pkc:End>303389999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9515b08e-d839-4df3-bfe7-daecde02d97e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-59337</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>304338000</pkc:Start>
			<pkc:End>304637999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{911e20cb-83ea-44ed-8799-073be1f77f22}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-89961:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>303738000</pkc:Start>
			<pkc:End>304037999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9515b08e-d839-4df3-bfe7-daecde02d97e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-14444:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>304638000</pkc:Start>
			<pkc:End>304987999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04771</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>264606000</pkc:Start>
			<pkc:End>264685999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04772:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>264686000</pkc:Start>
			<pkc:End>264765999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04775</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271080000</pkc:Start>
			<pkc:End>271159999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04776:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271160000</pkc:Start>
			<pkc:End>271239999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04773</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>264766000</pkc:Start>
			<pkc:End>264845999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04774:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>271079999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00304</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>268500000</pkc:Start>
			<pkc:End>268559999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00305:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>268560000</pkc:Start>
			<pkc:End>268619999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04759</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271240000</pkc:Start>
			<pkc:End>281239999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04760:Virtual</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>208999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04763</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>229000000</pkc:Start>
			<pkc:End>238999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04764:Virtual</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>239000000</pkc:Start>
			<pkc:End>248999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04761</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>209000000</pkc:Start>
			<pkc:End>218999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04762:Virtual</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219000000</pkc:Start>
			<pkc:End>228999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00058</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>280999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00059:Virtual</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>281000000</pkc:Start>
			<pkc:End>290999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04757</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>249000000</pkc:Start>
			<pkc:End>249499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04758:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>249500000</pkc:Start>
			<pkc:End>249999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04753</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>251000000</pkc:Start>
			<pkc:End>251499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04754:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>251500000</pkc:Start>
			<pkc:End>251999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04755</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>250000000</pkc:Start>
			<pkc:End>250499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04756:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>250500000</pkc:Start>
			<pkc:End>250999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00067</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110400000</pkc:Start>
			<pkc:End>110899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00066:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>268000000</pkc:Start>
			<pkc:End>268499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7c4ab58c-78f4-4403-bda2-d5bfb449ddf1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04780</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>256203000</pkc:Start>
			<pkc:End>256203999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{feb01ead-d438-4556-a5b3-2b6557da8737}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04782</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>256205000</pkc:Start>
			<pkc:End>256205999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c135db9b-0074-4ef9-a405-a415de4e31a5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04781</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>256204000</pkc:Start>
			<pkc:End>256204999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{15a581b4-f839-4d26-943c-b7e72f219849}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00441</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302416000</pkc:Start>
			<pkc:End>302416999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1404ea26-d078-4786-886a-0da035b2cd5a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04789</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>262206000</pkc:Start>
			<pkc:End>262605999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1404ea26-d078-4786-886a-0da035b2cd5a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04790:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>262606000</pkc:Start>
			<pkc:End>263005999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c99b1d91-25f1-4024-a20c-0e9da8d15225}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04793</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>263806000</pkc:Start>
			<pkc:End>264205999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c99b1d91-25f1-4024-a20c-0e9da8d15225}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04794:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>264206000</pkc:Start>
			<pkc:End>264605999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{74143dee-b000-419d-badc-b650f7e316e4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04791</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>263006000</pkc:Start>
			<pkc:End>263405999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{74143dee-b000-419d-badc-b650f7e316e4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04792:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>263406000</pkc:Start>
			<pkc:End>263805999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00454</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>126000000</pkc:Start>
			<pkc:End>126399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00455:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>101470000</pkc:Start>
			<pkc:End>101969999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04795</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>264846000</pkc:Start>
			<pkc:End>265245999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04798:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>266046000</pkc:Start>
			<pkc:End>266445999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04796</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>265246000</pkc:Start>
			<pkc:End>265645999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04799:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>266446000</pkc:Start>
			<pkc:End>266845999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04797</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>265646000</pkc:Start>
			<pkc:End>266045999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04800:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>266846000</pkc:Start>
			<pkc:End>267245999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00468</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>109500000</pkc:Start>
			<pkc:End>109999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-00469:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110000000</pkc:Start>
			<pkc:End>110399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04765</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>281240000</pkc:Start>
			<pkc:End>281439999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04766:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>281440000</pkc:Start>
			<pkc:End>281639999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04769</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>282040000</pkc:Start>
			<pkc:End>282239999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04770:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>282240000</pkc:Start>
			<pkc:End>282439999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04767</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>281640000</pkc:Start>
			<pkc:End>281839999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04768:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>281840000</pkc:Start>
			<pkc:End>282039999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04747</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>252000000</pkc:Start>
			<pkc:End>252699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04748:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>252700000</pkc:Start>
			<pkc:End>253399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04751</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>254800000</pkc:Start>
			<pkc:End>255499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04752:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>255500000</pkc:Start>
			<pkc:End>256199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04749</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>253400000</pkc:Start>
			<pkc:End>254099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04750:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>254100000</pkc:Start>
			<pkc:End>254799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7c4ab58c-78f4-4403-bda2-d5bfb449ddf1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04777</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>256200000</pkc:Start>
			<pkc:End>256200999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{feb01ead-d438-4556-a5b3-2b6557da8737}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04779</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>256202000</pkc:Start>
			<pkc:End>256202999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c135db9b-0074-4ef9-a405-a415de4e31a5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04778</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>256201000</pkc:Start>
			<pkc:End>256201999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1404ea26-d078-4786-886a-0da035b2cd5a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04783</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>256206000</pkc:Start>
			<pkc:End>257205999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1404ea26-d078-4786-886a-0da035b2cd5a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04784:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>257206000</pkc:Start>
			<pkc:End>258205999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c99b1d91-25f1-4024-a20c-0e9da8d15225}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04787</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>260206000</pkc:Start>
			<pkc:End>261205999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c99b1d91-25f1-4024-a20c-0e9da8d15225}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04788:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>261206000</pkc:Start>
			<pkc:End>262205999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{74143dee-b000-419d-badc-b650f7e316e4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04785</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>258206000</pkc:Start>
			<pkc:End>259205999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{74143dee-b000-419d-badc-b650f7e316e4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04786:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259206000</pkc:Start>
			<pkc:End>260205999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04801</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>637999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7c0e03c-9b98-4219-82dd-d17d9543891c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04804:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>640000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04802</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>638000000</pkc:Start>
			<pkc:End>638999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92da208a-1a89-4407-88e6-bb5ca02aec47}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04805:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>660999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04803</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>639000000</pkc:Start>
			<pkc:End>639999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c07c927-9017-4dbf-84e7-06c3a61fed6a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-04806:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>661000000</pkc:Start>
			<pkc:End>661999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22088</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>102000000</pkc:Start>
			<pkc:End>103599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23867</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>291000000</pkc:Start>
			<pkc:End>292599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23872</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>292600000</pkc:Start>
			<pkc:End>294199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7acd9eb8-e300-444c-b38a-47cdbe065508}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22090:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>128000000</pkc:Start>
			<pkc:End>129399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23878</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>294200000</pkc:Start>
			<pkc:End>295599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23864</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>295600000</pkc:Start>
			<pkc:End>296699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23869</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>296700000</pkc:Start>
			<pkc:End>297799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23875</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>297800000</pkc:Start>
			<pkc:End>298899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23881</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>298900000</pkc:Start>
			<pkc:End>299999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32b40e5e-0c6d-4c6f-ab12-a031933fd2c6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19719</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>300000000</pkc:Start>
			<pkc:End>300899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a6ad72e3-67a6-4d46-af1c-5f542c22ef7c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22082</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>103600000</pkc:Start>
			<pkc:End>104499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a6ad72e3-67a6-4d46-af1c-5f542c22ef7c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22083:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>104500000</pkc:Start>
			<pkc:End>105399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2cf1c8d6-ebe1-4ce9-83c6-c4877fae1355}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19709</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>300900000</pkc:Start>
			<pkc:End>301699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19710:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>301700000</pkc:Start>
			<pkc:End>302499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c6936a36-69f3-4994-9857-3069c7b9ec7a}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19717</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302500000</pkc:Start>
			<pkc:End>303199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{603504f9-109f-49f0-9271-8c66f7878f58}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19718:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>303200000</pkc:Start>
			<pkc:End>303899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32b40e5e-0c6d-4c6f-ab12-a031933fd2c6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-20002:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>303900000</pkc:Start>
			<pkc:End>304499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24227</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>304500000</pkc:Start>
			<pkc:End>305099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24228</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>305100000</pkc:Start>
			<pkc:End>305699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a77a6806-f59e-4953-97d7-229317b8e6a6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-24093</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>20599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{388afeb9-3b92-44a2-a3dd-1e68665f6d36}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22084</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>105400000</pkc:Start>
			<pkc:End>105899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{388afeb9-3b92-44a2-a3dd-1e68665f6d36}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22085:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>105900000</pkc:Start>
			<pkc:End>106399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a6ad72e3-67a6-4d46-af1c-5f542c22ef7c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22103</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>106400000</pkc:Start>
			<pkc:End>106899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a6ad72e3-67a6-4d46-af1c-5f542c22ef7c}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22104:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>106900000</pkc:Start>
			<pkc:End>107399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d020c729-07f0-4f8f-87ce-bf803275c786}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22080</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>107400000</pkc:Start>
			<pkc:End>107799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d020c729-07f0-4f8f-87ce-bf803275c786}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22081:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>107800000</pkc:Start>
			<pkc:End>108199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8210c9d1-4686-4f46-ac2e-56cf4e6ba674}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22116:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>108200000</pkc:Start>
			<pkc:End>108599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24715</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426000000</pkc:Start>
			<pkc:End>426399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24716</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426400000</pkc:Start>
			<pkc:End>426799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24720</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>775000000</pkc:Start>
			<pkc:End>775399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{256cc990-1692-4ea8-965c-2d423d5dd24e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22086</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>108600000</pkc:Start>
			<pkc:End>108899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{256cc990-1692-4ea8-965c-2d423d5dd24e}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22087:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>108900000</pkc:Start>
			<pkc:End>109199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8210c9d1-4686-4f46-ac2e-56cf4e6ba674}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22096</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>109200000</pkc:Start>
			<pkc:End>109499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8210c9d1-4686-4f46-ac2e-56cf4e6ba674}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22097:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>109500000</pkc:Start>
			<pkc:End>109799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{28169020-83db-42d0-87bb-7709454c5f62}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22098:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>109800000</pkc:Start>
			<pkc:End>110099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d020c729-07f0-4f8f-87ce-bf803275c786}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22099</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110100000</pkc:Start>
			<pkc:End>110399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8210c9d1-4686-4f46-ac2e-56cf4e6ba674}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22115</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110400000</pkc:Start>
			<pkc:End>110699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a77a6806-f59e-4953-97d7-229317b8e6a6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19723</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>86600000</pkc:Start>
			<pkc:End>86799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a77a6806-f59e-4953-97d7-229317b8e6a6}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-19725:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>86800000</pkc:Start>
			<pkc:End>86999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{28169020-83db-42d0-87bb-7709454c5f62}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22102</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>129400000</pkc:Start>
			<pkc:End>129599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23898</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87450000</pkc:Start>
			<pkc:End>87649999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23899</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87650000</pkc:Start>
			<pkc:End>87849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23900</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>268920000</pkc:Start>
			<pkc:End>269119999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24090</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>269120000</pkc:Start>
			<pkc:End>269319999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d020c729-07f0-4f8f-87ce-bf803275c786}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22100:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110700000</pkc:Start>
			<pkc:End>110769999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23866</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110900000</pkc:Start>
			<pkc:End>110959999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23860</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110960000</pkc:Start>
			<pkc:End>110979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb1d27c4-959d-4f82-b0fd-c02a7be54732}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23861</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110980000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23862</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81447000</pkc:Start>
			<pkc:End>81466999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23874</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81467000</pkc:Start>
			<pkc:End>81486999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23877</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81487000</pkc:Start>
			<pkc:End>81506999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23880</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81507000</pkc:Start>
			<pkc:End>81526999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23863</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81527000</pkc:Start>
			<pkc:End>81531999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23868</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81532000</pkc:Start>
			<pkc:End>81536999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9add589-f877-4aad-af6b-d641674d4ac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23871</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81537000</pkc:Start>
			<pkc:End>81541999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23873</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81542000</pkc:Start>
			<pkc:End>81546999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23879</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81547000</pkc:Start>
			<pkc:End>81551999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23882</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81552000</pkc:Start>
			<pkc:End>81556999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{94dd1d84-9d70-45ff-ae30-6c1643e583ac}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22121</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110770000</pkc:Start>
			<pkc:End>110770999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{15a581b4-f839-4d26-943c-b7e72f219849}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-22128</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110771000</pkc:Start>
			<pkc:End>110771999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e0872c5d-9308-4c2a-ba9b-22f04a9b9480}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28181</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>757250000</pkc:Start>
			<pkc:End>759499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{136595fa-543f-4a64-8326-873935b7b7a1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28182</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>756000000</pkc:Start>
			<pkc:End>757249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{acc41c6f-dc9f-40ca-b0da-108c7a5f8d90}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28183</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>854000000</pkc:Start>
			<pkc:End>973999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2d2d5664-88bd-4ebc-959a-dea6b1b80dc0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28184</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>711999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{94451d5d-8520-43d3-af38-4e54d817a407}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28185</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>606000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f79b5e33-4a4e-451c-9e8a-55dcc9bdb89d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28186</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>903000000</pkc:Start>
			<pkc:End>937999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f79b5e33-4a4e-451c-9e8a-55dcc9bdb89d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28187</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847000000</pkc:Start>
			<pkc:End>902999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28188</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>820500000</pkc:Start>
			<pkc:End>824999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{33a7e8d3-e2ab-413b-96a6-27c83b21c695}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28189</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>884000000</pkc:Start>
			<pkc:End>887499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89e51a3c-76c0-4beb-a650-53d34c8f8186}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28190</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>825000000</pkc:Start>
			<pkc:End>825999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3acdd3c-119a-4932-a3d7-0b6f33a1dca9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28191</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>826500000</pkc:Start>
			<pkc:End>826749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{86e0a073-040b-4e10-aaf1-55f75482b5a4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28194</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>558000000</pkc:Start>
			<pkc:End>563999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{86e0a073-040b-4e10-aaf1-55f75482b5a4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28195</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>564000000</pkc:Start>
			<pkc:End>570499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{86e0a073-040b-4e10-aaf1-55f75482b5a4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28196</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>493000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{86e0a073-040b-4e10-aaf1-55f75482b5a4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28196</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>237000000</pkc:Start>
			<pkc:End>261999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f23dba60-517a-4184-bd26-066d9e3c19a9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28197</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>546999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{08efb8fe-c403-4019-a084-9da91108cead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28198</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>890000000</pkc:Start>
			<pkc:End>919999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da0483a8-c443-45fd-9b52-2bba9b2ee8ab}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28199</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>831000000</pkc:Start>
			<pkc:End>889999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7e0e0685-8eef-47b8-8b25-f03f9819eb17}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28200</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>585999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7e0e0685-8eef-47b8-8b25-f03f9819eb17}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28201</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>173000000</pkc:Start>
			<pkc:End>182999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7e0e0685-8eef-47b8-8b25-f03f9819eb17}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28202</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>461000000</pkc:Start>
			<pkc:End>468249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7e0e0685-8eef-47b8-8b25-f03f9819eb17}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28203</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>355999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{121059c3-724a-48ba-b745-5ab6daad8e37}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28204</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>172999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{121059c3-724a-48ba-b745-5ab6daad8e37}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28205</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>397999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{121059c3-724a-48ba-b745-5ab6daad8e37}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28206</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>505000000</pkc:Start>
			<pkc:End>529999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{121059c3-724a-48ba-b745-5ab6daad8e37}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28207</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>398000000</pkc:Start>
			<pkc:End>409999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a7a4a974-ad47-420e-8e1a-83d28572058a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28209</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>830000000</pkc:Start>
			<pkc:End>857999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a7a4a974-ad47-420e-8e1a-83d28572058a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28210</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>504999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a7a4a974-ad47-420e-8e1a-83d28572058a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28211</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>829999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a7a4a974-ad47-420e-8e1a-83d28572058a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28213</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>410000000</pkc:Start>
			<pkc:End>419999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4cb70ae9-faf0-4cc1-88e5-f9d1d388e39a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28214</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>586000000</pkc:Start>
			<pkc:End>609999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{95fac25a-4268-48c3-ae04-071ea19594fa}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28215</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>766999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{70449d13-fe2e-453e-a19f-68b031ff1a19}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28216</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>64000000</pkc:Start>
			<pkc:End>75499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{657fd7f1-652f-4a7f-9cef-e45e60f8b4c7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28217</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>888999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{657fd7f1-652f-4a7f-9cef-e45e60f8b4c7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28219</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>75500000</pkc:Start>
			<pkc:End>81999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{657fd7f1-652f-4a7f-9cef-e45e60f8b4c7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28220</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>781999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{657fd7f1-652f-4a7f-9cef-e45e60f8b4c7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28221</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>93500000</pkc:Start>
			<pkc:End>93749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6f4429fd-9729-443a-abfc-a3daf21ba4b6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28222</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>889000000</pkc:Start>
			<pkc:End>970999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{11db994f-af86-4eb9-af35-fb4e3b0256f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28223</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>88000000</pkc:Start>
			<pkc:End>93499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{11db994f-af86-4eb9-af35-fb4e3b0256f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28224</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>82000000</pkc:Start>
			<pkc:End>87999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{11db994f-af86-4eb9-af35-fb4e3b0256f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28225</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>782000000</pkc:Start>
			<pkc:End>784999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6b16d38b-7dac-4614-9948-b4a92ddba889}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28226</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6b16d38b-7dac-4614-9948-b4a92ddba889}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28226</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>363999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6b16d38b-7dac-4614-9948-b4a92ddba889}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28227</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6b16d38b-7dac-4614-9948-b4a92ddba889}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28227</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>461000000</pkc:Start>
			<pkc:End>469999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ab8e6bc4-0499-484e-8da1-761697126843}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28228</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>193999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c6166b46-aba5-4374-8bdf-be06bde66223}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28229</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c6166b46-aba5-4374-8bdf-be06bde66223}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28229</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426000000</pkc:Start>
			<pkc:End>435999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c6166b46-aba5-4374-8bdf-be06bde66223}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28229</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>364000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{920b06bf-f7d3-4291-80d3-5d3d91a8be4c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28230</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>591999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{920b06bf-f7d3-4291-80d3-5d3d91a8be4c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28231</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>63999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7fd7e3ea-1a64-4e14-abc6-541992c5ef64}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28322</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>592000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7fd7e3ea-1a64-4e14-abc6-541992c5ef64}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28322</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>194000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9528038-4625-4693-ac4d-43387ec18233}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28323</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e9528038-4625-4693-ac4d-43387ec18233}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28323</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>454999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30494</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>427000000</pkc:Start>
			<pkc:End>436999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30494</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>448000000</pkc:Start>
			<pkc:End>476999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30494</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>617000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30494</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>641000000</pkc:Start>
			<pkc:End>659999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30494</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>699999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30494</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30495</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>139000000</pkc:Start>
			<pkc:End>198999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30498</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>44999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5d8ec70-e2ae-42d8-aaa9-eec3772438ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30501</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>45000000</pkc:Start>
			<pkc:End>50499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30502</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>784000000</pkc:Start>
			<pkc:End>787999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30503</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>136000000</pkc:Start>
			<pkc:End>138999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30504</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>966000000</pkc:Start>
			<pkc:End>968249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30505</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>550000000</pkc:Start>
			<pkc:End>550999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30506</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>665000000</pkc:Start>
			<pkc:End>665999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30507</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>788000000</pkc:Start>
			<pkc:End>788999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f14a0fcc-9198-49d0-9b48-61398a545aae}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30508</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>826000000</pkc:Start>
			<pkc:End>826499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30509</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>826750000</pkc:Start>
			<pkc:End>826999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30511</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>645999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bb4c2c10-dc0d-4ce6-8824-ee71ddb63c07}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30512</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>657000000</pkc:Start>
			<pkc:End>662999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30513</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425110000</pkc:Start>
			<pkc:End>425199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30769</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>712000000</pkc:Start>
			<pkc:End>721999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30770</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>722000000</pkc:Start>
			<pkc:End>731999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30771</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>732000000</pkc:Start>
			<pkc:End>741999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30fab9cc-8614-4339-989f-7ce61fb7a5c4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30772</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>742000000</pkc:Start>
			<pkc:End>751999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-31116</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>752000000</pkc:Start>
			<pkc:End>755999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24a6d36e-9110-4081-bec6-fa27c8e860d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-31117</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>817000000</pkc:Start>
			<pkc:End>820499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cdb090c3-053c-4cd1-9cb2-e35b1738747a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-31118</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>880500000</pkc:Start>
			<pkc:End>883999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5f44767a-daac-470f-8e93-294b3217f956}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-31119</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>877000000</pkc:Start>
			<pkc:End>880499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24a6d36e-9110-4081-bec6-fa27c8e860d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-31120</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>663000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24a6d36e-9110-4081-bec6-fa27c8e860d0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-31121</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>887500000</pkc:Start>
			<pkc:End>888999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0101b69a-85c8-4344-8196-7a16a7790bb5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-31344</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>61999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24d57dfd-f6e1-48f9-a045-0520a52f84c7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-31345</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>62000000</pkc:Start>
			<pkc:End>94999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fbe5f9be-2204-480a-93da-a5f81b3c52d9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-30494</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>330000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e05164a4-fb9a-471f-8c3a-6959b4cf1b72}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28208</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>356000000</pkc:Start>
			<pkc:End>367999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e05164a4-fb9a-471f-8c3a-6959b4cf1b72}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28208</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>420000000</pkc:Start>
			<pkc:End>460999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e05164a4-fb9a-471f-8c3a-6959b4cf1b72}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28208</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>530000000</pkc:Start>
			<pkc:End>550999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e05164a4-fb9a-471f-8c3a-6959b4cf1b72}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28208</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>610000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e05164a4-fb9a-471f-8c3a-6959b4cf1b72}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28208</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>662000000</pkc:Start>
			<pkc:End>665999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e05164a4-fb9a-471f-8c3a-6959b4cf1b72}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28208</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>699999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e05164a4-fb9a-471f-8c3a-6959b4cf1b72}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28208</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>767000000</pkc:Start>
			<pkc:End>788999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e05164a4-fb9a-471f-8c3a-6959b4cf1b72}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-28208</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>858000000</pkc:Start>
			<pkc:End>999999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-96325</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>340600000</pkc:Start>
			<pkc:End>387999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80007</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>308800000</pkc:Start>
			<pkc:End>308849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-80007</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>308850000</pkc:Start>
			<pkc:End>308999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9e042223-03bf-49ae-808f-ff37f128d40d}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23576</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>573949500</pkc:Start>
			<pkc:End>573971499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c5c23f2-a6c3-4c6c-b9b4-1f8796b63254}</pkc:RefActConfigId>
			<pkc:PartNumber>X12-90729</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6115000</pkc:Start>
			<pkc:End>6999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c5c23f2-a6c3-4c6c-b9b4-1f8796b63254}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-17465</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6110000</pkc:Start>
			<pkc:End>6114999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-14166</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>335000000</pkc:Start>
			<pkc:End>335999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-17463</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>506000000</pkc:Start>
			<pkc:End>507499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a4eec485-e375-48b4-8f51-80d13a4086b6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-19694</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>118000000</pkc:Start>
			<pkc:End>147999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-17464</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339600000</pkc:Start>
			<pkc:End>340599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-19693</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>388000000</pkc:Start>
			<pkc:End>407999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-73617</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927000000</pkc:Start>
			<pkc:End>927179999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26241618-ffd9-4440-af04-2ab852b2767f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-73618</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927180000</pkc:Start>
			<pkc:End>928979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d0333dad-c14e-46f2-b62a-8b47a1b9768b}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40008</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>420980000</pkc:Start>
			<pkc:End>420989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40014</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>432980000</pkc:Start>
			<pkc:End>432989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-40015</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>432990000</pkc:Start>
			<pkc:End>432999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b13b0123-8661-4ee2-afb7-05c37481686b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-08727</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>671999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db442be4-81ed-4ab3-9d66-2417e8a5c81c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-44771</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>377500000</pkc:Start>
			<pkc:End>377999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{177df7ed-709f-454a-91bd-947ec8a1e668}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-46713</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>706998800</pkc:Start>
			<pkc:End>706999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b13b0123-8661-4ee2-afb7-05c37481686b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-08727</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>672050000</pkc:Start>
			<pkc:End>674999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b13b0123-8661-4ee2-afb7-05c37481686b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-52457</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>672000000</pkc:Start>
			<pkc:End>672049999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{093e8e65-b6ab-4526-ab64-ae4e8269b656}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-52458</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>201350000</pkc:Start>
			<pkc:End>201399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9de9abe2-d01d-4538-af84-4498bdbc2ba3}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23568</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>573982000</pkc:Start>
			<pkc:End>573982999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d0333dad-c14e-46f2-b62a-8b47a1b9768b}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-04119</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>573972000</pkc:Start>
			<pkc:End>573981999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9515b08e-d839-4df3-bfe7-daecde02d97e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-14444:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>570500000</pkc:Start>
			<pkc:End>570849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8cc39469-8bf4-4859-9f14-639320501a1f}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23956</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>447010000</pkc:Start>
			<pkc:End>447999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-23953</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>414622000</pkc:Start>
			<pkc:End>416721999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5722cd65-5a5c-4315-957a-0e4e5daef5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-08681</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>943600000</pkc:Start>
			<pkc:End>951599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-14166</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>270000000</pkc:Start>
			<pkc:End>270999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-14166</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>636000000</pkc:Start>
			<pkc:End>636999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{91dbad68-4713-4f9c-b351-6e77a8361741}</pkc:RefActConfigId>
			<pkc:PartNumber>X13-14166</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>666000000</pkc:Start>
			<pkc:End>666999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{41606216-0fad-4425-8d6e-63be6ed8dc49}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-24714</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>399000000</pkc:Start>
			<pkc:End>399009999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a79a48fc-70d9-4413-ab47-81cf5d08f7ee}</pkc:RefActConfigId>
			<pkc:PartNumber>X14-27143</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>783800000</pkc:Start>
			<pkc:End>783999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9515b08e-d839-4df3-bfe7-daecde02d97e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-14444:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302469000</pkc:Start>
			<pkc:End>302764999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d188820a-cb63-4bad-a9a2-40b843ee23b7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39736</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000300</pkc:Start>
			<pkc:End>199001299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d188820a-cb63-4bad-a9a2-40b843ee23b7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39737</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000800</pkc:Start>
			<pkc:End>1001799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d188820a-cb63-4bad-a9a2-40b843ee23b7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38851</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>145000000</pkc:Start>
			<pkc:End>145000099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d188820a-cb63-4bad-a9a2-40b843ee23b7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38853</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87000000</pkc:Start>
			<pkc:End>87000099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d188820a-cb63-4bad-a9a2-40b843ee23b7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38928</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>37000000</pkc:Start>
			<pkc:End>49749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d188820a-cb63-4bad-a9a2-40b843ee23b7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38959</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1082800</pkc:Start>
			<pkc:End>1132799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d188820a-cb63-4bad-a9a2-40b843ee23b7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38963</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199201300</pkc:Start>
			<pkc:End>199301299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d188820a-cb63-4bad-a9a2-40b843ee23b7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38963</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>338000000</pkc:Start>
			<pkc:End>338599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d188820a-cb63-4bad-a9a2-40b843ee23b7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38997</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000300</pkc:Start>
			<pkc:End>1000799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8fe15d04-fc66-40e6-bf34-942481e06fd8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34696</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>305000000</pkc:Start>
			<pkc:End>312119999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8fe15d04-fc66-40e6-bf34-942481e06fd8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34697</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6800000</pkc:Start>
			<pkc:End>6919999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c99b641f-c4ea-4e63-bec3-5ed2ccd0f357}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34717</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>312880000</pkc:Start>
			<pkc:End>332999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c99b641f-c4ea-4e63-bec3-5ed2ccd0f357}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34718</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1288000</pkc:Start>
			<pkc:End>1407999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f73d1bcd-0802-47dd-b2d9-81bf2f8c0744}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34719</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>249000000</pkc:Start>
			<pkc:End>259119999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f73d1bcd-0802-47dd-b2d9-81bf2f8c0744}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34720</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259120000</pkc:Start>
			<pkc:End>259239999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c99b641f-c4ea-4e63-bec3-5ed2ccd0f357}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-59684</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>756000000</pkc:Start>
			<pkc:End>765999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24259a22-3bf0-44af-a68b-1b858bce1894}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-10776</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>213999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24259a22-3bf0-44af-a68b-1b858bce1894}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-10777</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>18000000</pkc:Start>
			<pkc:End>18699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24259a22-3bf0-44af-a68b-1b858bce1894}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-10778</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10003000</pkc:Start>
			<pkc:End>10007999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24259a22-3bf0-44af-a68b-1b858bce1894}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-10779</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10500000</pkc:Start>
			<pkc:End>10599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24259a22-3bf0-44af-a68b-1b858bce1894}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-10780</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10008000</pkc:Start>
			<pkc:End>10012999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7b37c913-252b-46be-ad80-b2b5ceade8af}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-09067</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>99000000</pkc:Start>
			<pkc:End>108999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7b37c913-252b-46be-ad80-b2b5ceade8af}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-09068</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>152000000</pkc:Start>
			<pkc:End>191999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7b37c913-252b-46be-ad80-b2b5ceade8af}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-09069</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10100000</pkc:Start>
			<pkc:End>10499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7b37c913-252b-46be-ad80-b2b5ceade8af}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-09070</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>214000000</pkc:Start>
			<pkc:End>233999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29d0b60f-66da-4858-bcaf-9eb513cd310d}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-95346</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>353999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29d0b60f-66da-4858-bcaf-9eb513cd310d}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-95347</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110000000</pkc:Start>
			<pkc:End>110699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29d0b60f-66da-4858-bcaf-9eb513cd310d}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-95348</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10013000</pkc:Start>
			<pkc:End>10017999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29d0b60f-66da-4858-bcaf-9eb513cd310d}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-95349</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10600000</pkc:Start>
			<pkc:End>10699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29d0b60f-66da-4858-bcaf-9eb513cd310d}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-95350</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10018000</pkc:Start>
			<pkc:End>10022999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dcb88f6f-b090-405b-850e-dabcccf3693f}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-90705</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>310999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dcb88f6f-b090-405b-850e-dabcccf3693f}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-90706</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>311000000</pkc:Start>
			<pkc:End>330999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dcb88f6f-b090-405b-850e-dabcccf3693f}</pkc:RefActConfigId>
			<pkc:PartNumber>X18-90707</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>109000000</pkc:Start>
			<pkc:End>109499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95508</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>778000000</pkc:Start>
			<pkc:End>779999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95509</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>780000000</pkc:Start>
			<pkc:End>781999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95510</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>782000000</pkc:Start>
			<pkc:End>783999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95511</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>784000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95512</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>887000000</pkc:Start>
			<pkc:End>888999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20442</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>919000000</pkc:Start>
			<pkc:End>923999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20442</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926000000</pkc:Start>
			<pkc:End>928999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20558</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>924000000</pkc:Start>
			<pkc:End>924499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20443</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>924500000</pkc:Start>
			<pkc:End>924999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20444</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>925000000</pkc:Start>
			<pkc:End>925499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{553673ed-6ddf-419c-a153-b760283472fd}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20445</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>925500000</pkc:Start>
			<pkc:End>925999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95513</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>889000000</pkc:Start>
			<pkc:End>890999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95514</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891000000</pkc:Start>
			<pkc:End>892999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95515</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>893000000</pkc:Start>
			<pkc:End>894999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95516</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>895000000</pkc:Start>
			<pkc:End>896999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95517</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>897000000</pkc:Start>
			<pkc:End>898999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20446</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>929000000</pkc:Start>
			<pkc:End>930999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20446</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>933000000</pkc:Start>
			<pkc:End>933999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20559</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>931000000</pkc:Start>
			<pkc:End>931499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20447</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>931500000</pkc:Start>
			<pkc:End>931999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20448</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>932000000</pkc:Start>
			<pkc:End>932499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{04fa0286-fa74-401e-bbe9-fbfbb158010d}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20449</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>932500000</pkc:Start>
			<pkc:End>932999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95518</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>899000000</pkc:Start>
			<pkc:End>900999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95519</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>900999999</pkc:Start>
			<pkc:End>902999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95520</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>903000000</pkc:Start>
			<pkc:End>904999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95521</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>905000000</pkc:Start>
			<pkc:End>906999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95522</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>907000000</pkc:Start>
			<pkc:End>908999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20450</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>934000000</pkc:Start>
			<pkc:End>935999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20450</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>938000000</pkc:Start>
			<pkc:End>938999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20560</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>936000000</pkc:Start>
			<pkc:End>936499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20451</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>936500000</pkc:Start>
			<pkc:End>936999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20452</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937000000</pkc:Start>
			<pkc:End>937499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16c08c85-0c8b-4009-9b2b-f1f7319e45f9}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20453</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937500000</pkc:Start>
			<pkc:End>937999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32163ff8-e96d-40b1-973c-44b9bf096d83}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-38565</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>845000000</pkc:Start>
			<pkc:End>849999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32163ff8-e96d-40b1-973c-44b9bf096d83}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-38570</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>865000000</pkc:Start>
			<pkc:End>884999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32163ff8-e96d-40b1-973c-44b9bf096d83}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09593</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>850000000</pkc:Start>
			<pkc:End>854999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32163ff8-e96d-40b1-973c-44b9bf096d83}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09564</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>855000000</pkc:Start>
			<pkc:End>859999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{32163ff8-e96d-40b1-973c-44b9bf096d83}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09565</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>860000000</pkc:Start>
			<pkc:End>864999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{338554b7-6f0a-48b6-aef3-ff6b42f1398b}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-38575</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>885000000</pkc:Start>
			<pkc:End>886999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{338554b7-6f0a-48b6-aef3-ff6b42f1398b}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09567</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>887000000</pkc:Start>
			<pkc:End>888999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{338554b7-6f0a-48b6-aef3-ff6b42f1398b}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09568</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>889000000</pkc:Start>
			<pkc:End>890999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{338554b7-6f0a-48b6-aef3-ff6b42f1398b}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09569</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891000000</pkc:Start>
			<pkc:End>892999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{338554b7-6f0a-48b6-aef3-ff6b42f1398b}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09570</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>893000000</pkc:Start>
			<pkc:End>894999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0ed79ef1-052c-4362-9cdc-5141491d06dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09571</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>895000000</pkc:Start>
			<pkc:End>896999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0ed79ef1-052c-4362-9cdc-5141491d06dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09572</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>897000000</pkc:Start>
			<pkc:End>898999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0ed79ef1-052c-4362-9cdc-5141491d06dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09573</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>899000000</pkc:Start>
			<pkc:End>900999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0ed79ef1-052c-4362-9cdc-5141491d06dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09574</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>901000000</pkc:Start>
			<pkc:End>902999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0ed79ef1-052c-4362-9cdc-5141491d06dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-09575</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>903000000</pkc:Start>
			<pkc:End>904999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95523</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>909000000</pkc:Start>
			<pkc:End>910999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95524</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>911000000</pkc:Start>
			<pkc:End>912999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95525</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>913000000</pkc:Start>
			<pkc:End>914999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95526</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>915000000</pkc:Start>
			<pkc:End>916999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X21-95527</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>917000000</pkc:Start>
			<pkc:End>918999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20454</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>939000000</pkc:Start>
			<pkc:End>940999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20454</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>943000000</pkc:Start>
			<pkc:End>943999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20561</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>941000000</pkc:Start>
			<pkc:End>941499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20455</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>941500000</pkc:Start>
			<pkc:End>941999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20456</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942000000</pkc:Start>
			<pkc:End>942499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8e7bfb1e-acc1-4f56-abae-b80fce56cd4b}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-20457</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942500000</pkc:Start>
			<pkc:End>942999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3ca9443e-6f68-4747-bb5e-7f0fbbd55ef0}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-14545</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>771900000</pkc:Start>
			<pkc:End>771944999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3ca9443e-6f68-4747-bb5e-7f0fbbd55ef0}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-14545</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1586000</pkc:Start>
			<pkc:End>1590999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{66c3d302-3a0e-4fca-9558-5a185996e592}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-14548</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>771945000</pkc:Start>
			<pkc:End>771989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{66c3d302-3a0e-4fca-9558-5a185996e592}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-14548</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1601000</pkc:Start>
			<pkc:End>1605999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5958cad-5b44-4780-8a6c-aa0d7033d261}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-14551</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>777700000</pkc:Start>
			<pkc:End>777744999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c5958cad-5b44-4780-8a6c-aa0d7033d261}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-14551</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1616000</pkc:Start>
			<pkc:End>1620999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f2d2e88e-bc56-41ab-9546-e8da76eefe6b}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-15119</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926150000</pkc:Start>
			<pkc:End>926199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{aa894c3f-dcb9-4907-a7b8-ffe1770b6c56}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-15120</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926200000</pkc:Start>
			<pkc:End>926249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d9b408a5-e3a9-4063-92b2-87f400cd9efb}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-15121</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926250000</pkc:Start>
			<pkc:End>926299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{130ab21f-ca91-4aae-b67f-ac3b45534731}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-32243</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>1000009</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a7e6fb3c-cb11-4832-bab0-deee887af138}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-32244</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000010</pkc:Start>
			<pkc:End>1000019</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{151db6a5-3dfa-4c7f-b5ba-af8d7991adc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-32245</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000020</pkc:Start>
			<pkc:End>1000029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bf10cbf5-500e-4426-99d9-297874760c80}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-15099</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>925000300</pkc:Start>
			<pkc:End>925000399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{de04b282-b11d-4506-9d33-f8c0bf621bdf}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-15100</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>925000400</pkc:Start>
			<pkc:End>925000499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c7807891-4364-40b8-8093-afac81160d91}</pkc:RefActConfigId>
			<pkc:PartNumber>X23-15101</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>925000500</pkc:Start>
			<pkc:End>925000599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d9205746-5f80-4062-ab75-eda24319d0fc}</pkc:RefActConfigId>
			<pkc:PartNumber>X22-32270</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000030</pkc:Start>
			<pkc:End>1000039</pkc:End>
		</pkc:KeyRange>
	</pkc:KeyRanges>
	<pkc:PublicKeys>
		<pkc:PublicKey>
			<pkc:GroupId>140</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>142</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>144</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>146</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>d2ZVRAABAAEzAQAAMyIRAAABAAEADg4DAAAAAgAAAAAAAAAAAAAAAAAAAA4AAAApAAAAyAAAAB8AAAAjAQMIDw8PHwMDAwMDBz9lRlQkZQyCO4odm4yzK+95rQH3Rhg7ih2bjLMrBAEAAQIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADaFNTfbm0EpMA/0x9NAU3mwCIgcXWY/gwmaFsSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN6gtF62YEIm9f0vs1kkliDOU2Do53nQKCiKRiAk5X8lu9G4ziI0+t5QDkgUSW0fVEW4HYrNg+8p63mxDt74JwfqUx2pwyaxnNjDOpQkxTgI8KjYCyodVLyMmvhTDF/1zSkE0TlJUWzQZtFPaz8lpSPQ/u5oryvXice8r83iEmM+wB/J0KxdMz5jLPgOdxPB7dpGNSkp44WIsR6f+youjpoYa83v2yIJAsdyDEW0rhCot7ZKiHoQbYHc3vWrFjhYsqIACA3snDaLVrVZRayh+9f1KRJdtjcbydECHCYS6tQhT54Ej2h9oNQ7S4wWCwBYvj82OhVDm/IF/ZtBI4ghjhgaXEZ58s/h/FkfwXnHRSR01wc6jjoz3CosNlS51i4GAmUG/rzTE3+qbe+9aj/a3g+L+/Um6+gBuFs55tFdqI15Tw0/PzsSWrs4D+/LDrpHHKAldToNipciiM7aoiQAHFITbGuuVUx4vCqBiACcfQ2PxISmmD7kNUs4DDbbaVa15rckCSzTKIIrDxqZd4jw+rqPz0vjsSXBEOs0p00/mqkGnTjUISWFGQAfybLe2IsGyPYGdZj6JyCfE52J94yW8ypxHQc41Ogvl2rGYpU8D81qjg5x+1LherK4a6koUtH5cxmg0l5T2YTZagCG84t90WzO7Zvd5lb+GfwSo7SJwSSq8a+lx+gKQLJfFXzYOZT5RfQrTBuLT9zcIcjaLiAA4/vpDF/ZA7b4MoNqFJm5y2kW1kzE4CEvbObyQ9DAYBS/5QbAO9W4HXrEV4TDB17zgh0DWhPw6OcKoT4JV+0PXe0FCK7K0Wq55xVGrQw7Xh/FAGjtABpcIuvm1p72r7sCtmTkchIaxVQYkPvjbc+Iu8sGHyCjqI1nXlyGZfvPKUKoGiYUvl0A37bXOicUiDIEI3C8/7Rk4LX2tagc/SbGhJ02QU2w1+rHe36wAHINcFSwk9n2I3a5jKAGavh5cY4DwV8xWxmGpyIvrBOjfZwnQ4ocIddLFDlcSv76CIsMiTleLIEATIRqBIfvcemd1UUibyK9KYxbdsg+e2+Bthn1JoV+nRhR/y0qQ5vtEJETOk/GgzjaMMBpazrliBkyjZ/ezEFLFSxs0axrDox3TlI7b23vaaw+vTAoepsKNiaGwImvv+95uQ2Mvm1tfyrRFVlheR5BAaU829rdKmCKemy8C5MbBIRhrNGeQ2IPpcY+2w8KwicNIvHmXwuA9noRE+8UPXqUKH0xG6gUfl4l4Rdlt7cFmR2rYKRFVik52ilqu3/XUh+Dq+DSJkgqJR/Vx7/cGSm0Le8YujzxdRHTrc1nGQHRxRX00PiTlN46OWhlCfbkDKdnYpewFrygaD1s1RwErFHXajLEBQyF4F1F2gI4VrjIyLi442RR1Y+aJCa8nrx4HnqbP7dV/TkFblx9E0gioL9WkUpqnxPXkGDURITrVUYVGgegGTJ/1CZNyIV+YNGuh9MYs1x2i8594bKwo4kq1yFNv4hYWh5UqirB01gZFWkcHaIOcN3cSo9ij+MEMR4Q2jICoCBgIEF5kB4dwHbN2jxmHzkaj1twKruREXFAZcLJ8x0+K3kYOpwy9tIcfUhsuzZTrxfaYYahIkZkHbeC6TFmEbIpT+9jz06Zblon1EUa1L6bO64qmUwnH9/xyCSDfU8fwTu+Ah2bNkCFEw==</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>148</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>150</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>152</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>154</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>156</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>158</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>160</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>162</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>164</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>166</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>168</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>172</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>178</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>206</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>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</pkc:PublicKeyValue>
		</pkc:PublicKey>
	</pkc:PublicKeys>
</pkc:ProductKeyConfiguration>
</tm:infoBin></tm:infoList></tm:infoTables></r:otherInfo></r:license></rg:licenseGroup>