|
Server : Apache/2.4.43 (Win64) OpenSSL/1.1.1g PHP/7.4.6 System : Windows NT USER-PC 6.1 build 7601 (Windows 7 Professional Edition Service Pack 1) AMD64 User : User ( 0) PHP Version : 7.4.6 Disable Function : NONE Directory : C:/Windows/SysWOW64/spp/tokens/pkeyconfig/ |
<?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="{06a4dd30-84b7-4fd2-b859-f1eddb0858f5}" 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>OVd+tLtGUXB0dD7G/eTxhnGcWqU=</DigestValue></Reference></SignedInfo><SignatureValue>tuuSIgMAbOSbXEDgQXfTcZpgfacWvYblZWAmx1bxiYvmbgloYkdObLxgDeRHNNdW44G1HaIweAJYjP94MC6m/QZi0QM9cDsIcwwaHhL4FvpsezoD8OMtaqyoU/rG5ET1UhmK1yaZ+jufK+t1XWyMNuOhsInCHyU9ZGQOGa7/0YeDL3fClSChY1PhYwUP7LtseqrhJixaIqi9ffEvdO5+p15B+74cl6sq9XkA+lS4sx6Hw8HKfKmZezMwIcUdSDZPvQFBQOLJwp1k10EbRKlVF53rusMhVCYJcbgA7PYT0oZYofKv7fxELTmT7qG8Rtajc3z2cvEZHh5tRJMDo/8rRA==</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:details><r:timeOfIssue>2010-11-02T17:57:13Z</r:timeOfIssue></r:details></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>{b793ff2d-9d80-407c-b521-85111c51028c}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>Enterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Enterprise Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</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>Enterprise;EnterpriseN;EnterpriseE;Professional;ProfessionalN;ProfessionalE</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>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>Enterprise;EnterpriseN;EnterpriseE;Professional;ProfessionalN;ProfessionalE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 All Volume Editions Volume:MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{358fb95b-0090-44fb-883a-75734e060c30}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>Enterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Enterprise OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8dffd6e4-0497-4c35-b7d7-e47cf464cf30}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>Enterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Enterprise Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ae2ee509-1b34-41c0-acb7-6d4650168915}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>Enterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Enterprise Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{07328a5d-8dee-4d3b-9974-8a6ad6ab6892}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>EnterpriseN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 EnterpriseN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{33eda5ad-ad65-4507-b585-abcac3cabae5}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>EnterpriseN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 EnterpriseN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f3ce0211-9843-4d7e-9e38-a55ae0cd3c33}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>EnterpriseN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 EnterpriseN Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1cb6d605-11b3-4e14-bb30-da91c8e3983a}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>EnterpriseN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 EnterpriseN Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:ActConfigId>
			<pkc:RefGroupId>192</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Basic OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:ActConfigId>
			<pkc:RefGroupId>190</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Basic OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Basic OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bde0d4a5-2f2a-4bff-9d75-4a497d2d0019}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Basic OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Basic Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6c7afc31-950c-4fa8-93ee-3e880aa97e5d}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Basic Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d63316d0-1b6c-48e5-8db9-32b4d83fc7a0}</pkc:ActConfigId>
			<pkc:RefGroupId>192</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home BasicN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0fa327c5-2ba7-4090-ade8-0ec3eeda3242}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home BasicN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{89cc87b2-d442-4c79-99b2-addc5abcf2a5}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home BasicN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d1b53b3d-38eb-46a7-9afa-47271d93aec4}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home BasicN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ca400347-52d3-45a2-a333-f7d4c33b6af5}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home BasicN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:ActConfigId>
			<pkc:RefGroupId>196</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Premium OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:ActConfigId>
			<pkc:RefGroupId>194</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Premium OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:ActConfigId>
			<pkc:RefGroupId>198</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Premium OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:ActConfigId>
			<pkc:RefGroupId>176</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Premium OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:ActConfigId>
			<pkc:RefGroupId>174</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Premium OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Premium OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d2c04e90-c3dd-4260-b0f3-f845f5d27d64}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Premium OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Premium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{3b965dfc-31d9-4903-886f-873a0382776c}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home Premium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{01039663-ab8e-4d11-ba6c-cb4dacb2d13e}</pkc:ActConfigId>
			<pkc:RefGroupId>194</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home PremiumN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2143d01a-961c-4d9e-9150-6b5de0011274}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home PremiumN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{05d94d71-4ba4-427c-98f2-0e058edfe9af}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home PremiumN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home PremiumN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b68cc682-9531-4b6c-bb5e-202c92a59946}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home PremiumN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4a8149bb-7d61-49f4-8822-82c7bf88d64b}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>OCUR</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 OCUR Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:ActConfigId>
			<pkc:RefGroupId>186</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Professional OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:ActConfigId>
			<pkc:RefGroupId>184</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Professional OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d8e04254-f9a5-4729-ae86-886de6aa907c}</pkc:ActConfigId>
			<pkc:RefGroupId>182</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Professional OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:ActConfigId>
			<pkc:RefGroupId>180</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Professional OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Professional OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{50e329f7-a5fa-46b2-85fd-f224e5da7764}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Professional OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Professional Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{770bc271-8dc1-467d-b574-73cbacbeccd1}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Professional Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b92e9980-b9d5-4821-9c94-140f632f6312}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Professional Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:ActConfigId>
			<pkc:RefGroupId>184</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{fc3d428b-656b-4129-8274-700966289991}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d932ba14-a8cd-4368-aa5a-90d6613afea7}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c63f22b5-fdaf-4488-aeac-cc19411d0243}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{54a09a0d-d57b-4c10-8b69-a842d6590ad5}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalN Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1d90c7cc-f3cc-4c2f-9650-7ac451fc73eb}</pkc:ActConfigId>
			<pkc:RefGroupId>190</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Starter OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d56863eb-6e59-4f2d-ae01-46322b5fba79}</pkc:ActConfigId>
			<pkc:RefGroupId>184</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Starter OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:ActConfigId>
			<pkc:RefGroupId>188</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Starter OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9dee7406-49c2-43f2-b479-09bc4d5c4399}</pkc:ActConfigId>
			<pkc:RefGroupId>194</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Starter OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Starter OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8be4a481-9b5c-4588-a5ec-5dad4b1f15da}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Starter OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{71c7c851-1863-4232-8ac2-cdd7f5e45dae}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Starter Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1c48e75a-71d5-4871-b6f2-bc407894445b}</pkc:ActConfigId>
			<pkc:RefGroupId>188</pkc:RefGroupId>
			<pkc:EditionId>StarterN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 StarterN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>StarterN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 StarterN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{56f31729-c7c2-46b1-88a9-b2ebde10a7b1}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>StarterN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 StarterN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{51ba3bd9-c1cd-42b5-ada3-22451bc151f4}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>StarterN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 StarterN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:ActConfigId>
			<pkc:RefGroupId>188</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Ultimate OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:ActConfigId>
			<pkc:RefGroupId>182</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Ultimate OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7cfd4696-69a9-4af7-af36-ff3d12b6b6c8}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Ultimate OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Ultimate Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a0cde89c-3304-4157-b61c-c8ad785d1fad}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Ultimate Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9b6938df-398f-407d-962f-d99b2e1d5d1b}</pkc:ActConfigId>
			<pkc:RefGroupId>188</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 UltimateN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:ActConfigId>
			<pkc:RefGroupId>182</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 UltimateN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b482b078-ed27-4750-9ce9-60da4f575c67}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 UltimateN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 UltimateN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{dca01e19-01f5-4ce1-98b1-35fb7a323806}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 UltimateN 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>Vista OCUR Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{07a012bd-c5b1-483a-a3ac-20da32d44dec}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>StarterE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 StarterE Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{18aa7613-98ff-4820-9b69-1f69105ebba8}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>UltimateE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 UltimateE Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{24371aee-296d-4398-940d-7612d0def8e2}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>StarterE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 StarterE OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{26cd687a-c069-49bd-adba-c622441a2d81}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 Home PremiumE OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2e5cfead-eb89-4b28-87ba-a85917b1b95a}</pkc:ActConfigId>
			<pkc:RefGroupId>188</pkc:RefGroupId>
			<pkc:EditionId>UltimateE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 UltimateE OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalE Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>StarterE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 StarterE OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{46bbed08-9c7b-48fc-a614-95250573f4ea}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>EnterpriseE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 EnterpriseE Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:ActConfigId>
			<pkc:RefGroupId>182</pkc:RefGroupId>
			<pkc:EditionId>UltimateE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 UltimateE OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>UltimateE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 UltimateE Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{524e0c34-73ce-4198-9878-a53951c6f6b1}</pkc:ActConfigId>
			<pkc:RefGroupId>198</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomePremiumE OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5757ccd7-4e7d-4723-a9a1-c5315263460d}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomeBasicE OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5a041529-fef8-4d07-b06f-b59b573b32d2}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalE Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{61944438-77f3-46d0-b434-0f340e01434c}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalE OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6841f362-8be0-4058-9c13-8f565ef1debb}</pkc:ActConfigId>
			<pkc:RefGroupId>190</pkc:RefGroupId>
			<pkc:EditionId>StarterE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 StarterE OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6eb02c88-98e6-4623-8edd-59fed8fb5b11}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>EnterpriseE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 EnterpriseE Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7438e626-0d47-4b81-83db-eeff76921fd7}</pkc:ActConfigId>
			<pkc:RefGroupId>188</pkc:RefGroupId>
			<pkc:EditionId>StarterE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 StarterE OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{78c95341-4f01-4e52-808a-e2f90fc56f71}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalE Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7f62a589-fc1c-4fc7-817b-90d565727ddb}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomeBasicE Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{82866d0f-354b-4dfc-bc75-8b925ba514db}</pkc:ActConfigId>
			<pkc:RefGroupId>184</pkc:RefGroupId>
			<pkc:EditionId>StarterE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 StarterE OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{88e1193d-e891-41c4-b517-3a305a013695}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomeBasicE Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomePremiumE Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{903e621f-f23c-4ba0-b8de-40c3affff57d}</pkc:ActConfigId>
			<pkc:RefGroupId>172</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomePremiumE Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ab761468-3ae8-4696-b762-e77f674ac0c1}</pkc:ActConfigId>
			<pkc:RefGroupId>180</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalE OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b2153262-12db-49d1-969a-9ca6b54cf93c}</pkc:ActConfigId>
			<pkc:RefGroupId>184</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalE OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bbbb2a8a-aaee-4f56-a237-1e2cdc8039d6}</pkc:ActConfigId>
			<pkc:RefGroupId>174</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomePremiumE OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bd61de01-6b6a-4756-8103-2978e8c5c980}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>UltimateE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 UltimateE OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{cab94894-574c-4ace-8b83-c89d121fda53}</pkc:ActConfigId>
			<pkc:RefGroupId>196</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomePremiumE OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d880a111-2ba6-4838-9553-3da0f31d8eb5}</pkc:ActConfigId>
			<pkc:RefGroupId>194</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomePremiumE OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f1fe0f5e-7a50-4853-984d-9abd2dc05b6e}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomeBasicE OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f7bc3d0d-ca9d-42ae-83e1-4fa46e0f4979}</pkc:ActConfigId>
			<pkc:RefGroupId>176</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomePremiumE OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f91bf45e-af5f-495a-8cab-5578e1c44da1}</pkc:ActConfigId>
			<pkc:RefGroupId>192</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomeBasicE OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0a6eaa31-2181-4266-b7b3-6b6a0dd0af8a}</pkc:ActConfigId>
			<pkc:RefGroupId>182</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalE OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e16f11e3-ba84-48cb-af72-a7a0deafe0e8}</pkc:ActConfigId>
			<pkc:RefGroupId>170</pkc:RefGroupId>
			<pkc:EditionId>EnterpriseE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 EnterpriseE Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5f56dc78-0853-4465-81ec-88891d9624b0}</pkc:ActConfigId>
			<pkc:RefGroupId>186</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalE OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5fa5bf1b-c208-491c-846f-4faa3c98767a}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 HomePremiumE OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0af59e82-53c5-4564-87cd-ddad65d5509f}</pkc:ActConfigId>
			<pkc:RefGroupId>178</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalE</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 ProfessionalE OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{017935c3-4ed2-427a-aedf-55129321a285}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 ProfessionalN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{01df6f02-29d6-487d-b3a1-95dcf42c10e6}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 ProfessionalN Retail:TB:Sub</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Sub</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{05bce0e7-2ed5-4876-afb3-5844ffc90f40}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 ProfessionalN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0e88bdae-f9a7-4e9d-9afe-9398459c4385}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomeBasic Retail:WAUx</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{114e0c1a-1aa5-47a2-8d38-8eb3b51cdbb6}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>StarterN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 StarterN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{153ebbcf-07f0-4fbc-b361-3b4b50f48617}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomePremiumN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2e822a96-f12b-4f9a-a638-6c567060d877}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>StarterN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 StarterN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{373a038e-d9b7-4fcb-9788-1bb41b96e8b0}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomeBasicN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{388fee2d-04ef-4825-b442-edb6295da3d8}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomePremiumN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{3d30924b-bf77-489c-afbe-ecdba5988161}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 UltimateN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Ultimate Retail:WAUx</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{46d97ac9-1eab-4f29-ae77-f69d6fe70bed}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>OCUR</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 OCUR Ultimate Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4af12fad-92f3-4f32-81f7-ff44c1b6474b}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 UltimateN Retail:TB:Sub</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Sub</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4beb680a-2f31-471c-a7fe-7a979ccf3d63}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomeBasicN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4de78642-0f7f-4b61-9392-8add86d70ae8}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Professional Retail:TB:Sub</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Sub</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4f00134f-b514-4626-a74b-a8ec7c8dfe92}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Enterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Enterprise Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{57a232fe-0931-48fe-9389-e4586967c661}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Ultimate OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{57c2bada-4fa1-410e-b9a7-92695078d46b}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomeBasic OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5a79ecd8-d33f-406c-a619-7785899b5d59}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Professional OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5e35dc43-389b-47c5-b889-2088b06738cb}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomePremium OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{628d8532-f53a-4861-a786-dd63ed6ac5b4}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 UltimateN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{69ffd12a-074f-4ab0-b654-99a2e278faeb}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Starter OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6e358ec7-1224-432e-aed8-955fb11a08bd}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>StarterN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 StarterN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7d39b06e-771b-41b7-9228-fe5fa91aa7a1}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomeBasicN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8b51f6c7-0b38-4487-83ff-bd3289c6292d}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Starter Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8bf50607-c8ce-4402-aaf8-92d2d63ab6c1}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 UltimateN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8c17fbea-5586-4807-aafe-0d8181c36ff5}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>StarterN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 StarterN OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8d84e167-c8ad-469f-a2b2-00b154668f70}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Starter OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8ec16e01-e86f-415f-b333-1819f4145294}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Ultimate Retail:TB:Sub</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Sub</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 ProfessionalN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{92f9d22a-65f5-49a7-90fe-06491b4fc379}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Professional;ProfessionalN;Enterprise;EnterpriseN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Professional;ProfessionalN;Enterprise;EnterpriseN Volume:MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{96b172b7-0521-413b-820b-4beb463bdac9}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomePremiumN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{974740ce-f7de-4f95-8404-01b53efdcb66}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomeBasic OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Professional Retail:WAUx</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a63275f4-530c-48a7-b0d3-4f00d688d151}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomePremium OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ac605e70-4f18-45ca-a99c-190e4b047cd1}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Starter</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Starter OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ada98380-2f0c-4a45-893d-d6b124e7f31b}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 UltimateN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b20418a8-a3d4-4296-8cc0-e7ed07267a04}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 ProfessionalN OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b2c4b9f6-3ee6-4a2a-a361-64ad3b61ded5}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Ultimate OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b8a4bb91-69b1-460d-93f8-40e0670af04a}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomePremium OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{baebe09a-840e-452f-9e39-df34c8d38adc}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomeBasic OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bba42084-cacd-4ad4-b606-9f3d6c93b2c5}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Ultimate OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bc95c3ad-bb46-4b09-b130-51665ef87e3b}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>ProfessionalN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 ProfessionalN Retail:WAUx</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Professional Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c33001fc-5e9c-4f27-8c05-e0154adb0db4}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Professional OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c619d61c-c2f2-40c3-ab3f-c5924314b0f3}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Ultimate</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Ultimate Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{cf3c5b35-35ff-4c95-9bbd-a188e47ad14c}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Professional</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Professional OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{cff07cac-7534-4cc3-b3f3-99e1a0aa3c20}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>Enterprise;EnterpriseN;Professional;ProfessionalN </pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 Enterprise  Volume:MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d24a2d0a-9cd3-4232-833f-ae3655b88425}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>EnterpriseN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 EnterpriseN Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e5d2c2c7-9140-4fe9-9d3d-c0b106739e34}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomeBasic</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomeBasic Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e68b141f-4dfa-4387-b3b7-e65c4889216e}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomePremium Retail:WAUx</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e72d9987-5c60-45b2-a093-87392e88107e}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomePremiumN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ecde36bb-22f8-481b-93ab-d3fc1204f470}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomeBasicN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomeBasicN OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ee4e1629-bcdc-4b42-a68f-b92e135f78d7}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomePremium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f294addd-20dd-46e6-bce7-01a15ef45e99}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>UltimateN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 UltimateN Retail:WAUx</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{fddde785-e27d-4c62-8ec0-ed78e58d424f}</pkc:ActConfigId>
			<pkc:RefGroupId>212</pkc:RefGroupId>
			<pkc:EditionId>HomePremiumN</pkc:EditionId>
			<pkc:ProductDescription>Windows 7 SP1 HomePremiumN Retail:WAUx</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{31f395ce-fc28-4a33-b676-81b109902ee8}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessMessaging</pkc:EditionId>
			<pkc:ProductDescription>Win 7 Server Medium Business Messaging retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{31ac603c-0483-4db9-8006-1831517ae142}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessSecurity</pkc:EditionId>
			<pkc:ProductDescription>Win 7 Server Medium Business Security retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{3c2baabd-257f-4f5c-9c3e-e3112a1c939e}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSolutionsPremium</pkc:EditionId>
			<pkc:ProductDescription>ServerSolutionsPremium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{fa0d7bfa-140f-4ca1-ae5b-e4a666549beb}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerForSBSolutionsEM</pkc:EditionId>
			<pkc:ProductDescription>ServerforSBSolutionsEM Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f4f5e8f4-7a61-40ce-8832-630a6eba038d}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessMessaging</pkc:EditionId>
			<pkc:ProductDescription>ServerMBS Messaging</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a1d8e513-d10f-479e-8963-b9f82c1bfa36}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerMediumBusinessSecurity</pkc:EditionId>
			<pkc:ProductDescription>ServerMBS Security</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b7b1d450-fb87-4054-84ee-5db525088124}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSBV</pkc:EditionId>
			<pkc:ProductDescription>ServerWinSBV Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ae486542-39df-4ec8-8483-ac502f5eed7f}</pkc:ActConfigId>
			<pkc:RefGroupId>140</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSPremium</pkc:EditionId>
			<pkc:ProductDescription>Win 7 Server SBS Premium retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{de57e6db-74a6-4de2-9b45-6305085bd104}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSPremium</pkc:EditionId>
			<pkc:ProductDescription>ServerSBSPremium Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{93d59c57-b6e1-4c3d-8caf-204cd102a69a}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerForSBSolutions</pkc:EditionId>
			<pkc:ProductDescription>ServerforSBSolutions Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{bdbaaa16-4622-4547-828b-abff92a18218}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSolutionEM</pkc:EditionId>
			<pkc:ProductDescription>ServerSolutionEM Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{005cf8e0-d40e-458f-8982-9ea5a37c080c}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSB</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Server for Windows Essential Server Solutions (WinWES) OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{039998e3-3ef5-4adf-b758-d25fa0128ff4}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Standard Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{07acd797-a4c1-49d2-84a8-c08a14fb83b2}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerHomeStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server 2008 R2 Essentials ServerHomeStandard OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0957c488-4993-4b07-a2a4-0097b2f8c37d}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Standard ServerSBSStandard OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0cbae191-195f-43b4-b53c-368b61652b74}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWinFoundation</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Foundation Retail (MUI locked to CH)</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0dbe8d16-b9e1-435f-9fc8-5e011438eb4c}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSolution</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Essentials ServerSolution OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0e0d125d-173f-4752-8c1b-ced62118977f}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWinFoundation</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Foundation OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1393c801-f389-4c5b-bb4e-bd7d3478ea60}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Web retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{161135e2-8a99-42ee-912c-4161e4056d7c}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialManagement</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Cascades" Retail TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{16cc978a-cf08-44f4-b02b-dfeb8bdacac2}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerHomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server 2011 SERVERHOMEPREMIUM Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{171ad3f3-e1f3-41e1-9d6f-0a0b9b6aba3f}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerSolution</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Essentials ServerSolution Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1a07362f-15ee-4af8-a374-75157d6b6fbb}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialManagementSvc</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Klamath" OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1bc49a17-9894-49c8-ba63-1b52852556a3}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Web Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1d63ae00-7733-4e46-b0d0-ae0ab81d7638}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Datacenter OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{1dbe6f30-a618-4909-ba6e-aa5a66f1e96a}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialManagement</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Cascades" OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{20fd891c-4d02-425c-9840-3f762d993737}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialAdditional</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Cascades" OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{23af83d3-8520-491e-88fb-3f6d7ab3783a}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerHPC</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Compute Cluster (HPC) OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{280f12e2-5412-4482-9004-b4c90a66e829}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Web OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{28e73646-24dc-4222-bf00-de8ded35ce13}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>ServerSolution</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Essentials ServerSolution OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{29b15bf5-8d7f-47e2-a0a7-ce1061254a0f}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSolution</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Essentials ServerSolution Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{29fb0edc-c2fd-413c-a72e-9fe36075c9de}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialManagementSvc</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Klamath" Retail TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2b1690e6-1066-4b17-883f-4f759db1a7dd}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWinFoundation</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Foundation OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2b756fa4-e8d3-4eac-8722-07b044e7b6b1}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Standard ServerSBSStandard OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</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</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{30e54fa6-ae6a-4523-b264-d7978e977d96}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Enterprise IA64 retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialManagement</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Cascades" Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Standard ServerSBSStandard Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{31d69fd1-8967-417e-9464-59d6ca58190f}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerHomeStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server 2008 R2 Essentials ServerHomeStandard OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{3ff36ff8-6220-484c-9fb0-165ac44e0a91}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerHomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server 2011 SERVERHOMEPREMIUM OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{402ffdaa-6813-424a-b07b-c31f8d24054e}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWinFoundation</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Foundation Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4539dd83-aa84-4cb8-aa73-bc89daf53a3a}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSB</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Server for Windows Essential Server Solutions (WinWES) Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter;ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 DC and IA64 Volume:MAK (MAK_C)</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4bcc8879-e699-4159-a810-f829566662ca}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Enterprise Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4ca3ecfc-432d-43f7-91c5-4d0226a07f41}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialAdditionalSvc</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Klamath" OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{4d3ae49a-0bea-4cea-9a9f-a6fbdf699b28}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Web OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEmbeddedSolution;ServerHPC;ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Web and CC Volume:MAK (MAK_A)</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{511bf083-7a59-4f5c-b41e-81c97e039fe9}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEmbeddedSolution</pkc:EditionId>
			<pkc:ProductDescription>Multipoint Server Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{5662c706-f571-4c83-9649-3916a56a2b74}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSolution</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 for Small Business Server Essentials  ServerSolution OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{56cd5000-40b0-4e44-97a7-245191e7dfe3}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEmbeddedSolution</pkc:EditionId>
			<pkc:ProductDescription>ServerEmbeddedSolution Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{620e2b3d-09e7-42fd-802a-17a13652fe7a}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Enterprise Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{63192b0b-20c9-49dc-9936-0a33d67f8c3a}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Enterprise IA64 Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{66c86c35-a315-468a-8dfd-b0a36f9d3584}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialManagement</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Cascades" OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{683b8d26-5471-4212-82fb-8148427ca281}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerHPC</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Compute Cluster (HPC) OEM:COA</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:COA</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{68531fb9-5511-4989-97be-d11a0f55633f}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Standard Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard;ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Std and Ent Volume:MAK (MAK_B)</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6b43d071-dbe7-472d-8c0f-d33295fcddd6}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialAdditional;ServerEssentialAdditionalSvc;ServerEssentialManagement;ServerEssentialManagementSvc</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server (all editions EBS) MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6c47797a-fdba-4ac8-b402-d4b937bb7edb}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerHomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server 2011 SERVERHOMEPREMIUM OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Standard OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialManagementSvc</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Klamath" Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialAdditionalSvc</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Klamath" Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7482e61b-c589-4b7f-8ecc-46d455ac3b87}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Datacenter Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{74e20158-a356-46aa-bb8a-fc200f20a9c2}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSolution</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 for Small Business Server Essentials  ServerSolution OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{780ac8a3-9312-4077-98a2-dd957cf8b7dc}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialAdditional</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Cascades" Retail TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{82f26cca-d9f0-4259-be0f-7b86c382eec7}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialAdditionalSvc</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Klamath" Retail TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{855d35f4-a334-46e7-b7d7-23fc1a22be65}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerHPC</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Compute Cluster (HPC) retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{862e432e-a461-42cf-b5dd-abc373943a4a}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEmbeddedSolution</pkc:EditionId>
			<pkc:ProductDescription>Multipoint Server OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8a26851c-1c7e-48d3-a687-fbca9b9ac16b}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Enterprise IA64 Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8fcad604-c17b-4620-b073-470555f273d5}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialAdditionalSvc</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Klamath" OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</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>ServerDatacenter;ServerEmbeddedSolution;ServerEnterprise;ServerEnterpriseIA64;ServerHPC;ServerStandard;ServerWeb</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>{9534497b-0bba-4fae-bf3d-1a7597eeb188}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialAdditional</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Cascades" OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9a159de8-d114-41d7-a5bf-d3574edb42fa}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Standard OEM:NONSLP (MUI locked to CH)</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9a7ceac4-1f33-4e4b-a866-34f00b8a2438}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialManagementSvc</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Klamath" OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9bc8998c-0d54-4d44-b299-fb778ec57230}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSolution</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Essentials ServerSolution OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a2855032-266b-45e6-8739-311652feeb28}</pkc:ActConfigId>
			<pkc:RefGroupId>156</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Standard ServerSBSStandard OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a60c85a9-7eff-4690-8aa1-010ddf5d38f0}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Standard OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Standard ServerSBSStandard Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a78b8bd9-8017-4df5-b86a-09f756affa7c}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Web Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b0830b97-08a6-4370-b4da-2d136616827e}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSB</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Server for Windows Essential Server Solutions (WinWES) Volume:MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Enterprise retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b41df512-845d-4384-a2d7-ace3f778bff5}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Datacenter OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b4d69df9-cdc5-48aa-8b88-dcadf9b558ba}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerHPC</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Compute Cluster (HPC) OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{b5f35387-daeb-4901-a253-c6001f14fda7}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Standard ServerSBSStandard Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ba480d59-94fc-46de-81f7-baf821e43488}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerWinSB</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Server for Windows Essential Server Solutions (WinWES) OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c0c97b05-e71a-4fe4-b234-4165f96250f6}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Datacenter Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c74417bd-f079-42e5-91f0-8f08ec052cba}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Enterprise IA64 OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c74dc7f6-ea35-4bd7-9776-333ab5dddae6}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Enterprise OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c837408d-3762-4dea-a4d7-6dba48f6c305}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 RC Standard OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerSolution</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 Essentials ServerSolution Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</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>ServerEmbeddedSolution;ServerEnterprise;ServerHPC;ServerStandard;ServerWeb</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>{cda18cf3-c196-46ad-b289-60c072869994}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerHPC</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Compute Cluster (HPC) Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d26969d7-e588-4ec8-9e52-911cbe0f744a}</pkc:ActConfigId>
			<pkc:RefGroupId>164</pkc:RefGroupId>
			<pkc:EditionId>ServerHomePremium</pkc:EditionId>
			<pkc:ProductDescription>Windows Home Server 2011 SERVERHOMEPREMIUM Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{da71774d-b2c9-4c42-bb7b-a66365d5abb2}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Standard Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{db1b36e0-f543-4f4d-8ce6-814fa5dea00d}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEmbeddedSolution</pkc:EditionId>
			<pkc:ProductDescription>Multipoint Server OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e1808e9b-b84c-4b3e-a351-d9820702720c}</pkc:ActConfigId>
			<pkc:RefGroupId>152</pkc:RefGroupId>
			<pkc:EditionId>ServerSolution;ServerSBSStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Small Business Server 2011 ServerSolution, ServerSBSStandard Volume:MAK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e1f0bb5b-2421-4b7c-81a1-03643106421d}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Datacenter retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e267bacf-b3bf-45e5-a2ba-057855b3c59f}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerHomeStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Storage Server 2008 R2 Essentials ServerHomeStandard Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e3913f37-c311-4a0d-b603-ad3d61be9e39}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWinFoundation</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Foundation OEM:NONSLP (MUI locked to CH)</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:ActConfigId>
			<pkc:RefGroupId>150</pkc:RefGroupId>
			<pkc:EditionId>ServerEssentialAdditional</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Essential Business Server "Cascades" Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{ea36520d-fbfe-4042-acd8-fe926781b615}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Enterprise OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{eea69412-4907-4185-8322-2ce1be6912a3}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Enterprise IA64 OEM:SLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:SLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{f14c8ee3-560d-441e-aee1-325c2e9ae74a}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Standard Retail (MUI locked to CH)</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</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>ServerEmbeddedSolution;ServerHPC;ServerWeb</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>{f772515c-0e87-48d5-a676-e6962c3e1195}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerEmbeddedSolution</pkc:EditionId>
			<pkc:ProductDescription>Multipoint Server Volume:GVLK</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:GVLK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{fe0e7d01-192a-47c1-858e-95df10baa491}</pkc:ActConfigId>
			<pkc:RefGroupId>168</pkc:RefGroupId>
			<pkc:EditionId>ServerWinFoundation</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 Foundation OEM:NONSLP</pkc:ProductDescription>
			<pkc:ProductKeyType>OEM:NONSLP</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{7a68f0c7-9dee-433d-b1da-e9779be95ab3}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerWinFoundation</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 SP1 Foundation Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{8402d835-3b9f-4cba-81f5-22922afa7366}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 SP1 ServerDatacenter Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 SP1 ServerDatacenter Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{9c135606-f8d0-4b88-8bca-78403696e1ef}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerDatacenter;ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 SP1 DC and IA64 Volume:MAK (MAK_C)</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 SP1 ServerEnterprise Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{2d727362-1f80-4a74-9e4d-e7c79826e659}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 SP1 ServerEnterprise Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{46c2cc67-6a50-4a66-8048-9334f4a3914e}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerEnterpriseIA64</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 SP1 ServerEnterpriseIA64 Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 SP1 ServerStandard Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{a7dad4b1-8065-4576-9e61-2fd025fe16cc}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 SP1 ServerStandard Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{c60b048b-8071-4532-8398-f15f4c981861}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerStandard;ServerEnterprise</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 SP1 Std and Ent Volume:MAK (MAK_B)</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{01fd368f-a172-45d7-b147-273aa1aba00b}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 SP1 ServerWeb Retail:TB:Eval</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail:TB:Eval</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Windows Server 2008 R2 SP1 ServerWeb Retail</pkc:ProductDescription>
			<pkc:ProductKeyType>Retail</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration><pkc:Configuration>
			<pkc:ActConfigId>{0eee96cb-116a-4109-852a-e3797b6c4260}</pkc:ActConfigId>
			<pkc:RefGroupId>208</pkc:RefGroupId>
			<pkc:EditionId>ServerEmbeddedSolution;ServerHPC;ServerWeb</pkc:EditionId>
			<pkc:ProductDescription>Server 2008 R2 SP1 Web and CC Volume:MAK (MAK_A)</pkc:ProductDescription>
			<pkc:ProductKeyType>Volume:MAK</pkc:ProductKeyType>
			<pkc:IsRandomized>false</pkc:IsRandomized>
		</pkc:Configuration>
	        </pkc:Configurations>
	        <pkc:KeyRanges>
		        <pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>3000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>185999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>187000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</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>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</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>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</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>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</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>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</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>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</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>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</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>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e017a8a-f3f9-4167-b1bd-ba3e236a4d8f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>768999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>185999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>187000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</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>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</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>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</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>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</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>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</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>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</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>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>478999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37341</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>709599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>185999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>187000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</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>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</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>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</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>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</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>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</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>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</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>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37342</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>477999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>185999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>187000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</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>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</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>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</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>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</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>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</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>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</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>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37303</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>477999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37343</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37343</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37343</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>185999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37343</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>187000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37343</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>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37343</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>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37343</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>361000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37343</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>387999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d90c7cc-f3cc-4c2f-9650-7ac451fc73eb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37344</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>478000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d90c7cc-f3cc-4c2f-9650-7ac451fc73eb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37344</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d90c7cc-f3cc-4c2f-9650-7ac451fc73eb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37344</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d90c7cc-f3cc-4c2f-9650-7ac451fc73eb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37344</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d90c7cc-f3cc-4c2f-9650-7ac451fc73eb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37344</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>892999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37345</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>388000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37345</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>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37345</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37345</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>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37345</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>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37345</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37345</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37345</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37345</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37345</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>812999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37304</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37304</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37304</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>185999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37304</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>187000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37304</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>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37304</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>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37304</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>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37304</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>387999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37346</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>710000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37346</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>988399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37305</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37305</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37305</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37305</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>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37305</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>330999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37347</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37347</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37347</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>185999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37347</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>187000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37348</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>478000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37348</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37348</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37348</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37348</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>759999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37349</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>734000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37349</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>911999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37350</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>331000000</pkc:Start>
			<pkc:End>334599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37350</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>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37350</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37350</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>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37350</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>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37350</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37350</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>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37350</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>496999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d56863eb-6e59-4f2d-ae01-46322b5fba79}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37351</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>497000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d56863eb-6e59-4f2d-ae01-46322b5fba79}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37351</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>581000000</pkc:Start>
			<pkc:End>617999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37352</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>383000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37352</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>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37352</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37352</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>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37352</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>512999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37306</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>256000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37306</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>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37306</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>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37306</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37306</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>382999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37353</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>618000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37353</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37353</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37353</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>726000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37353</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>791999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d56863eb-6e59-4f2d-ae01-46322b5fba79}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37307</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>792000000</pkc:Start>
			<pkc:End>884999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37308</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>760000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37308</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>842999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</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>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</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>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</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>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</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>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</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>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</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>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37354</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>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37355</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>412000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37355</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>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37355</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37355</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>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37355</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>505000000</pkc:Start>
			<pkc:End>541999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37356</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37356</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37356</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37356</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>200999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37356</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>305999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37357</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>306000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37357</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>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37357</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37357</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>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37357</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>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37357</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37357</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>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37357</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>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37358</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>542000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37358</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>595999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d8e04254-f9a5-4729-ae86-886de6aa907c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37359</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d8e04254-f9a5-4729-ae86-886de6aa907c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37359</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d8e04254-f9a5-4729-ae86-886de6aa907c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37359</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d8e04254-f9a5-4729-ae86-886de6aa907c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37359</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>{d8e04254-f9a5-4729-ae86-886de6aa907c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37359</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>{d8e04254-f9a5-4729-ae86-886de6aa907c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37359</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d8e04254-f9a5-4729-ae86-886de6aa907c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37359</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>381000000</pkc:Start>
			<pkc:End>411999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37360</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37360</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37360</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37360</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>229999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37361</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>230000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37361</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>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37361</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>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37361</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37361</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>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37361</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>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37361</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>438999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37362</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>439000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37362</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>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37362</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>507000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37362</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>567999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37363</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>568000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37363</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37363</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37363</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>728999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37364</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>547000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37364</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37364</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37364</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37364</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37364</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>836999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37365</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>837000000</pkc:Start>
			<pkc:End>976999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37366</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>729000000</pkc:Start>
			<pkc:End>770999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37366</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>791999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37367</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>613000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37367</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37367</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37367</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>733999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37368</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>618000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37368</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37368</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37368</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37368</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>821999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37369</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>792000000</pkc:Start>
			<pkc:End>851999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37370</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>852000000</pkc:Start>
			<pkc:End>911999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37371</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37371</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37371</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>137999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37372</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>138000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37372</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>249999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37373</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>439000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37373</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>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37373</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>496999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37373</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928000000</pkc:Start>
			<pkc:End>931999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7cfd4696-69a9-4af7-af36-ff3d12b6b6c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37374</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926600000</pkc:Start>
			<pkc:End>926674999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b482b078-ed27-4750-9ce9-60da4f575c67}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37376</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927730000</pkc:Start>
			<pkc:End>927734999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{50e329f7-a5fa-46b2-85fd-f224e5da7764}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37377</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926700000</pkc:Start>
			<pkc:End>926774849</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d932ba14-a8cd-4368-aa5a-90d6613afea7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37378</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927735000</pkc:Start>
			<pkc:End>927739999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d2c04e90-c3dd-4260-b0f3-f845f5d27d64}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37379</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926800000</pkc:Start>
			<pkc:End>926874999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{05d94d71-4ba4-427c-98f2-0e058edfe9af}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37380</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927740000</pkc:Start>
			<pkc:End>927744999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bde0d4a5-2f2a-4bff-9d75-4a497d2d0019}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37381</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926900000</pkc:Start>
			<pkc:End>926974999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89cc87b2-d442-4c79-99b2-addc5abcf2a5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37382</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927745000</pkc:Start>
			<pkc:End>927749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8be4a481-9b5c-4588-a5ec-5dad4b1f15da}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38980</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927000000</pkc:Start>
			<pkc:End>927099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56f31729-c7c2-46b1-88a9-b2ebde10a7b1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38982</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927750000</pkc:Start>
			<pkc:End>927754999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38984</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>734000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38984</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>796999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39778</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>797000000</pkc:Start>
			<pkc:End>835749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38988</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847000000</pkc:Start>
			<pkc:End>886999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38990</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>887000000</pkc:Start>
			<pkc:End>926999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38992</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>912000000</pkc:Start>
			<pkc:End>941999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fc3d428b-656b-4129-8274-700966289991}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38994</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>608000000</pkc:Start>
			<pkc:End>627999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38996</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>15999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38998</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>822000000</pkc:Start>
			<pkc:End>911999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39001</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>901999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39003</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39003</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942000000</pkc:Start>
			<pkc:End>993999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39005</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39005</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>977000000</pkc:Start>
			<pkc:End>989999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39007</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>897000000</pkc:Start>
			<pkc:End>899999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39008</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>900000000</pkc:Start>
			<pkc:End>902999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39010</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>15999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39012</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>903000000</pkc:Start>
			<pkc:End>905999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39014</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>966000000</pkc:Start>
			<pkc:End>968999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39016</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>969000000</pkc:Start>
			<pkc:End>971999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39018</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>681999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39020</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>972000000</pkc:Start>
			<pkc:End>974999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39022</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927000000</pkc:Start>
			<pkc:End>956999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39024</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>957000000</pkc:Start>
			<pkc:End>976999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39026</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>15999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39028</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>16000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39028</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942000000</pkc:Start>
			<pkc:End>950999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39030</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>776000000</pkc:Start>
			<pkc:End>783499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39032</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>954000000</pkc:Start>
			<pkc:End>963999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39034</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>964000000</pkc:Start>
			<pkc:End>973999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2143d01a-961c-4d9e-9150-6b5de0011274}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39036</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>243000000</pkc:Start>
			<pkc:End>267999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39038</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>176000000</pkc:Start>
			<pkc:End>190999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39040</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>{9f83d90f-a151-4665-ae69-30b3f63ec659}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39040</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>680999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39042</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>16000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39042</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>977000000</pkc:Start>
			<pkc:End>983999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39044</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>974000000</pkc:Start>
			<pkc:End>983999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39046</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>984000000</pkc:Start>
			<pkc:End>989999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39048</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>990000000</pkc:Start>
			<pkc:End>994699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fc3d428b-656b-4129-8274-700966289991}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39050</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>819000000</pkc:Start>
			<pkc:End>824999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fa327c5-2ba7-4090-ade8-0ec3eeda3242}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39052</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927100000</pkc:Start>
			<pkc:End>927199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d56863eb-6e59-4f2d-ae01-46322b5fba79}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37309</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>892000000</pkc:Start>
			<pkc:End>971999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a7d5d8a-92af-4e6a-af4b-8fddaec800e5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39054</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>813000000</pkc:Start>
			<pkc:End>872999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39056</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>513000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39056</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>573999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9dee7406-49c2-43f2-b479-09bc4d5c4399}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37310</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>893000000</pkc:Start>
			<pkc:End>967999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39756</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>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39756</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>843000000</pkc:Start>
			<pkc:End>902999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d90c7cc-f3cc-4c2f-9650-7ac451fc73eb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39060</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>893000000</pkc:Start>
			<pkc:End>952999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d90c7cc-f3cc-4c2f-9650-7ac451fc73eb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39060</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>983000000</pkc:Start>
			<pkc:End>984999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39062</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>715000000</pkc:Start>
			<pkc:End>774999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37311</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>594000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37311</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37311</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37311</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>714999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39064</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>775000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39064</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>837999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39066</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>786000000</pkc:Start>
			<pkc:End>788999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39066</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>838000000</pkc:Start>
			<pkc:End>874999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01039663-ab8e-4d11-ba6c-cb4dacb2d13e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39068</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01039663-ab8e-4d11-ba6c-cb4dacb2d13e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39068</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>696999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01039663-ab8e-4d11-ba6c-cb4dacb2d13e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39068</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>988000000</pkc:Start>
			<pkc:End>999999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37312</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>903000000</pkc:Start>
			<pkc:End>952999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37313</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>912000000</pkc:Start>
			<pkc:End>951999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37314</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>953000000</pkc:Start>
			<pkc:End>992999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39070</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>952000000</pkc:Start>
			<pkc:End>981999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39070</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>998001000</pkc:Start>
			<pkc:End>998600999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39072</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39072</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>365000000</pkc:Start>
			<pkc:End>367999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39072</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>676999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37315</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>953000000</pkc:Start>
			<pkc:End>982999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>111000000</pkc:Start>
			<pkc:End>111199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-71453</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>111200000</pkc:Start>
			<pkc:End>111219999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>111220000</pkc:Start>
			<pkc:End>111999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>197000000</pkc:Start>
			<pkc:End>198999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>365000000</pkc:Start>
			<pkc:End>367999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425000000</pkc:Start>
			<pkc:End>425999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436000000</pkc:Start>
			<pkc:End>436999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>460000000</pkc:Start>
			<pkc:End>460999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>470000000</pkc:Start>
			<pkc:End>476999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</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>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>630000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>641000000</pkc:Start>
			<pkc:End>647999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37316</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37316</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337000000</pkc:Start>
			<pkc:End>338999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37316</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>676999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39076</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>677000000</pkc:Start>
			<pkc:End>699999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39076</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>786000000</pkc:Start>
			<pkc:End>788999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39076</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>992000000</pkc:Start>
			<pkc:End>995999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39078</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>972000000</pkc:Start>
			<pkc:End>991999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01039663-ab8e-4d11-ba6c-cb4dacb2d13e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39080</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>968000000</pkc:Start>
			<pkc:End>987999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1c48e75a-71d5-4871-b6f2-bc407894445b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39082</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>888000000</pkc:Start>
			<pkc:End>907999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37317</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37317</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>908000000</pkc:Start>
			<pkc:End>909999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37318</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37318</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>993000000</pkc:Start>
			<pkc:End>994999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37319</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>910000000</pkc:Start>
			<pkc:End>929999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39084</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>930000000</pkc:Start>
			<pkc:End>944999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39757</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>197000000</pkc:Start>
			<pkc:End>198999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39757</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337000000</pkc:Start>
			<pkc:End>338999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39757</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>365000000</pkc:Start>
			<pkc:End>367999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39757</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425000000</pkc:Start>
			<pkc:End>425999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39757</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436000000</pkc:Start>
			<pkc:End>436999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39757</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>460000000</pkc:Start>
			<pkc:End>460999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39757</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>470000000</pkc:Start>
			<pkc:End>474999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39758</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>945000000</pkc:Start>
			<pkc:End>959999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9821c9cb-288b-4c98-96f9-adc75a15eaf4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39090</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>677000000</pkc:Start>
			<pkc:End>691999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39092</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>960000000</pkc:Start>
			<pkc:End>974999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37320</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>975000000</pkc:Start>
			<pkc:End>989999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39094</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337000000</pkc:Start>
			<pkc:End>338999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39094</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425000000</pkc:Start>
			<pkc:End>425999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39094</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436000000</pkc:Start>
			<pkc:End>436999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39094</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>460000000</pkc:Start>
			<pkc:End>460999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39094</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>470000000</pkc:Start>
			<pkc:End>476999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9b6938df-398f-407d-962f-d99b2e1d5d1b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39096</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>{9b6938df-398f-407d-962f-d99b2e1d5d1b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39096</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>630000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9b6938df-398f-407d-962f-d99b2e1d5d1b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39096</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>641000000</pkc:Start>
			<pkc:End>648999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39098</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>990000000</pkc:Start>
			<pkc:End>999999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37321</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>475000000</pkc:Start>
			<pkc:End>476999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37321</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>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37321</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>630000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37321</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>641000000</pkc:Start>
			<pkc:End>641999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37322</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>3000000</pkc:Start>
			<pkc:End>12999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39100</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>13000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39100</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>982000000</pkc:Start>
			<pkc:End>985999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39102</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>642000000</pkc:Start>
			<pkc:End>651999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39104</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>986000000</pkc:Start>
			<pkc:End>995999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1c48e75a-71d5-4871-b6f2-bc407894445b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39106</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>649000000</pkc:Start>
			<pkc:End>654999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39108</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>648000000</pkc:Start>
			<pkc:End>653999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37323</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>654000000</pkc:Start>
			<pkc:End>658999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39110</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>885000000</pkc:Start>
			<pkc:End>889999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01039663-ab8e-4d11-ba6c-cb4dacb2d13e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39112</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>697000000</pkc:Start>
			<pkc:End>699999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01039663-ab8e-4d11-ba6c-cb4dacb2d13e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39112</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>786000000</pkc:Start>
			<pkc:End>787999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1c48e75a-71d5-4871-b6f2-bc407894445b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39114</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>655000000</pkc:Start>
			<pkc:End>659999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39117</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>659000000</pkc:Start>
			<pkc:End>659999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39117</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>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39117</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>890000000</pkc:Start>
			<pkc:End>891999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39119</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>995000000</pkc:Start>
			<pkc:End>997999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39121</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>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39121</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>668999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9b6938df-398f-407d-962f-d99b2e1d5d1b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39123</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>669000000</pkc:Start>
			<pkc:End>671999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37324</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>672000000</pkc:Start>
			<pkc:End>674999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39125</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>675000000</pkc:Start>
			<pkc:End>677999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39127</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678000000</pkc:Start>
			<pkc:End>679999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39129</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>996000000</pkc:Start>
			<pkc:End>997999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39131</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>996000000</pkc:Start>
			<pkc:End>997999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39133</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>998000000</pkc:Start>
			<pkc:End>998999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39135</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>998000000</pkc:Start>
			<pkc:End>998999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9b6938df-398f-407d-962f-d99b2e1d5d1b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39137</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>680000000</pkc:Start>
			<pkc:End>680999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39139</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>681000000</pkc:Start>
			<pkc:End>681499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d63316d0-1b6c-48e5-8db9-32b4d83fc7a0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39141</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>999000000</pkc:Start>
			<pkc:End>999049999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2143d01a-961c-4d9e-9150-6b5de0011274}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39143</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>727000000</pkc:Start>
			<pkc:End>741999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39145</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>365000000</pkc:Start>
			<pkc:End>367999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39145</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425000000</pkc:Start>
			<pkc:End>425999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39145</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436000000</pkc:Start>
			<pkc:End>436999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37325</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>825000000</pkc:Start>
			<pkc:End>830999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39147</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>837000000</pkc:Start>
			<pkc:End>842999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39149</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>111000000</pkc:Start>
			<pkc:End>111999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39149</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>197000000</pkc:Start>
			<pkc:End>198999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39149</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337000000</pkc:Start>
			<pkc:End>338999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39149</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>365000000</pkc:Start>
			<pkc:End>367999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39149</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425000000</pkc:Start>
			<pkc:End>425999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39149</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436000000</pkc:Start>
			<pkc:End>436999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39149</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>460000000</pkc:Start>
			<pkc:End>460999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{586bc076-c93d-429a-afe5-a69fbc644e88}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39149</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>470000000</pkc:Start>
			<pkc:End>473999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39151</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>742000000</pkc:Start>
			<pkc:End>753999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39153</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>297399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39155</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>268000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38986</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>111000000</pkc:Start>
			<pkc:End>111999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38986</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>197000000</pkc:Start>
			<pkc:End>198999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39159</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>460000000</pkc:Start>
			<pkc:End>460999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39159</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>470000000</pkc:Start>
			<pkc:End>473999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39161</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>984000000</pkc:Start>
			<pkc:End>988999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39163</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>855000000</pkc:Start>
			<pkc:End>859999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39165</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>902000000</pkc:Start>
			<pkc:End>916999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39167</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>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39169</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>461000000</pkc:Start>
			<pkc:End>468999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39171</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>537000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39171</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>567999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39173</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>568000000</pkc:Start>
			<pkc:End>587999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39173</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>935000000</pkc:Start>
			<pkc:End>936999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39175</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>843000000</pkc:Start>
			<pkc:End>848999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39177</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>506999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39179</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>398000000</pkc:Start>
			<pkc:End>422999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39181</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>917000000</pkc:Start>
			<pkc:End>922999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39183</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>16000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39183</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>628000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39183</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39183</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39183</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>700999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39185</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>731000000</pkc:Start>
			<pkc:End>745999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39187</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>880000000</pkc:Start>
			<pkc:End>884999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39189</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>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39191</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>306000000</pkc:Start>
			<pkc:End>330999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39193</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>623000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39195</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474000000</pkc:Start>
			<pkc:End>476999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39195</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>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39195</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>630000000</pkc:Start>
			<pkc:End>630999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39197</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>631000000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39199</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>870000000</pkc:Start>
			<pkc:End>873999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fc3d428b-656b-4129-8274-700966289991}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39201</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>885000000</pkc:Start>
			<pkc:End>887999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39203</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>537000000</pkc:Start>
			<pkc:End>544999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39205</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>331000000</pkc:Start>
			<pkc:End>333999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39207</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>64800000</pkc:Start>
			<pkc:End>64999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39209</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>996000000</pkc:Start>
			<pkc:End>998999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39211</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>641000000</pkc:Start>
			<pkc:End>643999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39759</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>650000000</pkc:Start>
			<pkc:End>652999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39760</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>366000000</pkc:Start>
			<pkc:End>367999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39760</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425000000</pkc:Start>
			<pkc:End>425999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39217</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>989000000</pkc:Start>
			<pkc:End>991999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39218</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>992000000</pkc:Start>
			<pkc:End>994999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2143d01a-961c-4d9e-9150-6b5de0011274}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39219</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>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39220</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>545000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39253</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>849000000</pkc:Start>
			<pkc:End>854999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39254</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>860000000</pkc:Start>
			<pkc:End>864999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39255</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>916000000</pkc:Start>
			<pkc:End>917999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39256</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>929000000</pkc:Start>
			<pkc:End>934999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39257</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>950000000</pkc:Start>
			<pkc:End>954999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39258</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>996000000</pkc:Start>
			<pkc:End>997999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39259</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>716000000</pkc:Start>
			<pkc:End>730999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39260</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>761000000</pkc:Start>
			<pkc:End>775999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39261</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>894000000</pkc:Start>
			<pkc:End>896999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39262</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>712000000</pkc:Start>
			<pkc:End>723299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39263</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>469000000</pkc:Start>
			<pkc:End>469999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39264</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>507000000</pkc:Start>
			<pkc:End>536999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39265</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>575999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39266</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>923000000</pkc:Start>
			<pkc:End>928999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7cfd4696-69a9-4af7-af36-ff3d12b6b6c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39267</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927450000</pkc:Start>
			<pkc:End>927469999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b482b078-ed27-4750-9ce9-60da4f575c67}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39268</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927755000</pkc:Start>
			<pkc:End>927755999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{50e329f7-a5fa-46b2-85fd-f224e5da7764}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39269</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927470000</pkc:Start>
			<pkc:End>927489999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d932ba14-a8cd-4368-aa5a-90d6613afea7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39270</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927756000</pkc:Start>
			<pkc:End>927756999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d2c04e90-c3dd-4260-b0f3-f845f5d27d64}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39271</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927490000</pkc:Start>
			<pkc:End>927509999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{05d94d71-4ba4-427c-98f2-0e058edfe9af}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39272</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927757000</pkc:Start>
			<pkc:End>927757999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bde0d4a5-2f2a-4bff-9d75-4a497d2d0019}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39273</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927510000</pkc:Start>
			<pkc:End>927529999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89cc87b2-d442-4c79-99b2-addc5abcf2a5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39274</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927758000</pkc:Start>
			<pkc:End>927758999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8be4a481-9b5c-4588-a5ec-5dad4b1f15da}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39275</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927530000</pkc:Start>
			<pkc:End>927549999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56f31729-c7c2-46b1-88a9-b2ebde10a7b1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39276</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927759000</pkc:Start>
			<pkc:End>927759999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bde0d4a5-2f2a-4bff-9d75-4a497d2d0019}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39278</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927550000</pkc:Start>
			<pkc:End>927569999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8be4a481-9b5c-4588-a5ec-5dad4b1f15da}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39280</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927570000</pkc:Start>
			<pkc:End>927589999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7cfd4696-69a9-4af7-af36-ff3d12b6b6c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39296</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927590000</pkc:Start>
			<pkc:End>927609999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b482b078-ed27-4750-9ce9-60da4f575c67}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39298</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927760000</pkc:Start>
			<pkc:End>927760999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{50e329f7-a5fa-46b2-85fd-f224e5da7764}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39300</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927800000</pkc:Start>
			<pkc:End>927819999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d932ba14-a8cd-4368-aa5a-90d6613afea7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39302</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927761000</pkc:Start>
			<pkc:End>927761999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d2c04e90-c3dd-4260-b0f3-f845f5d27d64}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39304</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927610000</pkc:Start>
			<pkc:End>927629999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{05d94d71-4ba4-427c-98f2-0e058edfe9af}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39306</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927762000</pkc:Start>
			<pkc:End>927762999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bde0d4a5-2f2a-4bff-9d75-4a497d2d0019}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39308</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927630000</pkc:Start>
			<pkc:End>927649999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89cc87b2-d442-4c79-99b2-addc5abcf2a5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39310</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927763000</pkc:Start>
			<pkc:End>927763999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8be4a481-9b5c-4588-a5ec-5dad4b1f15da}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39312</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927650000</pkc:Start>
			<pkc:End>927669999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56f31729-c7c2-46b1-88a9-b2ebde10a7b1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39314</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927764000</pkc:Start>
			<pkc:End>927764999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bde0d4a5-2f2a-4bff-9d75-4a497d2d0019}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39316</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927670000</pkc:Start>
			<pkc:End>927689999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89cc87b2-d442-4c79-99b2-addc5abcf2a5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39318</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927765000</pkc:Start>
			<pkc:End>927765999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8be4a481-9b5c-4588-a5ec-5dad4b1f15da}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39320</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927690000</pkc:Start>
			<pkc:End>927709999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56f31729-c7c2-46b1-88a9-b2ebde10a7b1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39322</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927766000</pkc:Start>
			<pkc:End>927766999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39324</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>995000000</pkc:Start>
			<pkc:End>997999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39326</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337000000</pkc:Start>
			<pkc:End>338999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39326</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>365000000</pkc:Start>
			<pkc:End>365999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39328</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>644000000</pkc:Start>
			<pkc:End>646999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39330</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>647000000</pkc:Start>
			<pkc:End>649999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39761</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>653000000</pkc:Start>
			<pkc:End>655999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39336</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>918000000</pkc:Start>
			<pkc:End>918749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39338</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>919000000</pkc:Start>
			<pkc:End>919749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fa327c5-2ba7-4090-ade8-0ec3eeda3242}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39340</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927400000</pkc:Start>
			<pkc:End>927449999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39763</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955000000</pkc:Start>
			<pkc:End>958029999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39344</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>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39345</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>108000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39347</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>963000000</pkc:Start>
			<pkc:End>965999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39349</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>975000000</pkc:Start>
			<pkc:End>977999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39351</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>250000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39351</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>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39351</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>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39351</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>343999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39353</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>344000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39353</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>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39353</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>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39353</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>438999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39355</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>497000000</pkc:Start>
			<pkc:End>536999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39355</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>932000000</pkc:Start>
			<pkc:End>934999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39357</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>656000000</pkc:Start>
			<pkc:End>658999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39359</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>659000000</pkc:Start>
			<pkc:End>659999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39359</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>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39359</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>667000000</pkc:Start>
			<pkc:End>667999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39361</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>668000000</pkc:Start>
			<pkc:End>669549999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39363</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>906000000</pkc:Start>
			<pkc:End>907999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39365</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>978000000</pkc:Start>
			<pkc:End>980999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39367</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>981000000</pkc:Start>
			<pkc:End>983999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39369</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>984000000</pkc:Start>
			<pkc:End>986999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39371</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>987000000</pkc:Start>
			<pkc:End>989999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39373</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>999000000</pkc:Start>
			<pkc:End>999999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39375</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>670000000</pkc:Start>
			<pkc:End>670999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39377</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>671000000</pkc:Start>
			<pkc:End>671999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39379</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>672000000</pkc:Start>
			<pkc:End>672819999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39381</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>998000000</pkc:Start>
			<pkc:End>999999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39383</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>630000000</pkc:Start>
			<pkc:End>631999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39385</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>908000000</pkc:Start>
			<pkc:End>909639999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37326</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>910000000</pkc:Start>
			<pkc:End>911999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39387</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>673000000</pkc:Start>
			<pkc:End>673999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39391</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>632000000</pkc:Start>
			<pkc:End>633999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39393</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>674000000</pkc:Start>
			<pkc:End>674849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39395</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>675000000</pkc:Start>
			<pkc:End>675999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39397</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>634000000</pkc:Start>
			<pkc:End>635704999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39399</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>914000000</pkc:Start>
			<pkc:End>915999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39401</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>990000000</pkc:Start>
			<pkc:End>992399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39403</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>993000000</pkc:Start>
			<pkc:End>995999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39405</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>757000000</pkc:Start>
			<pkc:End>769019999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39407</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>998000000</pkc:Start>
			<pkc:End>998999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39409</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>676000000</pkc:Start>
			<pkc:End>676499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39411</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>676500000</pkc:Start>
			<pkc:End>676899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39413</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>677000000</pkc:Start>
			<pkc:End>677499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39415</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>921000000</pkc:Start>
			<pkc:End>921999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39548</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>922000000</pkc:Start>
			<pkc:End>922999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39419</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2143d01a-961c-4d9e-9150-6b5de0011274}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39421</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>423000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39423</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>663000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39425</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>588000000</pkc:Start>
			<pkc:End>607999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39427</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>701000000</pkc:Start>
			<pkc:End>715999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39431</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>831000000</pkc:Start>
			<pkc:End>836999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39433</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>456999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39435</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>682000000</pkc:Start>
			<pkc:End>696999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39437</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>772000000</pkc:Start>
			<pkc:End>777999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39439</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>746000000</pkc:Start>
			<pkc:End>760999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39441</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>799000000</pkc:Start>
			<pkc:End>808999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39443</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>875000000</pkc:Start>
			<pkc:End>879999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39447</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>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39449</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>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39451</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>616000000</pkc:Start>
			<pkc:End>622999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39453</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>677500000</pkc:Start>
			<pkc:End>677999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39455</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678000000</pkc:Start>
			<pkc:End>678499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fc3d428b-656b-4129-8274-700966289991}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39779</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>923000000</pkc:Start>
			<pkc:End>923999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39459</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>196000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2143d01a-961c-4d9e-9150-6b5de0011274}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39461</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>999000000</pkc:Start>
			<pkc:End>999999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39463</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>945000000</pkc:Start>
			<pkc:End>948807999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39465</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>145200000</pkc:Start>
			<pkc:End>145499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39467</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678500000</pkc:Start>
			<pkc:End>678599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39764</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678600000</pkc:Start>
			<pkc:End>678649999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39471</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678650000</pkc:Start>
			<pkc:End>678699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39473</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>924500000</pkc:Start>
			<pkc:End>924999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39475</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>472500000</pkc:Start>
			<pkc:End>472999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39477</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>550000000</pkc:Start>
			<pkc:End>550699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39479</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>425000000</pkc:Start>
			<pkc:End>425999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39481</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>107600000</pkc:Start>
			<pkc:End>107999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39483</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>865000000</pkc:Start>
			<pkc:End>869999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39550</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>888000000</pkc:Start>
			<pkc:End>890999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39552</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>912000000</pkc:Start>
			<pkc:End>913999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39554</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>959000000</pkc:Start>
			<pkc:End>962999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39556</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>16000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39557</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>784000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39559</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>798999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39561</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>809000000</pkc:Start>
			<pkc:End>818999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39563</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891000000</pkc:Start>
			<pkc:End>893999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39565</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>596000000</pkc:Start>
			<pkc:End>611533703</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39567</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>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39569</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>576000000</pkc:Start>
			<pkc:End>595999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39571</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>697000000</pkc:Start>
			<pkc:End>711999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39573</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>778000000</pkc:Start>
			<pkc:End>783999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39575</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>473000000</pkc:Start>
			<pkc:End>473499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39581</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>925000000</pkc:Start>
			<pkc:End>925499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37327</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>473500000</pkc:Start>
			<pkc:End>473999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fc3d428b-656b-4129-8274-700966289991}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39579</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>925500000</pkc:Start>
			<pkc:End>925999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39587</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474200000</pkc:Start>
			<pkc:End>474399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39583</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436800000</pkc:Start>
			<pkc:End>436999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39585</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474000000</pkc:Start>
			<pkc:End>474199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39577</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926000000</pkc:Start>
			<pkc:End>926199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39589</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474600000</pkc:Start>
			<pkc:End>474699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2143d01a-961c-4d9e-9150-6b5de0011274}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39591</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>460000000</pkc:Start>
			<pkc:End>460199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2143d01a-961c-4d9e-9150-6b5de0011274}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39593</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>550700000</pkc:Start>
			<pkc:End>550899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37328</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15900000</pkc:Start>
			<pkc:End>15999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39595</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>920000000</pkc:Start>
			<pkc:End>920999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39597</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>924000000</pkc:Start>
			<pkc:End>924499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39599</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927710000</pkc:Start>
			<pkc:End>927719999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39601</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>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39603</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436500000</pkc:Start>
			<pkc:End>436999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39605</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15865000</pkc:Start>
			<pkc:End>15874999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39607</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474700000</pkc:Start>
			<pkc:End>474799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39609</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474800000</pkc:Start>
			<pkc:End>474899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fc3d428b-656b-4129-8274-700966289991}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39611</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927200000</pkc:Start>
			<pkc:End>927299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37329</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>145100000</pkc:Start>
			<pkc:End>145199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39613</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15855000</pkc:Start>
			<pkc:End>15864999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37330</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>460200000</pkc:Start>
			<pkc:End>460299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37331</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926200000</pkc:Start>
			<pkc:End>926299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37332</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926300000</pkc:Start>
			<pkc:End>926399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37333</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926400000</pkc:Start>
			<pkc:End>926499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37334</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>460300000</pkc:Start>
			<pkc:End>460399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37335</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>550900000</pkc:Start>
			<pkc:End>550999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37336</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>460400000</pkc:Start>
			<pkc:End>460499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fc3d428b-656b-4129-8274-700966289991}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39780</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927300000</pkc:Start>
			<pkc:End>927399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{90a61a0d-0b76-4bf1-a8b8-89061855a4c9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37337</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926500000</pkc:Start>
			<pkc:End>926599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39766</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474900000</pkc:Start>
			<pkc:End>474909999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37338</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474400000</pkc:Start>
			<pkc:End>474499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-37339</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474500000</pkc:Start>
			<pkc:End>474599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39767</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>145500000</pkc:Start>
			<pkc:End>145874999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39622</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15875000</pkc:Start>
			<pkc:End>15899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39768</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219500000</pkc:Start>
			<pkc:End>219874999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39626</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>64750000</pkc:Start>
			<pkc:End>64799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39628</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15850000</pkc:Start>
			<pkc:End>15854999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39630</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15845000</pkc:Start>
			<pkc:End>15849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39632</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15840000</pkc:Start>
			<pkc:End>15844999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39634</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436000000</pkc:Start>
			<pkc:End>436379999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39636</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>145050000</pkc:Start>
			<pkc:End>145099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39638</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15835000</pkc:Start>
			<pkc:End>15839999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39640</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>107557000</pkc:Start>
			<pkc:End>107561999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39642</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>107562000</pkc:Start>
			<pkc:End>107566999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39000</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>935000000</pkc:Start>
			<pkc:End>938749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39002</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>940000000</pkc:Start>
			<pkc:End>944999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39644</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>292000000</pkc:Start>
			<pkc:End>306999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39646</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39648</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>491000000</pkc:Start>
			<pkc:End>498999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39650</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>406000000</pkc:Start>
			<pkc:End>413999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39652</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>373999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39655</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>177000000</pkc:Start>
			<pkc:End>191999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39657</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>827500000</pkc:Start>
			<pkc:End>829499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39659</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>414000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39661</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>499000000</pkc:Start>
			<pkc:End>509999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39663</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>461000000</pkc:Start>
			<pkc:End>469999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39665</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>141999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39667</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39669</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>312000000</pkc:Start>
			<pkc:End>329999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39671</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39673</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>390000000</pkc:Start>
			<pkc:End>405999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39675</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>354999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39677</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>374000000</pkc:Start>
			<pkc:End>389999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39679</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>490999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39681</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>74000000</pkc:Start>
			<pkc:End>96499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39683</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>943000000</pkc:Start>
			<pkc:End>945999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39685</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>152000000</pkc:Start>
			<pkc:End>167249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39687</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>825000000</pkc:Start>
			<pkc:End>827324999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39689</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>29999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39689</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>31200000</pkc:Start>
			<pkc:End>62749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39691</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>870000000</pkc:Start>
			<pkc:End>874454999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39693</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>963742600</pkc:Start>
			<pkc:End>964176624</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39695</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946587130</pkc:Start>
			<pkc:End>946616064</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39697</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>968199080</pkc:Start>
			<pkc:End>968416879</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39769</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>968416880</pkc:Start>
			<pkc:End>968634679</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39701</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>969234680</pkc:Start>
			<pkc:End>969398029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39770</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>858090000</pkc:Start>
			<pkc:End>858529687</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39705</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>829954500</pkc:Start>
			<pkc:End>829983812</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39707</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>861426250</pkc:Start>
			<pkc:End>861759449</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39709</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>861759450</pkc:Start>
			<pkc:End>862092649</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39711</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>862342650</pkc:Start>
			<pkc:End>862592549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39713</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>905823000</pkc:Start>
			<pkc:End>906528599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39715</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>874941150</pkc:Start>
			<pkc:End>874988189</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39717</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>906763800</pkc:Start>
			<pkc:End>907452549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39771</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>907452550</pkc:Start>
			<pkc:End>908141299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39721</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>908141300</pkc:Start>
			<pkc:End>908657862</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39723</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>934000000</pkc:Start>
			<pkc:End>934482124</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39277</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>934482125</pkc:Start>
			<pkc:End>934964249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39279</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>936314250</pkc:Start>
			<pkc:End>936675843</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39281</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>962000000</pkc:Start>
			<pkc:End>962819449</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39283</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946500000</pkc:Start>
			<pkc:End>946554629</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39285</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>857500000</pkc:Start>
			<pkc:End>857942499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39287</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>829925000</pkc:Start>
			<pkc:End>829954499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39289</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>904500000</pkc:Start>
			<pkc:End>905492249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39291</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>874875000</pkc:Start>
			<pkc:End>874941149</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39293</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>956000000</pkc:Start>
			<pkc:End>956749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39295</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926628571</pkc:Start>
			<pkc:End>926678570</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39297</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>957000000</pkc:Start>
			<pkc:End>957999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39299</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>958000000</pkc:Start>
			<pkc:End>958499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39301</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>958500000</pkc:Start>
			<pkc:End>958999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39303</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>851000000</pkc:Start>
			<pkc:End>851749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39305</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>972800100</pkc:Start>
			<pkc:End>972850099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39307</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>852000000</pkc:Start>
			<pkc:End>852999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39309</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>854000000</pkc:Start>
			<pkc:End>854499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39311</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>854500000</pkc:Start>
			<pkc:End>854999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39313</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>892000000</pkc:Start>
			<pkc:End>892749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39315</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>868000100</pkc:Start>
			<pkc:End>868050099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39317</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>893000000</pkc:Start>
			<pkc:End>893999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39319</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>894000000</pkc:Start>
			<pkc:End>894499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39321</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>894500000</pkc:Start>
			<pkc:End>894999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39323</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>929000000</pkc:Start>
			<pkc:End>929749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d1b53b3d-38eb-46a7-9afa-47271d93aec4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39325</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>896300000</pkc:Start>
			<pkc:End>896349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39327</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>930000000</pkc:Start>
			<pkc:End>930999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39329</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>931000000</pkc:Start>
			<pkc:End>931499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39331</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>931500000</pkc:Start>
			<pkc:End>931999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39333</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>853000000</pkc:Start>
			<pkc:End>853749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39335</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>972850100</pkc:Start>
			<pkc:End>972900099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39337</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>848000000</pkc:Start>
			<pkc:End>849499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39339</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>855000000</pkc:Start>
			<pkc:End>855099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39341</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>849500000</pkc:Start>
			<pkc:End>850999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39343</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>895900000</pkc:Start>
			<pkc:End>896124999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39346</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>868050100</pkc:Start>
			<pkc:End>868065099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39348</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>895000000</pkc:Start>
			<pkc:End>895449999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39350</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>896200000</pkc:Start>
			<pkc:End>896299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39352</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>895450000</pkc:Start>
			<pkc:End>895899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39354</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>932900000</pkc:Start>
			<pkc:End>933124999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d1b53b3d-38eb-46a7-9afa-47271d93aec4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39772</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>896350000</pkc:Start>
			<pkc:End>896364999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39358</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>932000000</pkc:Start>
			<pkc:End>932449999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39360</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>933200000</pkc:Start>
			<pkc:End>933299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39362</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>932450000</pkc:Start>
			<pkc:End>932899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39364</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>953500000</pkc:Start>
			<pkc:End>954624999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39366</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942250000</pkc:Start>
			<pkc:End>942399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39368</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>846600000</pkc:Start>
			<pkc:End>847162499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39370</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824260000</pkc:Start>
			<pkc:End>824334999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39372</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>889800000</pkc:Start>
			<pkc:End>890362499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39374</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>868065100</pkc:Start>
			<pkc:End>868140099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39376</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>951000000</pkc:Start>
			<pkc:End>952874999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39378</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942000000</pkc:Start>
			<pkc:End>942249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39380</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>845000000</pkc:Start>
			<pkc:End>845599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39382</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824100000</pkc:Start>
			<pkc:End>824179999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39384</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>889000000</pkc:Start>
			<pkc:End>889599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39386</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>869400000</pkc:Start>
			<pkc:End>869479999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39388</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>333000000</pkc:Start>
			<pkc:End>334499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39390</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942550000</pkc:Start>
			<pkc:End>942649999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39392</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955051400</pkc:Start>
			<pkc:End>955060599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39394</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955060600</pkc:Start>
			<pkc:End>955069799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39396</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955069800</pkc:Start>
			<pkc:End>955078999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39398</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>845800000</pkc:Start>
			<pkc:End>846399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39400</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824180000</pkc:Start>
			<pkc:End>824259999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39402</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847368000</pkc:Start>
			<pkc:End>847371999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39404</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847372000</pkc:Start>
			<pkc:End>847375999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39406</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847376000</pkc:Start>
			<pkc:End>847379999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39408</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>890550000</pkc:Start>
			<pkc:End>891074999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39410</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>869555000</pkc:Start>
			<pkc:End>869589999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39412</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891264400</pkc:Start>
			<pkc:End>891267599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39414</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891267600</pkc:Start>
			<pkc:End>891270799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39416</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891270800</pkc:Start>
			<pkc:End>891273999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39418</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927000000</pkc:Start>
			<pkc:End>927412499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d1b53b3d-38eb-46a7-9afa-47271d93aec4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39420</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>913622982</pkc:Start>
			<pkc:End>913677981</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39422</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928100000</pkc:Start>
			<pkc:End>928102399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39424</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928102400</pkc:Start>
			<pkc:End>928104799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39426</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928104800</pkc:Start>
			<pkc:End>928107199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39428</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>330000000</pkc:Start>
			<pkc:End>332249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39430</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942400000</pkc:Start>
			<pkc:End>942549999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39432</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955000000</pkc:Start>
			<pkc:End>955013799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39434</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955013800</pkc:Start>
			<pkc:End>955027599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39436</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955027600</pkc:Start>
			<pkc:End>955041399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39438</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>844000000</pkc:Start>
			<pkc:End>844749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39440</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824000000</pkc:Start>
			<pkc:End>824099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39442</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847350000</pkc:Start>
			<pkc:End>847355999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39444</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847356000</pkc:Start>
			<pkc:End>847361999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39446</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847362000</pkc:Start>
			<pkc:End>847367999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39448</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>452000000</pkc:Start>
			<pkc:End>457999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39450</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>869000000</pkc:Start>
			<pkc:End>869399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39452</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891250000</pkc:Start>
			<pkc:End>891254799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39773</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891254800</pkc:Start>
			<pkc:End>891259599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39456</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891259600</pkc:Start>
			<pkc:End>891264399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39458</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927550000</pkc:Start>
			<pkc:End>927962499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d1b53b3d-38eb-46a7-9afa-47271d93aec4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39460</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>913677982</pkc:Start>
			<pkc:End>913732981</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39462</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928107200</pkc:Start>
			<pkc:End>928109599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39464</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928109600</pkc:Start>
			<pkc:End>928111999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39466</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928112000</pkc:Start>
			<pkc:End>928114399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a0cde89c-3304-4157-b61c-c8ad785d1fad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39004</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>65000000</pkc:Start>
			<pkc:End>73249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dca01e19-01f5-4ce1-98b1-35fb7a323806}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39006</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>76000000</pkc:Start>
			<pkc:End>86999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{770bc271-8dc1-467d-b574-73cbacbeccd1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39009</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>220000000</pkc:Start>
			<pkc:End>228249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c63f22b5-fdaf-4488-aeac-cc19411d0243}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39011</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>165000000</pkc:Start>
			<pkc:End>175999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3b965dfc-31d9-4903-886f-873a0382776c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39013</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>231000000</pkc:Start>
			<pkc:End>240249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b68cc682-9531-4b6c-bb5e-202c92a59946}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39015</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>134000000</pkc:Start>
			<pkc:End>144999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6c7afc31-950c-4fa8-93ee-3e880aa97e5d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39017</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>120249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ca400347-52d3-45a2-a333-f7d4c33b6af5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39019</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>123000000</pkc:Start>
			<pkc:End>133999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39021</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>838000000</pkc:Start>
			<pkc:End>842124999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39023</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>823000000</pkc:Start>
			<pkc:End>823274999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39025</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>925000000</pkc:Start>
			<pkc:End>926628570</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39468</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>948000000</pkc:Start>
			<pkc:End>949124999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39470</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>941000000</pkc:Start>
			<pkc:End>941074999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39027</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>835000000</pkc:Start>
			<pkc:End>836124999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39029</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>822384858</pkc:Start>
			<pkc:End>822459857</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39472</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>949500000</pkc:Start>
			<pkc:End>950099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39474</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>941075000</pkc:Start>
			<pkc:End>941114999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39031</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>836500000</pkc:Start>
			<pkc:End>837099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39033</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>822459858</pkc:Start>
			<pkc:End>822499857</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39476</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>967449080</pkc:Start>
			<pkc:End>967674079</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39478</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946657454</pkc:Start>
			<pkc:End>946672453</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39480</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>969398030</pkc:Start>
			<pkc:End>969548029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39482</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>969548030</pkc:Start>
			<pkc:End>969698029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39484</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>970273030</pkc:Start>
			<pkc:End>970373029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39486</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>862592550</pkc:Start>
			<pkc:End>862761299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39488</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>830008813</pkc:Start>
			<pkc:End>830020062</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39490</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>864119550</pkc:Start>
			<pkc:End>864269549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39492</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>864269550</pkc:Start>
			<pkc:End>864419549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39494</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>864544550</pkc:Start>
			<pkc:End>864644549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39496</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>911854763</pkc:Start>
			<pkc:End>912079762</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39498</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>875033035</pkc:Start>
			<pkc:End>875048034</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39500</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>912404763</pkc:Start>
			<pkc:End>912629762</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39502</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>912629763</pkc:Start>
			<pkc:End>912854762</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39503</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>913268013</pkc:Start>
			<pkc:End>913468012</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39505</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>936675844</pkc:Start>
			<pkc:End>936875843</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39507</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>936875844</pkc:Start>
			<pkc:End>937075843</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39509</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937075844</pkc:Start>
			<pkc:End>937225843</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39511</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>967121300</pkc:Start>
			<pkc:End>967367134</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39513</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946641065</pkc:Start>
			<pkc:End>946657453</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39515</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>863942550</pkc:Start>
			<pkc:End>864075299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39517</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>830020063</pkc:Start>
			<pkc:End>830028912</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39519</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>911457863</pkc:Start>
			<pkc:End>911755537</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39521</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>875013190</pkc:Start>
			<pkc:End>875033034</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39523</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>950300000</pkc:Start>
			<pkc:End>950524999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39525</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>941115000</pkc:Start>
			<pkc:End>941129999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39527</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>837300000</pkc:Start>
			<pkc:End>837524999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39529</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259745000</pkc:Start>
			<pkc:End>259759999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39531</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>964321300</pkc:Start>
			<pkc:End>964696299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39533</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946616065</pkc:Start>
			<pkc:End>946641064</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39535</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>967749080</pkc:Start>
			<pkc:End>967974079</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39537</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>967974080</pkc:Start>
			<pkc:End>968199079</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39539</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>970148030</pkc:Start>
			<pkc:End>970273029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39541</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>858676250</pkc:Start>
			<pkc:End>859051249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39543</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>829983813</pkc:Start>
			<pkc:End>830008812</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39545</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>862817550</pkc:Start>
			<pkc:End>863042549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39547</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>863042550</pkc:Start>
			<pkc:End>863267549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39549</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>864419550</pkc:Start>
			<pkc:End>864544549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39551</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>908657863</pkc:Start>
			<pkc:End>909032862</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39553</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>874988190</pkc:Start>
			<pkc:End>875013189</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39555</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>912854763</pkc:Start>
			<pkc:End>913061387</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39558</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>913061388</pkc:Start>
			<pkc:End>913268012</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39560</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>913468013</pkc:Start>
			<pkc:End>913622981</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39562</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937225844</pkc:Start>
			<pkc:End>937370481</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39564</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937370482</pkc:Start>
			<pkc:End>937515119</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39566</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937515120</pkc:Start>
			<pkc:End>937623597</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39568</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>959000000</pkc:Start>
			<pkc:End>961249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39570</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU5</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946350000</pkc:Start>
			<pkc:End>946499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39572</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>968634680</pkc:Start>
			<pkc:End>968834679</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39574</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>968834680</pkc:Start>
			<pkc:End>969034679</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39576</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>970373030</pkc:Start>
			<pkc:End>970473029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39578</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>104000000</pkc:Start>
			<pkc:End>109249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39580</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU6</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946000000</pkc:Start>
			<pkc:End>946349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39582</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>966321300</pkc:Start>
			<pkc:End>966721299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39584</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>966721300</pkc:Start>
			<pkc:End>967121299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39586</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>969034680</pkc:Start>
			<pkc:End>969234679</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39588</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>964821300</pkc:Start>
			<pkc:End>965321299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39590</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>965321300</pkc:Start>
			<pkc:End>965821299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39592</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>965821300</pkc:Start>
			<pkc:End>966321299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39594</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>963092600</pkc:Start>
			<pkc:End>963580099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39596</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU8</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946554630</pkc:Start>
			<pkc:End>946587129</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39598</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>969698030</pkc:Start>
			<pkc:End>969848029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39600</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>969848030</pkc:Start>
			<pkc:End>969998029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39602</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>969998030</pkc:Start>
			<pkc:End>970148029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39604</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>618000000</pkc:Start>
			<pkc:End>623249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39606</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU6</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>829500000</pkc:Start>
			<pkc:End>829849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39608</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>859176250</pkc:Start>
			<pkc:End>859626249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39610</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>859626250</pkc:Start>
			<pkc:End>860076249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39612</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>862092650</pkc:Start>
			<pkc:End>862342649</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39774</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>860076250</pkc:Start>
			<pkc:End>860526249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39616</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>860526250</pkc:Start>
			<pkc:End>860976249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39618</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>860976250</pkc:Start>
			<pkc:End>861426249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39619</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>910107863</pkc:Start>
			<pkc:End>910557862</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39775</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>910557863</pkc:Start>
			<pkc:End>911007862</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39623</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>911007863</pkc:Start>
			<pkc:End>911457862</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39625</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>897000000</pkc:Start>
			<pkc:End>902599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39627</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU8</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>874500000</pkc:Start>
			<pkc:End>874874999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39629</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>909157863</pkc:Start>
			<pkc:End>909632862</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39631</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>909632863</pkc:Start>
			<pkc:End>910107862</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39633</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>912154763</pkc:Start>
			<pkc:End>912404762</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39776</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>934964250</pkc:Start>
			<pkc:End>935414249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39637</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>935414250</pkc:Start>
			<pkc:End>935864249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39639</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>935864250</pkc:Start>
			<pkc:End>936314249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39641</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>856000000</pkc:Start>
			<pkc:End>857099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39643</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU8</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>829850000</pkc:Start>
			<pkc:End>829924999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39645</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>863267550</pkc:Start>
			<pkc:End>863492549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39647</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>863492550</pkc:Start>
			<pkc:End>863717549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39649</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>863717550</pkc:Start>
			<pkc:End>863942549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39651</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>878341553</pkc:Start>
			<pkc:End>878690302</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39777</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>878690303</pkc:Start>
			<pkc:End>878790302</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39654</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>878790303</pkc:Start>
			<pkc:End>878890302</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39656</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>833000000</pkc:Start>
			<pkc:End>833699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39658</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>833700000</pkc:Start>
			<pkc:End>833949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39660</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>833950000</pkc:Start>
			<pkc:End>833999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39662</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>832000000</pkc:Start>
			<pkc:End>832699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39664</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>832700000</pkc:Start>
			<pkc:End>832949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39666</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>832950000</pkc:Start>
			<pkc:End>832999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39668</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847383600</pkc:Start>
			<pkc:End>847383699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39668</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847383700</pkc:Start>
			<pkc:End>847384699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39670</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847383000</pkc:Start>
			<pkc:End>847383199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39672</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847383200</pkc:Start>
			<pkc:End>847383399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39674</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824335200</pkc:Start>
			<pkc:End>824335299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39676</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928117400</pkc:Start>
			<pkc:End>928117499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d1b53b3d-38eb-46a7-9afa-47271d93aec4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39678</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>913733182</pkc:Start>
			<pkc:End>913733281</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39680</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891278400</pkc:Start>
			<pkc:End>891278499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39682</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891278000</pkc:Start>
			<pkc:End>891278199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39684</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>869590200</pkc:Start>
			<pkc:End>869590299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4a8149bb-7d61-49f4-8822-82c7bf88d64b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39781</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>972900100</pkc:Start>
			<pkc:End>972900109</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39686</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955081800</pkc:Start>
			<pkc:End>955081899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39686</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955081900</pkc:Start>
			<pkc:End>955082899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39690</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955081000</pkc:Start>
			<pkc:End>955081199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39692</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955081200</pkc:Start>
			<pkc:End>955081399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39694</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955081400</pkc:Start>
			<pkc:End>955081599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39696</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942650500</pkc:Start>
			<pkc:End>942650599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{71c7c851-1863-4232-8ac2-cdd7f5e45dae}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39698</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946677454</pkc:Start>
			<pkc:End>946677553</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{51ba3bd9-c1cd-42b5-ada3-22451bc151f4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39700</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>971500200</pkc:Start>
			<pkc:End>971500299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39702</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955081600</pkc:Start>
			<pkc:End>955081799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39704</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847383400</pkc:Start>
			<pkc:End>847383599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39706</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891278200</pkc:Start>
			<pkc:End>891278399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39708</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU2</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824335300</pkc:Start>
			<pkc:End>824335399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39710</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU6</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824335400</pkc:Start>
			<pkc:End>824335499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39712</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU2</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>869590300</pkc:Start>
			<pkc:End>869590399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39714</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU2</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942650600</pkc:Start>
			<pkc:End>942650699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39716</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU6</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942650700</pkc:Start>
			<pkc:End>942650799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39718</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU5</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942650800</pkc:Start>
			<pkc:End>942650899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39720</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU8</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942650900</pkc:Start>
			<pkc:End>942650999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39722</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU8</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824335500</pkc:Start>
			<pkc:End>824335599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39724</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU8</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>869590400</pkc:Start>
			<pkc:End>869590499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d1b53b3d-38eb-46a7-9afa-47271d93aec4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39725</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU8</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>913733282</pkc:Start>
			<pkc:End>913733381</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39726</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847380000</pkc:Start>
			<pkc:End>847381999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39727</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847382000</pkc:Start>
			<pkc:End>847382999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39728</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928114400</pkc:Start>
			<pkc:End>928116399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b1184982-a958-4643-8e66-445fa0f92832}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39729</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928116400</pkc:Start>
			<pkc:End>928117399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39730</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891274000</pkc:Start>
			<pkc:End>891276999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39731</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891277000</pkc:Start>
			<pkc:End>891277999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39732</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955041400</pkc:Start>
			<pkc:End>955051399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39733</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>955079000</pkc:Start>
			<pkc:End>955080999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{71c7c851-1863-4232-8ac2-cdd7f5e45dae}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39734</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946674454</pkc:Start>
			<pkc:End>946676453</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{71c7c851-1863-4232-8ac2-cdd7f5e45dae}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39735</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946676454</pkc:Start>
			<pkc:End>946677453</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>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39065</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000100</pkc:Start>
			<pkc:End>199000199</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>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39738</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>999000000</pkc:Start>
			<pkc:End>999000199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{50e329f7-a5fa-46b2-85fd-f224e5da7764}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39739</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927767900</pkc:Start>
			<pkc:End>927768099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39740</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474910000</pkc:Start>
			<pkc:End>474910199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{25a0d760-2580-4c99-adfb-d57ba93560f5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39741</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>999050000</pkc:Start>
			<pkc:End>999050199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bde0d4a5-2f2a-4bff-9d75-4a497d2d0019}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39742</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927768100</pkc:Start>
			<pkc:End>927768299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39782</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927768500</pkc:Start>
			<pkc:End>927768699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39744</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>998000000</pkc:Start>
			<pkc:End>998000199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d2c04e90-c3dd-4260-b0f3-f845f5d27d64}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39745</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927768300</pkc:Start>
			<pkc:End>927768499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39746</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15832800</pkc:Start>
			<pkc:End>15832999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{276d6155-27e2-437a-95f9-f1251168c970}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38819</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>681500000</pkc:Start>
			<pkc:End>681500199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8be4a481-9b5c-4588-a5ec-5dad4b1f15da}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38821</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927767500</pkc:Start>
			<pkc:End>927767699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38824</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833000</pkc:Start>
			<pkc:End>15833199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{022a1afb-b893-4190-92c3-8f69a49839fb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38825</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>681500200</pkc:Start>
			<pkc:End>681500399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7cfd4696-69a9-4af7-af36-ff3d12b6b6c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38827</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927767700</pkc:Start>
			<pkc:End>927767899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38829</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678700000</pkc:Start>
			<pkc:End>678700199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38831</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824335000</pkc:Start>
			<pkc:End>824335199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38833</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824335600</pkc:Start>
			<pkc:End>824335699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d1b53b3d-38eb-46a7-9afa-47271d93aec4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38835</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>913732982</pkc:Start>
			<pkc:End>913733181</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d1b53b3d-38eb-46a7-9afa-47271d93aec4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38837</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>913733382</pkc:Start>
			<pkc:End>913733481</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38839</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>869590000</pkc:Start>
			<pkc:End>869590199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38841</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>869590500</pkc:Start>
			<pkc:End>869590599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38843</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942650000</pkc:Start>
			<pkc:End>942650499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa3d0658-67f4-4a26-ba57-3fc6f39861f1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38845</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942651000</pkc:Start>
			<pkc:End>942651099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{51ba3bd9-c1cd-42b5-ada3-22451bc151f4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38847</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>971500000</pkc:Start>
			<pkc:End>971500199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{51ba3bd9-c1cd-42b5-ada3-22451bc151f4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38849</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>971500300</pkc:Start>
			<pkc:End>971500399</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>{61dbe86e-9979-45b4-8607-ae8b56aead36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38855</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>999000200</pkc:Start>
			<pkc:End>999000299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d932ba14-a8cd-4368-aa5a-90d6613afea7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38857</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927768700</pkc:Start>
			<pkc:End>927768799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fc3d428b-656b-4129-8274-700966289991}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39783</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770200</pkc:Start>
			<pkc:End>927770299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d63316d0-1b6c-48e5-8db9-32b4d83fc7a0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38861</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>999050200</pkc:Start>
			<pkc:End>999050299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89cc87b2-d442-4c79-99b2-addc5abcf2a5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38863</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927768800</pkc:Start>
			<pkc:End>927768899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fa327c5-2ba7-4090-ade8-0ec3eeda3242}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39784</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770300</pkc:Start>
			<pkc:End>927770399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01039663-ab8e-4d11-ba6c-cb4dacb2d13e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38867</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>788000000</pkc:Start>
			<pkc:End>788000099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{05d94d71-4ba4-427c-98f2-0e058edfe9af}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38869</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927768900</pkc:Start>
			<pkc:End>927768999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2143d01a-961c-4d9e-9150-6b5de0011274}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38871</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833200</pkc:Start>
			<pkc:End>15833299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1c48e75a-71d5-4871-b6f2-bc407894445b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38873</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>681500400</pkc:Start>
			<pkc:End>681500499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56f31729-c7c2-46b1-88a9-b2ebde10a7b1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38875</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927769000</pkc:Start>
			<pkc:End>927769099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38877</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833300</pkc:Start>
			<pkc:End>15833399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9b6938df-398f-407d-962f-d99b2e1d5d1b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38879</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>681500500</pkc:Start>
			<pkc:End>681500599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b482b078-ed27-4750-9ce9-60da4f575c67}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38881</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927769100</pkc:Start>
			<pkc:End>927769199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38883</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678700200</pkc:Start>
			<pkc:End>678700299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{50e329f7-a5fa-46b2-85fd-f224e5da7764}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38885</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927769200</pkc:Start>
			<pkc:End>927769299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d932ba14-a8cd-4368-aa5a-90d6613afea7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38887</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927769300</pkc:Start>
			<pkc:End>927769399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bde0d4a5-2f2a-4bff-9d75-4a497d2d0019}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38889</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927769400</pkc:Start>
			<pkc:End>927769499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{89cc87b2-d442-4c79-99b2-addc5abcf2a5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38891</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927769500</pkc:Start>
			<pkc:End>927769599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d2c04e90-c3dd-4260-b0f3-f845f5d27d64}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38893</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927769600</pkc:Start>
			<pkc:End>927769699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{05d94d71-4ba4-427c-98f2-0e058edfe9af}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38895</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927769700</pkc:Start>
			<pkc:End>927769799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7cfd4696-69a9-4af7-af36-ff3d12b6b6c8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38897</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927769800</pkc:Start>
			<pkc:End>927769899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b482b078-ed27-4750-9ce9-60da4f575c67}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38899</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927769900</pkc:Start>
			<pkc:End>927769999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8be4a481-9b5c-4588-a5ec-5dad4b1f15da}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38901</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770000</pkc:Start>
			<pkc:End>927770099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56f31729-c7c2-46b1-88a9-b2ebde10a7b1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38903</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770100</pkc:Start>
			<pkc:End>927770199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e120e868-3df2-464a-95a0-b52fa5ada4bf}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38905</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474910200</pkc:Start>
			<pkc:End>474910299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fc3d428b-656b-4129-8274-700966289991}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39785</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770400</pkc:Start>
			<pkc:End>927770499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{774d5df6-d8dd-4d92-98bc-58825849d249}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39786</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770500</pkc:Start>
			<pkc:End>927770599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0fa327c5-2ba7-4090-ade8-0ec3eeda3242}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39787</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770600</pkc:Start>
			<pkc:End>927770699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ab82e0c-ffc9-4107-baa1-c65a8bd3ccc3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38913</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833400</pkc:Start>
			<pkc:End>15833499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2143d01a-961c-4d9e-9150-6b5de0011274}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38915</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833500</pkc:Start>
			<pkc:End>15833599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cfb3e52c-d707-4861-af51-11b27ee6169c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38917</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678700300</pkc:Start>
			<pkc:End>678700399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{419c2448-cd87-48cd-94d4-7b9af5efd169}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38919</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678700400</pkc:Start>
			<pkc:End>678700499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{197247fa-8fb7-4a9d-9415-1ba0e14215e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38921</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833600</pkc:Start>
			<pkc:End>15833699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dd14134a-d56c-4bc0-a2e9-14c462b4295b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38923</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833700</pkc:Start>
			<pkc:End>15833799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38925</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38925</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>388000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38925</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>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38925</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38925</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>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38925</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>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38925</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>626000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38925</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38925</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>664999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01f5fc37-a99e-45c5-b65e-d762f3518ead}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38925</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>733999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39073</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>49750000</pkc:Start>
			<pkc:End>64749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39073</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>92566900</pkc:Start>
			<pkc:End>107556999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39073</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>107567000</pkc:Start>
			<pkc:End>107596899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39073</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>150010000</pkc:Start>
			<pkc:End>164999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39073</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>204411300</pkc:Start>
			<pkc:End>219401299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39081</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>32999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39081</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>203601300</pkc:Start>
			<pkc:End>204401299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39089</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6232800</pkc:Start>
			<pkc:End>7132799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39089</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87271900</pkc:Start>
			<pkc:End>87306899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39089</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219401300</pkc:Start>
			<pkc:End>219411299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39214</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1002800</pkc:Start>
			<pkc:End>1032799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39214</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>107596900</pkc:Start>
			<pkc:End>107598399</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>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39049</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>33000000</pkc:Start>
			<pkc:End>36999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39049</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87729400</pkc:Start>
			<pkc:End>87919399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39049</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219411300</pkc:Start>
			<pkc:End>219421299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39057</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>5432800</pkc:Start>
			<pkc:End>6232799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39057</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87231900</pkc:Start>
			<pkc:End>87261899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39057</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219421300</pkc:Start>
			<pkc:End>219431299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39061</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1432800</pkc:Start>
			<pkc:End>1932799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39061</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87031900</pkc:Start>
			<pkc:End>87046899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39061</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219431300</pkc:Start>
			<pkc:End>219441299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39093</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>13132800</pkc:Start>
			<pkc:End>15382799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39093</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87616900</pkc:Start>
			<pkc:End>87719399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39093</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219441300</pkc:Start>
			<pkc:End>219451299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39115</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1932800</pkc:Start>
			<pkc:End>2432799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39115</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87056900</pkc:Start>
			<pkc:End>87071899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39115</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219451300</pkc:Start>
			<pkc:End>219461299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39118</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>2432800</pkc:Start>
			<pkc:End>2932799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39118</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87081900</pkc:Start>
			<pkc:End>87096899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39118</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219461300</pkc:Start>
			<pkc:End>219471299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39097</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>11132800</pkc:Start>
			<pkc:End>13132799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39097</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87516900</pkc:Start>
			<pkc:End>87606899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39097</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219471300</pkc:Start>
			<pkc:End>219481299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39122</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>8132800</pkc:Start>
			<pkc:End>9632799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39122</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87366900</pkc:Start>
			<pkc:End>87431899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39122</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219481300</pkc:Start>
			<pkc:End>219491299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39130</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>9632800</pkc:Start>
			<pkc:End>11132799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39130</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87441900</pkc:Start>
			<pkc:End>87506899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39130</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337000000</pkc:Start>
			<pkc:End>337009999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39138</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>7132800</pkc:Start>
			<pkc:End>8132799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39138</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87316900</pkc:Start>
			<pkc:End>87356899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39138</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337010000</pkc:Start>
			<pkc:End>337019999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39101</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1132800</pkc:Start>
			<pkc:End>1232799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39142</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>2932800</pkc:Start>
			<pkc:End>3432799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39142</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87106900</pkc:Start>
			<pkc:End>87121899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39142</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337020000</pkc:Start>
			<pkc:End>337029999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b793ff2d-9d80-407c-b521-85111c51028c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39053</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>914000000</pkc:Start>
			<pkc:End>917374999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{33eda5ad-ad65-4507-b585-abcac3cabae5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39055</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>940000000</pkc:Start>
			<pkc:End>940224999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38932</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>447949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38934</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>260000000</pkc:Start>
			<pkc:End>267349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{dca01e19-01f5-4ce1-98b1-35fb7a323806}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38935</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15382800</pkc:Start>
			<pkc:End>15832799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38937</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>426000000</pkc:Start>
			<pkc:End>433349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8dffd6e4-0497-4c35-b7d7-e47cf464cf30}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38939</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>972800000</pkc:Start>
			<pkc:End>972800099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3ce0211-9843-4d7e-9e38-a55ae0cd3c33}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38941</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>939500000</pkc:Start>
			<pkc:End>939500014</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8dffd6e4-0497-4c35-b7d7-e47cf464cf30}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38943</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>355000000</pkc:Start>
			<pkc:End>362499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f3ce0211-9843-4d7e-9e38-a55ae0cd3c33}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38945</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>939000000</pkc:Start>
			<pkc:End>939499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{358fb95b-0090-44fb-883a-75734e060c30}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38947</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927720000</pkc:Start>
			<pkc:End>927724999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{07328a5d-8dee-4d3b-9974-8a6ad6ab6892}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38949</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927767000</pkc:Start>
			<pkc:End>927767249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{50e329f7-a5fa-46b2-85fd-f224e5da7764}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38951</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927725000</pkc:Start>
			<pkc:End>927729999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d932ba14-a8cd-4368-aa5a-90d6613afea7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38953</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927767250</pkc:Start>
			<pkc:End>927767499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38955</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>867500000</pkc:Start>
			<pkc:End>867574999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38957</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>831000000</pkc:Start>
			<pkc:End>831004999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39035</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1032800</pkc:Start>
			<pkc:End>1082799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39035</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219491300</pkc:Start>
			<pkc:End>219493799</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>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39039</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199001300</pkc:Start>
			<pkc:End>199101299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39039</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337100000</pkc:Start>
			<pkc:End>337699999</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>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38973</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>451600000</pkc:Start>
			<pkc:End>451699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38975</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>971000000</pkc:Start>
			<pkc:End>971249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38977</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>451700000</pkc:Start>
			<pkc:End>451799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38979</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>867600000</pkc:Start>
			<pkc:End>867699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38981</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>867000000</pkc:Start>
			<pkc:End>867249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38983</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>867700000</pkc:Start>
			<pkc:End>867799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38985</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>451800000</pkc:Start>
			<pkc:End>451899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38987</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>971250000</pkc:Start>
			<pkc:End>971499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38989</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>451900000</pkc:Start>
			<pkc:End>451999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38991</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>867800000</pkc:Start>
			<pkc:End>867899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38993</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>867250000</pkc:Start>
			<pkc:End>867499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38995</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>867900000</pkc:Start>
			<pkc:End>867999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ae2ee509-1b34-41c0-acb7-6d4650168915}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39166</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>918500000</pkc:Start>
			<pkc:End>918500009</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1cb6d605-11b3-4e14-bb30-da91c8e3983a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39168</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>940225000</pkc:Start>
			<pkc:End>940225009</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b92e9980-b9d5-4821-9c94-140f632f6312}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39170</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>868000000</pkc:Start>
			<pkc:End>868000009</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{54a09a0d-d57b-4c10-8b69-a842d6590ad5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39172</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>831005000</pkc:Start>
			<pkc:End>831005009</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ae2ee509-1b34-41c0-acb7-6d4650168915}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39174</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>918500010</pkc:Start>
			<pkc:End>918500019</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1cb6d605-11b3-4e14-bb30-da91c8e3983a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39176</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>940225010</pkc:Start>
			<pkc:End>940225019</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b92e9980-b9d5-4821-9c94-140f632f6312}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39178</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>868000010</pkc:Start>
			<pkc:End>868000019</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{54a09a0d-d57b-4c10-8b69-a842d6590ad5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39180</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>831005010</pkc:Start>
			<pkc:End>831005019</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-39113</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1001800</pkc:Start>
			<pkc:End>1002799</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>{ac96e1a8-6cc4-4310-a4ff-332ce77fb5b8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-38999</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946672454</pkc:Start>
			<pkc:End>946674453</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b793ff2d-9d80-407c-b521-85111c51028c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-41859</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259760000</pkc:Start>
			<pkc:End>259760999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e7d060d-4714-40f2-9896-1e4f15b612ad}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-66479</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>30000000</pkc:Start>
			<pkc:End>30899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cab94894-574c-4ace-8b83-c89d121fda53}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89070</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>769000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cab94894-574c-4ace-8b83-c89d121fda53}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89070</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>996999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5f56dc78-0853-4465-81ec-88891d9624b0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89071</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>479000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5f56dc78-0853-4465-81ec-88891d9624b0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89071</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d880a111-2ba6-4838-9553-3da0f31d8eb5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89072</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>{d880a111-2ba6-4838-9553-3da0f31d8eb5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89072</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>360999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6841f362-8be0-4058-9c13-8f565ef1debb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89073</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e5cfead-eb89-4b28-87ba-a85917b1b95a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89074</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>255999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{82866d0f-354b-4dfc-bc75-8b925ba514db}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89075</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>580999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b2153262-12db-49d1-969a-9ca6b54cf93c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89076</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>725999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f7bc3d0d-ca9d-42ae-83e1-4fa46e0f4979}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89077</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>470000000</pkc:Start>
			<pkc:End>549999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f7bc3d0d-ca9d-42ae-83e1-4fa46e0f4979}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89077</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>617999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89078</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>{bbbb2a8a-aaee-4f56-a237-1e2cdc8039d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89079</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>201000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89080</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>596000000</pkc:Start>
			<pkc:End>612999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0a6eaa31-2181-4266-b7b3-6b6a0dd0af8a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89081</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>{0a6eaa31-2181-4266-b7b3-6b6a0dd0af8a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89081</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>380999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0a6eaa31-2181-4266-b7b3-6b6a0dd0af8a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89081</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>679000000</pkc:Start>
			<pkc:End>699999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ab761468-3ae8-4696-b762-e77f674ac0c1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89082</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>506999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ab761468-3ae8-4696-b762-e77f674ac0c1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89083</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>771000000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bd61de01-6b6a-4756-8103-2978e8c5c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89084</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926675000</pkc:Start>
			<pkc:End>926699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61944438-77f3-46d0-b434-0f340e01434c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89085</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926775000</pkc:Start>
			<pkc:End>926799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5fa5bf1b-c208-491c-846f-4faa3c98767a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89086</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926875000</pkc:Start>
			<pkc:End>926899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5757ccd7-4e7d-4723-a9a1-c5315263460d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89087</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926975000</pkc:Start>
			<pkc:End>926999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24371aee-296d-4398-940d-7612d0def8e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89116</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927775000</pkc:Start>
			<pkc:End>927799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89264</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>835750000</pkc:Start>
			<pkc:End>846999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f7bc3d0d-ca9d-42ae-83e1-4fa46e0f4979}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89118</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>912000000</pkc:Start>
			<pkc:End>941999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bbbb2a8a-aaee-4f56-a237-1e2cdc8039d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89122</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>990000000</pkc:Start>
			<pkc:End>998999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ab761468-3ae8-4696-b762-e77f674ac0c1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89128</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>951000000</pkc:Start>
			<pkc:End>953999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0af59e82-53c5-4564-87cd-ddad65d5509f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89129</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>783500000</pkc:Start>
			<pkc:End>785999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26cd687a-c069-49bd-adba-c622441a2d81}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89131</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>191000000</pkc:Start>
			<pkc:End>195999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89132</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>994700000</pkc:Start>
			<pkc:End>995999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d880a111-2ba6-4838-9553-3da0f31d8eb5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89134</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>873000000</pkc:Start>
			<pkc:End>892999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7438e626-0d47-4b81-83db-eeff76921fd7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89135</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>574000000</pkc:Start>
			<pkc:End>593999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e5cfead-eb89-4b28-87ba-a85917b1b95a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89136</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>875000000</pkc:Start>
			<pkc:End>887999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e5cfead-eb89-4b28-87ba-a85917b1b95a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89137</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>365000000</pkc:Start>
			<pkc:End>367999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26cd687a-c069-49bd-adba-c622441a2d81}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89138</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>754000000</pkc:Start>
			<pkc:End>756999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89139</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>297400000</pkc:Start>
			<pkc:End>305999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89117</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>337000000</pkc:Start>
			<pkc:End>338999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0af59e82-53c5-4564-87cd-ddad65d5509f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89144</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>874000000</pkc:Start>
			<pkc:End>874999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89145</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>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89147</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>723300000</pkc:Start>
			<pkc:End>726999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bd61de01-6b6a-4756-8103-2978e8c5c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89148</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937005000</pkc:Start>
			<pkc:End>937009999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61944438-77f3-46d0-b434-0f340e01434c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89149</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937000000</pkc:Start>
			<pkc:End>937004999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5fa5bf1b-c208-491c-846f-4faa3c98767a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89150</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937010000</pkc:Start>
			<pkc:End>937014999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5757ccd7-4e7d-4723-a9a1-c5315263460d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89151</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937015000</pkc:Start>
			<pkc:End>937019999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24371aee-296d-4398-940d-7612d0def8e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89152</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937020000</pkc:Start>
			<pkc:End>937024999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5757ccd7-4e7d-4723-a9a1-c5315263460d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89153</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937025000</pkc:Start>
			<pkc:End>937029999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24371aee-296d-4398-940d-7612d0def8e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89154</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937030000</pkc:Start>
			<pkc:End>937034999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bd61de01-6b6a-4756-8103-2978e8c5c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89159</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937035000</pkc:Start>
			<pkc:End>937039999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61944438-77f3-46d0-b434-0f340e01434c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89160</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937040000</pkc:Start>
			<pkc:End>937044999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5fa5bf1b-c208-491c-846f-4faa3c98767a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89162</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937045000</pkc:Start>
			<pkc:End>937049999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5757ccd7-4e7d-4723-a9a1-c5315263460d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89163</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937050000</pkc:Start>
			<pkc:End>937054999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24371aee-296d-4398-940d-7612d0def8e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89164</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937055000</pkc:Start>
			<pkc:End>937059999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5757ccd7-4e7d-4723-a9a1-c5315263460d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89166</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937060000</pkc:Start>
			<pkc:End>937064999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24371aee-296d-4398-940d-7612d0def8e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89167</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937065000</pkc:Start>
			<pkc:End>937069999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f1fe0f5e-7a50-4853-984d-9abd2dc05b6e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89170</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>918750000</pkc:Start>
			<pkc:End>918999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f1fe0f5e-7a50-4853-984d-9abd2dc05b6e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89171</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>919750000</pkc:Start>
			<pkc:End>919999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26cd687a-c069-49bd-adba-c622441a2d81}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89260</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>958030000</pkc:Start>
			<pkc:End>958999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89174</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>669550000</pkc:Start>
			<pkc:End>669999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89179</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>672820000</pkc:Start>
			<pkc:End>672999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0af59e82-53c5-4564-87cd-ddad65d5509f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89182</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>909640000</pkc:Start>
			<pkc:End>909999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89184</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>674850000</pkc:Start>
			<pkc:End>674999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ab761468-3ae8-4696-b762-e77f674ac0c1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89186</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>635705000</pkc:Start>
			<pkc:End>635999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26cd687a-c069-49bd-adba-c622441a2d81}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89188</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>992400000</pkc:Start>
			<pkc:End>992999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89189</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>769020000</pkc:Start>
			<pkc:End>771999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89191</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>676900000</pkc:Start>
			<pkc:End>676999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89197</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>948808000</pkc:Start>
			<pkc:End>949999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89212</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>611533704</pkc:Start>
			<pkc:End>615999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89261</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>145875000</pkc:Start>
			<pkc:End>145999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89262</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>219875000</pkc:Start>
			<pkc:End>219999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89218</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>436380000</pkc:Start>
			<pkc:End>436499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89120</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>938750000</pkc:Start>
			<pkc:End>939999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89220</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>307000000</pkc:Start>
			<pkc:End>311999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89221</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>192000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89222</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>142000000</pkc:Start>
			<pkc:End>151999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89228</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>96500000</pkc:Start>
			<pkc:End>103999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89230</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>170750000</pkc:Start>
			<pkc:End>176999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89232</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>62750000</pkc:Start>
			<pkc:End>73999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89235</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>964176625</pkc:Start>
			<pkc:End>964321299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89263</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>858529688</pkc:Start>
			<pkc:End>858676249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89241</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>906528600</pkc:Start>
			<pkc:End>906763799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89155</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336001000</pkc:Start>
			<pkc:End>336274150</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89156</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>857942500</pkc:Start>
			<pkc:End>858089999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89157</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>905492250</pkc:Start>
			<pkc:End>905822999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89158</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>956750000</pkc:Start>
			<pkc:End>956999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89161</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>851750000</pkc:Start>
			<pkc:End>851999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89165</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>892750000</pkc:Start>
			<pkc:End>892999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7f62a589-fc1c-4fc7-817b-90d565727ddb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89168</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>929750000</pkc:Start>
			<pkc:End>929999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89169</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>853750000</pkc:Start>
			<pkc:End>853999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89172</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>896125000</pkc:Start>
			<pkc:End>896199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7f62a589-fc1c-4fc7-817b-90d565727ddb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89173</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>933125000</pkc:Start>
			<pkc:End>933199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89175</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>954625000</pkc:Start>
			<pkc:End>954999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89176</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>847162500</pkc:Start>
			<pkc:End>847349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89177</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>890362500</pkc:Start>
			<pkc:End>890549999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89178</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>952875000</pkc:Start>
			<pkc:End>953499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89180</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>845600000</pkc:Start>
			<pkc:End>845799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89181</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>889600000</pkc:Start>
			<pkc:End>889799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89183</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>334500000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89187</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>846400000</pkc:Start>
			<pkc:End>846599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89190</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>891075000</pkc:Start>
			<pkc:End>891249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7f62a589-fc1c-4fc7-817b-90d565727ddb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89192</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927412500</pkc:Start>
			<pkc:End>927549999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89193</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>332250000</pkc:Start>
			<pkc:End>332999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89194</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>844750000</pkc:Start>
			<pkc:End>844999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89195</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>458000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7f62a589-fc1c-4fc7-817b-90d565727ddb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89196</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927962500</pkc:Start>
			<pkc:End>928099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{18aa7613-98ff-4820-9b69-1f69105ebba8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89121</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>73250000</pkc:Start>
			<pkc:End>75999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{78c95341-4f01-4e52-808a-e2f90fc56f71}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89123</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>228250000</pkc:Start>
			<pkc:End>230999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{903e621f-f23c-4ba0-b8de-40c3affff57d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89124</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>240250000</pkc:Start>
			<pkc:End>242999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{88e1193d-e891-41c4-b517-3a305a013695}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89125</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>120250000</pkc:Start>
			<pkc:End>122999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89126</pkc:PartNumber>
			<pkc:EulaType>MSDN</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>842125000</pkc:Start>
			<pkc:End>843499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89198</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>949125000</pkc:Start>
			<pkc:End>949499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89127</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>836125000</pkc:Start>
			<pkc:End>836499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89199</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>950100000</pkc:Start>
			<pkc:End>950299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89130</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>837100000</pkc:Start>
			<pkc:End>837299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89200</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>967674080</pkc:Start>
			<pkc:End>967749079</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89201</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>862761300</pkc:Start>
			<pkc:End>862817549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89202</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>912079763</pkc:Start>
			<pkc:End>912154762</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89204</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>967367135</pkc:Start>
			<pkc:End>967449079</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89205</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>864075300</pkc:Start>
			<pkc:End>864119549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89206</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>911755538</pkc:Start>
			<pkc:End>911854762</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89207</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>950525000</pkc:Start>
			<pkc:End>950599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89208</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>837525000</pkc:Start>
			<pkc:End>837599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89209</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>964696300</pkc:Start>
			<pkc:End>964821299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89210</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>859051250</pkc:Start>
			<pkc:End>859176249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89211</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>909032863</pkc:Start>
			<pkc:End>909157862</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89213</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU12</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>961250000</pkc:Start>
			<pkc:End>961999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89214</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU11</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>109250000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89215</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU9</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>963580100</pkc:Start>
			<pkc:End>963742599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89216</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU11</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>623250000</pkc:Start>
			<pkc:End>624999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89217</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU9</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>902600000</pkc:Start>
			<pkc:End>904499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89219</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU9</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>857100000</pkc:Start>
			<pkc:End>857499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89223</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761000</pkc:Start>
			<pkc:End>259761249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89224</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU10</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761250</pkc:Start>
			<pkc:End>259761299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89225</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU11</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761300</pkc:Start>
			<pkc:End>259761349</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7f62a589-fc1c-4fc7-817b-90d565727ddb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89226</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761350</pkc:Start>
			<pkc:End>259761374</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89227</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761375</pkc:Start>
			<pkc:End>259761399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89229</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU10</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761400</pkc:Start>
			<pkc:End>259761449</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89231</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761450</pkc:Start>
			<pkc:End>259761699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89233</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU10</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761700</pkc:Start>
			<pkc:End>259761749</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89234</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU11</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761750</pkc:Start>
			<pkc:End>259761799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89236</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU12</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761800</pkc:Start>
			<pkc:End>259761849</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{07a012bd-c5b1-483a-a3ac-20da32d44dec}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89237</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761850</pkc:Start>
			<pkc:End>259761874</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89238</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU9</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>269800000</pkc:Start>
			<pkc:End>269800049</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89239</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU9</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>269800050</pkc:Start>
			<pkc:End>269800099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89240</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU9</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>269800100</pkc:Start>
			<pkc:End>269800149</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89242</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259761900</pkc:Start>
			<pkc:End>259762399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89243</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259762400</pkc:Start>
			<pkc:End>259762649</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7f62a589-fc1c-4fc7-817b-90d565727ddb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89244</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>269800200</pkc:Start>
			<pkc:End>269800699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7f62a589-fc1c-4fc7-817b-90d565727ddb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89245</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259762650</pkc:Start>
			<pkc:End>259762899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89246</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>336000749</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89247</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000750</pkc:Start>
			<pkc:End>336000999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89248</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>269800700</pkc:Start>
			<pkc:End>269803199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89249</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259762900</pkc:Start>
			<pkc:End>259763399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{07a012bd-c5b1-483a-a3ac-20da32d44dec}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89250</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259763400</pkc:Start>
			<pkc:End>259763899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{07a012bd-c5b1-483a-a3ac-20da32d44dec}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89251</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>269803200</pkc:Start>
			<pkc:End>269803449</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b2153262-12db-49d1-969a-9ca6b54cf93c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89252</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>999000300</pkc:Start>
			<pkc:End>999000349</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61944438-77f3-46d0-b434-0f340e01434c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89253</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770700</pkc:Start>
			<pkc:End>927770749</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ab761468-3ae8-4696-b762-e77f674ac0c1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89254</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474910300</pkc:Start>
			<pkc:End>474910349</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f91bf45e-af5f-495a-8cab-5578e1c44da1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89255</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>652000000</pkc:Start>
			<pkc:End>652000049</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5757ccd7-4e7d-4723-a9a1-c5315263460d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89256</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770750</pkc:Start>
			<pkc:End>927770799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f1fe0f5e-7a50-4853-984d-9abd2dc05b6e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89265</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927820000</pkc:Start>
			<pkc:End>927820049</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{524e0c34-73ce-4198-9878-a53951c6f6b1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89257</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>335000000</pkc:Start>
			<pkc:End>335000049</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5fa5bf1b-c208-491c-846f-4faa3c98767a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89258</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927820050</pkc:Start>
			<pkc:End>927820099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26cd687a-c069-49bd-adba-c622441a2d81}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89259</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833800</pkc:Start>
			<pkc:End>15833849</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7438e626-0d47-4b81-83db-eeff76921fd7}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89089</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>681500600</pkc:Start>
			<pkc:End>681500649</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24371aee-296d-4398-940d-7612d0def8e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89090</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927820100</pkc:Start>
			<pkc:End>927820149</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89091</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833850</pkc:Start>
			<pkc:End>15833899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e5cfead-eb89-4b28-87ba-a85917b1b95a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89092</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>681500650</pkc:Start>
			<pkc:End>681500699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bd61de01-6b6a-4756-8103-2978e8c5c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89093</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927820150</pkc:Start>
			<pkc:End>927820199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89094</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678700500</pkc:Start>
			<pkc:End>678700549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61944438-77f3-46d0-b434-0f340e01434c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89095</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927820200</pkc:Start>
			<pkc:End>927820224</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5757ccd7-4e7d-4723-a9a1-c5315263460d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89096</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927820225</pkc:Start>
			<pkc:End>927820249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5fa5bf1b-c208-491c-846f-4faa3c98767a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89097</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927820250</pkc:Start>
			<pkc:End>927820274</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bd61de01-6b6a-4756-8103-2978e8c5c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89098</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927820275</pkc:Start>
			<pkc:End>927820299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{24371aee-296d-4398-940d-7612d0def8e2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89099</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770800</pkc:Start>
			<pkc:End>927770824</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ab761468-3ae8-4696-b762-e77f674ac0c1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89100</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>474910350</pkc:Start>
			<pkc:End>474910374</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f1fe0f5e-7a50-4853-984d-9abd2dc05b6e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89266</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>927770825</pkc:Start>
			<pkc:End>927770849</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{26cd687a-c069-49bd-adba-c622441a2d81}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89101</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833900</pkc:Start>
			<pkc:End>15833924</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{48fae3c8-9656-4147-bc80-5dd08c50d9bc}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89102</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>678700550</pkc:Start>
			<pkc:End>678700574</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{42d70d37-136a-4eba-9d21-b394a73b7516}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89103</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15833925</pkc:Start>
			<pkc:End>15833949</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{524e0c34-73ce-4198-9878-a53951c6f6b1}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89104</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>625999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6eb02c88-98e6-4623-8edd-59fed8fb5b11}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89133</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>917375000</pkc:Start>
			<pkc:End>918499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89105</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>447950000</pkc:Start>
			<pkc:End>451599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89106</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>267350000</pkc:Start>
			<pkc:End>269799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89107</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>433350000</pkc:Start>
			<pkc:End>435999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e16f11e3-ba84-48cb-af72-a7a0deafe0e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89108</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259744859</pkc:Start>
			<pkc:End>259744883</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e16f11e3-ba84-48cb-af72-a7a0deafe0e8}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89109</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>362500000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{61944438-77f3-46d0-b434-0f340e01434c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89111</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>937070000</pkc:Start>
			<pkc:End>937071249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{36c9cf6d-4b2b-4311-8552-e36d8c601781}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89112</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>834800000</pkc:Start>
			<pkc:End>834824999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{46bbed08-9c7b-48fc-a614-95250573f4ea}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89140</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259744884</pkc:Start>
			<pkc:End>259744886</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5a041529-fef8-4d07-b06f-b59b573b32d2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89141</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259744887</pkc:Start>
			<pkc:End>259744889</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{46bbed08-9c7b-48fc-a614-95250573f4ea}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89142</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259744890</pkc:Start>
			<pkc:End>259744892</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5a041529-fef8-4d07-b06f-b59b573b32d2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89143</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259744893</pkc:Start>
			<pkc:End>259744895</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{520130ee-efd4-4de0-99e0-565a86d7aeff}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89119</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259763900</pkc:Start>
			<pkc:End>259764399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6eb02c88-98e6-4623-8edd-59fed8fb5b11}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89267</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259764400</pkc:Start>
			<pkc:End>259764649</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d1786df-c824-49e4-8353-0525ee16c980}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-89268</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>30900000</pkc:Start>
			<pkc:End>31199999</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>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-17129</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>169250000</pkc:Start>
			<pkc:End>170749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-17130</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>168250000</pkc:Start>
			<pkc:End>169249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e838d943-63ed-4a0b-9fb1-47152908acc9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-17131</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>167250000</pkc:Start>
			<pkc:End>168249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0bdb55f8-df23-41e9-bd76-a3b9cc40d7ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-17132</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>827325000</pkc:Start>
			<pkc:End>827499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d2813f4-654e-4aad-9786-dba84bfe33d6}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-15091</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>874455000</pkc:Start>
			<pkc:End>874499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-11187</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>988400000</pkc:Start>
			<pkc:End>990999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{50e329f7-a5fa-46b2-85fd-f224e5da7764}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-11188</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>926774850</pkc:Start>
			<pkc:End>926774999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da22eadd-46dc-4056-a287-f5041c852470}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-11186</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>709600000</pkc:Start>
			<pkc:End>709999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-11184</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21400000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1027486-8ae8-4633-9cf9-9658ed80504d}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-11185</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>334600000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-68002</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>149990000</pkc:Start>
			<pkc:End>149999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-68002</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>203411300</pkc:Start>
			<pkc:End>203601299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-68003</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>88566900</pkc:Start>
			<pkc:End>92556899</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-68003</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>145010400</pkc:Start>
			<pkc:End>145040399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-68003</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>146010000</pkc:Start>
			<pkc:End>149989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9abf5984-9c16-46f2-ad1e-7fe15931a8dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-68005</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>200411300</pkc:Start>
			<pkc:End>203411299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4f00134f-b514-4626-a74b-a8ec7c8dfe92}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95554</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259000000</pkc:Start>
			<pkc:End>259000499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4f00134f-b514-4626-a74b-a8ec7c8dfe92}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95561</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>178000000</pkc:Start>
			<pkc:End>187999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4f00134f-b514-4626-a74b-a8ec7c8dfe92}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95563</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>290999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cff07cac-7534-4cc3-b3f3-99e1a0aa3c20}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95575</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>32999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cff07cac-7534-4cc3-b3f3-99e1a0aa3c20}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95575</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>201000000</pkc:Start>
			<pkc:End>216999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d24a2d0a-9cd3-4232-833f-ae3655b88425}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95562</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>188000000</pkc:Start>
			<pkc:End>189999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0e88bdae-f9a7-4e9d-9afe-9398459c4385}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95648</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>934000000</pkc:Start>
			<pkc:End>934499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0e88bdae-f9a7-4e9d-9afe-9398459c4385}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95649</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>934500000</pkc:Start>
			<pkc:End>934999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0e88bdae-f9a7-4e9d-9afe-9398459c4385}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95650</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>935000000</pkc:Start>
			<pkc:End>935499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{57c2bada-4fa1-410e-b9a7-92695078d46b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95449</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21302200</pkc:Start>
			<pkc:End>21302399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{974740ce-f7de-4f95-8404-01b53efdcb66}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95471</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21303200</pkc:Start>
			<pkc:End>21303399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{baebe09a-840e-452f-9e39-df34c8d38adc}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95483</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21304200</pkc:Start>
			<pkc:End>21304399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e5d2c2c7-9140-4fe9-9d3d-c0b106739e34}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95502</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>33000000</pkc:Start>
			<pkc:End>33999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e5d2c2c7-9140-4fe9-9d3d-c0b106739e34}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95502</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>122999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e5d2c2c7-9140-4fe9-9d3d-c0b106739e34}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95502</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>925000000</pkc:Start>
			<pkc:End>926999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e5d2c2c7-9140-4fe9-9d3d-c0b106739e34}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95535</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>928000000</pkc:Start>
			<pkc:End>928000099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e5d2c2c7-9140-4fe9-9d3d-c0b106739e34}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95545</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34000500</pkc:Start>
			<pkc:End>34005499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{373a038e-d9b7-4fcb-9788-1bb41b96e8b0}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95476</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21305750</pkc:Start>
			<pkc:End>21305849</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4beb680a-2f31-471c-a7fe-7a979ccf3d63}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95503</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>123000000</pkc:Start>
			<pkc:End>133999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4beb680a-2f31-471c-a7fe-7a979ccf3d63}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95536</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34006000</pkc:Start>
			<pkc:End>34006099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4beb680a-2f31-471c-a7fe-7a979ccf3d63}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95550</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34005500</pkc:Start>
			<pkc:End>34005999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7d39b06e-771b-41b7-9228-fe5fa91aa7a1}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95488</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34006400</pkc:Start>
			<pkc:End>34006499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ecde36bb-22f8-481b-93ab-d3fc1204f470}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95454</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21305250</pkc:Start>
			<pkc:End>21305349</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5e35dc43-389b-47c5-b889-2088b06738cb}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95450</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21302400</pkc:Start>
			<pkc:End>21302599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a63275f4-530c-48a7-b0d3-4f00d688d151}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95460</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>291000000</pkc:Start>
			<pkc:End>310999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a63275f4-530c-48a7-b0d3-4f00d688d151}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95466</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>456999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a63275f4-530c-48a7-b0d3-4f00d688d151}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95472</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21303400</pkc:Start>
			<pkc:End>21303599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b8a4bb91-69b1-460d-93f8-40e0670af04a}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95484</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21304400</pkc:Start>
			<pkc:End>21304599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e68b141f-4dfa-4387-b3b7-e65c4889216e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95640</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>911000000</pkc:Start>
			<pkc:End>911499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e68b141f-4dfa-4387-b3b7-e65c4889216e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95641</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>200500000</pkc:Start>
			<pkc:End>200999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e68b141f-4dfa-4387-b3b7-e65c4889216e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95642</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>908500000</pkc:Start>
			<pkc:End>908999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e68b141f-4dfa-4387-b3b7-e65c4889216e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95643</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>912000000</pkc:Start>
			<pkc:End>913999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e68b141f-4dfa-4387-b3b7-e65c4889216e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95645</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>909000000</pkc:Start>
			<pkc:End>909499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e68b141f-4dfa-4387-b3b7-e65c4889216e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95646</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>200000000</pkc:Start>
			<pkc:End>200499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e68b141f-4dfa-4387-b3b7-e65c4889216e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95647</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>908000000</pkc:Start>
			<pkc:End>908499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e68b141f-4dfa-4387-b3b7-e65c4889216e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95658</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>104015010</pkc:Start>
			<pkc:End>104015209</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e68b141f-4dfa-4387-b3b7-e65c4889216e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95664</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>104015210</pkc:Start>
			<pkc:End>104015409</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ee4e1629-bcdc-4b42-a68f-b92e135f78d7}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95500</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>231000000</pkc:Start>
			<pkc:End>242999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ee4e1629-bcdc-4b42-a68f-b92e135f78d7}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95500</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>973000000</pkc:Start>
			<pkc:End>974999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ee4e1629-bcdc-4b42-a68f-b92e135f78d7}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95518</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>897000000</pkc:Start>
			<pkc:End>901999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ee4e1629-bcdc-4b42-a68f-b92e135f78d7}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95520</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>910000000</pkc:Start>
			<pkc:End>910999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ee4e1629-bcdc-4b42-a68f-b92e135f78d7}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95525</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>37000000</pkc:Start>
			<pkc:End>39999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ee4e1629-bcdc-4b42-a68f-b92e135f78d7}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95531</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>40000000</pkc:Start>
			<pkc:End>44999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ee4e1629-bcdc-4b42-a68f-b92e135f78d7}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95537</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>104015410</pkc:Start>
			<pkc:End>104015509</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ee4e1629-bcdc-4b42-a68f-b92e135f78d7}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95546</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>104000010</pkc:Start>
			<pkc:End>104015009</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{153ebbcf-07f0-4fbc-b361-3b4b50f48617}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95461</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>65000000</pkc:Start>
			<pkc:End>69999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{153ebbcf-07f0-4fbc-b361-3b4b50f48617}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95467</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>105000000</pkc:Start>
			<pkc:End>109999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{153ebbcf-07f0-4fbc-b361-3b4b50f48617}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95477</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21305850</pkc:Start>
			<pkc:End>21305949</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{388fee2d-04ef-4825-b442-edb6295da3d8}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95489</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34006500</pkc:Start>
			<pkc:End>34006599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{96b172b7-0521-413b-820b-4beb463bdac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95501</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>134000000</pkc:Start>
			<pkc:End>144999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{96b172b7-0521-413b-820b-4beb463bdac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95519</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>875000000</pkc:Start>
			<pkc:End>875999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{96b172b7-0521-413b-820b-4beb463bdac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95526</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>874000000</pkc:Start>
			<pkc:End>874999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{96b172b7-0521-413b-820b-4beb463bdac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95532</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>873000000</pkc:Start>
			<pkc:End>873999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{96b172b7-0521-413b-820b-4beb463bdac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95538</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34022100</pkc:Start>
			<pkc:End>34022199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{96b172b7-0521-413b-820b-4beb463bdac9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95551</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34021600</pkc:Start>
			<pkc:End>34022099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e72d9987-5c60-45b2-a093-87392e88107e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95455</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21305350</pkc:Start>
			<pkc:End>21305449</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fddde785-e27d-4c62-8ec0-ed78e58d424f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95644</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU8</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>872000000</pkc:Start>
			<pkc:End>872999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{46d97ac9-1eab-4f29-ae77-f69d6fe70bed}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95539</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>972000000</pkc:Start>
			<pkc:End>972000009</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4de78642-0f7f-4b61-9392-8add86d70ae8}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95570</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>60000000</pkc:Start>
			<pkc:End>64999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4de78642-0f7f-4b61-9392-8add86d70ae8}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95572</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>74000000</pkc:Start>
			<pkc:End>74999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5a79ecd8-d33f-406c-a619-7785899b5d59}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95446</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>13500000</pkc:Start>
			<pkc:End>13999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5a79ecd8-d33f-406c-a619-7785899b5d59}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95448</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21302000</pkc:Start>
			<pkc:End>21302199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95601</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>461000000</pkc:Start>
			<pkc:End>462999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95603</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>424000000</pkc:Start>
			<pkc:End>424499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95635</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>55000000</pkc:Start>
			<pkc:End>55499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95636</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>466500000</pkc:Start>
			<pkc:End>466999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95637</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>55500000</pkc:Start>
			<pkc:End>55999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95638</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>56000000</pkc:Start>
			<pkc:End>56499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95639</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>56500000</pkc:Start>
			<pkc:End>56999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95651</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>463000000</pkc:Start>
			<pkc:End>464999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95653</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>465000000</pkc:Start>
			<pkc:End>465499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95654</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>465500000</pkc:Start>
			<pkc:End>465999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95655</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>466000000</pkc:Start>
			<pkc:End>466499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95656</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34022200</pkc:Start>
			<pkc:End>34022399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95657</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34022400</pkc:Start>
			<pkc:End>34022599</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9ccffaf9-86a2-414e-b031-b2f777720e90}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95663</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34022600</pkc:Start>
			<pkc:End>34022799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95498</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>220000000</pkc:Start>
			<pkc:End>230999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95498</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>838000000</pkc:Start>
			<pkc:End>840999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95504</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>700000000</pkc:Start>
			<pkc:End>784999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95508</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>835000000</pkc:Start>
			<pkc:End>835999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95512</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>836000000</pkc:Start>
			<pkc:End>836999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95516</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>370000000</pkc:Start>
			<pkc:End>372999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95523</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>57000000</pkc:Start>
			<pkc:End>59999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95527</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>45000000</pkc:Start>
			<pkc:End>49999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95529</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>50000000</pkc:Start>
			<pkc:End>54999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95533</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34022800</pkc:Start>
			<pkc:End>34024299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95544</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34024300</pkc:Start>
			<pkc:End>34029299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95555</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>199999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95557</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>13000000</pkc:Start>
			<pkc:End>13499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c1e88de3-96c4-4563-ad7d-775f65b1e670}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95559</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>414000000</pkc:Start>
			<pkc:End>423999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c33001fc-5e9c-4f27-8c05-e0154adb0db4}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95458</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>{c33001fc-5e9c-4f27-8c05-e0154adb0db4}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95464</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>471000000</pkc:Start>
			<pkc:End>495999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c33001fc-5e9c-4f27-8c05-e0154adb0db4}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95470</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21303000</pkc:Start>
			<pkc:End>21303199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cf3c5b35-35ff-4c95-9bbd-a188e47ad14c}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95482</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21304000</pkc:Start>
			<pkc:End>21304199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f9d22a-65f5-49a7-90fe-06491b4fc379}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95574</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>1000099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{017935c3-4ed2-427a-aedf-55129321a285}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95459</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>14000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{017935c3-4ed2-427a-aedf-55129321a285}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95465</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>87000000</pkc:Start>
			<pkc:End>91999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{017935c3-4ed2-427a-aedf-55129321a285}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95475</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21305650</pkc:Start>
			<pkc:End>21305749</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01df6f02-29d6-487d-b3a1-95dcf42c10e6}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95571</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>177000000</pkc:Start>
			<pkc:End>177249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01df6f02-29d6-487d-b3a1-95dcf42c10e6}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95573</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>177250000</pkc:Start>
			<pkc:End>177499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{05bce0e7-2ed5-4876-afb3-5844ffc90f40}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95447</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21000000</pkc:Start>
			<pkc:End>21299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{05bce0e7-2ed5-4876-afb3-5844ffc90f40}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95453</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21305150</pkc:Start>
			<pkc:End>21305249</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95499</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>2000000</pkc:Start>
			<pkc:End>9999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95505</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>145000000</pkc:Start>
			<pkc:End>159999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95509</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>822000000</pkc:Start>
			<pkc:End>822249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95513</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>822250000</pkc:Start>
			<pkc:End>822499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95517</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>829000000</pkc:Start>
			<pkc:End>830999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95524</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>825000000</pkc:Start>
			<pkc:End>825999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95528</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>826000000</pkc:Start>
			<pkc:End>826999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95530</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>827000000</pkc:Start>
			<pkc:End>827999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95534</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34029810</pkc:Start>
			<pkc:End>34029909</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95549</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34029310</pkc:Start>
			<pkc:End>34029809</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95556</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>831000000</pkc:Start>
			<pkc:End>831999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95558</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>164000000</pkc:Start>
			<pkc:End>164499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95560</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>160000000</pkc:Start>
			<pkc:End>161999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b20418a8-a3d4-4296-8cc0-e7ed07267a04}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95487</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34006300</pkc:Start>
			<pkc:End>34006399</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b20418a8-a3d4-4296-8cc0-e7ed07267a04}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95576</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21305000</pkc:Start>
			<pkc:End>21305149</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bc95c3ad-bb46-4b09-b130-51665ef87e3b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95602</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU6</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>162000000</pkc:Start>
			<pkc:End>162999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bc95c3ad-bb46-4b09-b130-51665ef87e3b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95652</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU8</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>163000000</pkc:Start>
			<pkc:End>163999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{69ffd12a-074f-4ab0-b654-99a2e278faeb}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95485</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21304600</pkc:Start>
			<pkc:End>21304799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8b51f6c7-0b38-4487-83ff-bd3289c6292d}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95542</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946000000</pkc:Start>
			<pkc:End>946000099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8b51f6c7-0b38-4487-83ff-bd3289c6292d}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95548</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>946000100</pkc:Start>
			<pkc:End>946005099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8d84e167-c8ad-469f-a2b2-00b154668f70}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95451</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21302600</pkc:Start>
			<pkc:End>21302799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac605e70-4f18-45ca-a99c-190e4b047cd1}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95462</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>165000000</pkc:Start>
			<pkc:End>174999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac605e70-4f18-45ca-a99c-190e4b047cd1}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95468</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>243000000</pkc:Start>
			<pkc:End>252999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ac605e70-4f18-45ca-a99c-190e4b047cd1}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95473</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21303600</pkc:Start>
			<pkc:End>21303799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{114e0c1a-1aa5-47a2-8d38-8eb3b51cdbb6}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95456</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21305450</pkc:Start>
			<pkc:End>21305549</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e822a96-f12b-4f9a-a638-6c567060d877}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95480</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21300000</pkc:Start>
			<pkc:End>21300999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e822a96-f12b-4f9a-a638-6c567060d877}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95481</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21301000</pkc:Start>
			<pkc:End>21301999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2e822a96-f12b-4f9a-a638-6c567060d877}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95490</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34006600</pkc:Start>
			<pkc:End>34006699</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6e358ec7-1224-432e-aed8-955fb11a08bd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95543</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>971000000</pkc:Start>
			<pkc:End>971000099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6e358ec7-1224-432e-aed8-955fb11a08bd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95553</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34000000</pkc:Start>
			<pkc:End>34000499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8c17fbea-5586-4807-aafe-0d8181c36ff5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95463</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>70000000</pkc:Start>
			<pkc:End>71999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8c17fbea-5586-4807-aafe-0d8181c36ff5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95469</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>35000000</pkc:Start>
			<pkc:End>36999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8c17fbea-5586-4807-aafe-0d8181c36ff5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95478</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34006100</pkc:Start>
			<pkc:End>34006199</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95583</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>98000000</pkc:Start>
			<pkc:End>99999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95588</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>102000000</pkc:Start>
			<pkc:End>103999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95596</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>968000000</pkc:Start>
			<pkc:End>969999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95659</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34054910</pkc:Start>
			<pkc:End>34055109</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95660</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34055110</pkc:Start>
			<pkc:End>34055309</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95661</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34055310</pkc:Start>
			<pkc:End>34055509</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95662</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34055510</pkc:Start>
			<pkc:End>34055709</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{57a232fe-0931-48fe-9389-e4586967c661}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95474</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21303800</pkc:Start>
			<pkc:End>21303999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8ec16e01-e86f-415f-b333-1819f4145294}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95566</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>313000000</pkc:Start>
			<pkc:End>316999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8ec16e01-e86f-415f-b333-1819f4145294}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95566</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>373000000</pkc:Start>
			<pkc:End>373999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8ec16e01-e86f-415f-b333-1819f4145294}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95568</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>317000000</pkc:Start>
			<pkc:End>317999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b2c4b9f6-3ee6-4a2a-a361-64ad3b61ded5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95486</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21304800</pkc:Start>
			<pkc:End>21304999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bba42084-cacd-4ad4-b606-9f3d6c93b2c5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95452</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21302800</pkc:Start>
			<pkc:End>21302999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c619d61c-c2f2-40c3-ab3f-c5924314b0f3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95492</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>318000000</pkc:Start>
			<pkc:End>319999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c619d61c-c2f2-40c3-ab3f-c5924314b0f3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95494</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>320000000</pkc:Start>
			<pkc:End>321999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c619d61c-c2f2-40c3-ab3f-c5924314b0f3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95496</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>383000000</pkc:Start>
			<pkc:End>404999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c619d61c-c2f2-40c3-ab3f-c5924314b0f3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95506</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>948000000</pkc:Start>
			<pkc:End>948999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c619d61c-c2f2-40c3-ab3f-c5924314b0f3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95510</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>949000000</pkc:Start>
			<pkc:End>949999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c619d61c-c2f2-40c3-ab3f-c5924314b0f3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95514</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>378000000</pkc:Start>
			<pkc:End>382999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c619d61c-c2f2-40c3-ab3f-c5924314b0f3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95521</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>96000000</pkc:Start>
			<pkc:End>97999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c619d61c-c2f2-40c3-ab3f-c5924314b0f3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95540</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34055710</pkc:Start>
			<pkc:End>34057209</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c619d61c-c2f2-40c3-ab3f-c5924314b0f3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95547</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34029910</pkc:Start>
			<pkc:End>34054909</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95585</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>100000000</pkc:Start>
			<pkc:End>100499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95586</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>100500000</pkc:Start>
			<pkc:End>100999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95587</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU4</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>101000000</pkc:Start>
			<pkc:End>101499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95590</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>101500000</pkc:Start>
			<pkc:End>101999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95591</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>964000000</pkc:Start>
			<pkc:End>964499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95592</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU3</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368500000</pkc:Start>
			<pkc:End>368999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95593</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>967000000</pkc:Start>
			<pkc:End>967499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95594</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>368499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95595</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU1</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>970000000</pkc:Start>
			<pkc:End>970499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95598</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>970500000</pkc:Start>
			<pkc:End>970999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95599</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>965000000</pkc:Start>
			<pkc:End>965499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{436cef53-8387-4692-bb4a-9492cd82260e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95600</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU7</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>369000000</pkc:Start>
			<pkc:End>369499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3d30924b-bf77-489c-afbe-ecdba5988161}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95457</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21305550</pkc:Start>
			<pkc:End>21305649</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4af12fad-92f3-4f32-81f7-ff44c1b6474b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95567</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>322000000</pkc:Start>
			<pkc:End>322249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4af12fad-92f3-4f32-81f7-ff44c1b6474b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95569</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>322250000</pkc:Start>
			<pkc:End>322499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{628d8532-f53a-4861-a786-dd63ed6ac5b4}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95479</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34006200</pkc:Start>
			<pkc:End>34006299</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8bf50607-c8ce-4402-aaf8-92d2d63ab6c1}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95491</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>34006700</pkc:Start>
			<pkc:End>34006799</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ada98380-2f0c-4a45-893d-d6b124e7f31b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95493</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>323000000</pkc:Start>
			<pkc:End>324249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ada98380-2f0c-4a45-893d-d6b124e7f31b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95495</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>325000000</pkc:Start>
			<pkc:End>325999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ada98380-2f0c-4a45-893d-d6b124e7f31b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95497</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>76000000</pkc:Start>
			<pkc:End>86999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ada98380-2f0c-4a45-893d-d6b124e7f31b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95507</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>950000000</pkc:Start>
			<pkc:End>950249999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ada98380-2f0c-4a45-893d-d6b124e7f31b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95511</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>950250000</pkc:Start>
			<pkc:End>950499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ada98380-2f0c-4a45-893d-d6b124e7f31b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95515</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>943000000</pkc:Start>
			<pkc:End>943999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ada98380-2f0c-4a45-893d-d6b124e7f31b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95522</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>944000000</pkc:Start>
			<pkc:End>944999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ada98380-2f0c-4a45-893d-d6b124e7f31b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95541</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>942000000</pkc:Start>
			<pkc:End>942000099</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ada98380-2f0c-4a45-893d-d6b124e7f31b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95552</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>951000000</pkc:Start>
			<pkc:End>951000499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f294addd-20dd-46e6-bce7-01a15ef45e99}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95584</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU5</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>945000000</pkc:Start>
			<pkc:End>945999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f294addd-20dd-46e6-bce7-01a15ef45e99}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95589</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU6</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>375000000</pkc:Start>
			<pkc:End>375999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f294addd-20dd-46e6-bce7-01a15ef45e99}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95597</pkc:PartNumber>
			<pkc:EulaType>Retail:WAU8</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>20999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{92f06ba8-08e1-4156-b8b5-d38328f5b5d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-95499</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10000100</pkc:Start>
			<pkc:End>12999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{31f395ce-fc28-4a33-b676-81b109902ee8}</pkc:RefActConfigId>
			<pkc:PartNumber>X11-56958</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>11900028</pkc:Start>
			<pkc:End>11900028</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{31ac603c-0483-4db9-8006-1831517ae142}</pkc:RefActConfigId>
			<pkc:PartNumber>X11-56959</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>12000018</pkc:Start>
			<pkc:End>12000018</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3c2baabd-257f-4f5c-9c3e-e3112a1c939e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55277</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1270000</pkc:Start>
			<pkc:End>1299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fa0d7bfa-140f-4ca1-ae5b-e4a666549beb}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55279</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1330000</pkc:Start>
			<pkc:End>1359999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f4f5e8f4-7a61-40ce-8832-630a6eba038d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55699</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1500000</pkc:Start>
			<pkc:End>1519999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f4f5e8f4-7a61-40ce-8832-630a6eba038d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55700:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110792000</pkc:Start>
			<pkc:End>110796999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a1d8e513-d10f-479e-8963-b9f82c1bfa36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55701</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1520000</pkc:Start>
			<pkc:End>1539999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a1d8e513-d10f-479e-8963-b9f82c1bfa36}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55702:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110797000</pkc:Start>
			<pkc:End>110801999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b7b1d450-fb87-4054-84ee-5db525088124}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55272</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1120000</pkc:Start>
			<pkc:End>1149999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{93d59c57-b6e1-4c3d-8caf-204cd102a69a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55275</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1210000</pkc:Start>
			<pkc:End>1239999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ae486542-39df-4ec8-8483-ac502f5eed7f}</pkc:RefActConfigId>
			<pkc:PartNumber>X11-56955</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>11600010</pkc:Start>
			<pkc:End>11600010</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{de57e6db-74a6-4de2-9b45-6305085bd104}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55270</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1060000</pkc:Start>
			<pkc:End>1089999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{de57e6db-74a6-4de2-9b45-6305085bd104}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55274</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1180000</pkc:Start>
			<pkc:End>1209999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{de57e6db-74a6-4de2-9b45-6305085bd104}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55276</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1240000</pkc:Start>
			<pkc:End>1269999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{bdbaaa16-4622-4547-828b-abff92a18218}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55278</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1300000</pkc:Start>
			<pkc:End>1329999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e1f0bb5b-2421-4b7c-81a1-03643106421d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34618</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>164240000</pkc:Start>
			<pkc:End>164389999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d63ae00-7733-4e46-b0d0-ae0ab81d7638}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34630</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>167000000</pkc:Start>
			<pkc:End>170999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b41df512-845d-4384-a2d7-ace3f778bff5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34650</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1005500</pkc:Start>
			<pkc:End>1007999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d63ae00-7733-4e46-b0d0-ae0ab81d7638}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34632</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>199749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e1f0bb5b-2421-4b7c-81a1-03643106421d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34619:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>164390000</pkc:Start>
			<pkc:End>164539999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d63ae00-7733-4e46-b0d0-ae0ab81d7638}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34631:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>171000000</pkc:Start>
			<pkc:End>174999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b41df512-845d-4384-a2d7-ace3f778bff5}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34651:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1008000</pkc:Start>
			<pkc:End>1010499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1d63ae00-7733-4e46-b0d0-ae0ab81d7638}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34633:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>175000000</pkc:Start>
			<pkc:End>175749999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e1f0bb5b-2421-4b7c-81a1-03643106421d}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34617:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>164000000</pkc:Start>
			<pkc:End>164239999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7482e61b-c589-4b7f-8ecc-46d455ac3b87}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34818</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000128</pkc:Start>
			<pkc:End>1000138</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c0c97b05-e71a-4fe4-b234-4165f96250f6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34820</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000150</pkc:Start>
			<pkc:End>1000159</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34699</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>8000000</pkc:Start>
			<pkc:End>10999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34700</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>7000000</pkc:Start>
			<pkc:End>7499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34701</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>7500000</pkc:Start>
			<pkc:End>7999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34698</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1025500</pkc:Start>
			<pkc:End>1027999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-36422</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199990000</pkc:Start>
			<pkc:End>199999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34709</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>402000000</pkc:Start>
			<pkc:End>424999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34711</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>11500000</pkc:Start>
			<pkc:End>12999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34712</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>477000000</pkc:Start>
			<pkc:End>506999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34710</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>11000000</pkc:Start>
			<pkc:End>11499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-36423</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1028000</pkc:Start>
			<pkc:End>1037999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34702</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>312120000</pkc:Start>
			<pkc:End>312869999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34703</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>242000000</pkc:Start>
			<pkc:End>243999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34704</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>244000000</pkc:Start>
			<pkc:End>244999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34705</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>245000000</pkc:Start>
			<pkc:End>245999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34706</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>246000000</pkc:Start>
			<pkc:End>248999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34707</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>166730000</pkc:Start>
			<pkc:End>166879999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ae528f4-05c3-446e-90ea-a4fbd460b83a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34708</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>166880000</pkc:Start>
			<pkc:End>166999999</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>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34682</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>178450000</pkc:Start>
			<pkc:End>178624999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34685</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>109000000</pkc:Start>
			<pkc:End>109999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34689</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>239000000</pkc:Start>
			<pkc:End>239499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34680</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>237000000</pkc:Start>
			<pkc:End>237799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c74dc7f6-ea35-4bd7-9776-333ab5dddae6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34771</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>345000000</pkc:Start>
			<pkc:End>349909999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ea36520d-fbfe-4042-acd8-fe926781b615}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34724</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6920000</pkc:Start>
			<pkc:End>6922499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c74dc7f6-ea35-4bd7-9776-333ab5dddae6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34773</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>269000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34683:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>178625000</pkc:Start>
			<pkc:End>178799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34686:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34688:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>241900000</pkc:Start>
			<pkc:End>241999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34690:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>239500000</pkc:Start>
			<pkc:End>239999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34681:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>237800000</pkc:Start>
			<pkc:End>238599999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c74dc7f6-ea35-4bd7-9776-333ab5dddae6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34772:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>350000000</pkc:Start>
			<pkc:End>354909999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ea36520d-fbfe-4042-acd8-fe926781b615}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34725:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6922500</pkc:Start>
			<pkc:End>6924999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c74dc7f6-ea35-4bd7-9776-333ab5dddae6}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34774:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>469000000</pkc:Start>
			<pkc:End>469999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34684:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199750000</pkc:Start>
			<pkc:End>199989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{620e2b3d-09e7-42fd-802a-17a13652fe7a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34795</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000107</pkc:Start>
			<pkc:End>1000117</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4bcc8879-e699-4159-a810-f829566662ca}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34815</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000118</pkc:Start>
			<pkc:End>1000127</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b297426d-464d-4af1-abb2-3474aeecb878}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34687</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>240900000</pkc:Start>
			<pkc:End>240999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c74417bd-f079-42e5-91f0-8f08ec052cba}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34634</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>175750000</pkc:Start>
			<pkc:End>176299999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{eea69412-4907-4185-8322-2ce1be6912a3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34628</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000500</pkc:Start>
			<pkc:End>1002999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c74417bd-f079-42e5-91f0-8f08ec052cba}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34635:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>176300000</pkc:Start>
			<pkc:End>176849999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{eea69412-4907-4185-8322-2ce1be6912a3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34629:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1003000</pkc:Start>
			<pkc:End>1005499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{30e54fa6-ae6a-4523-b264-d7978e977d96}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34626:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>165840000</pkc:Start>
			<pkc:End>166079999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8a26851c-1c7e-48d3-a687-fbca9b9ac16b}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34627</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000021</pkc:Start>
			<pkc:End>1000031</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{63192b0b-20c9-49dc-9936-0a33d67f8c3a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34625</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000011</pkc:Start>
			<pkc:End>1000020</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{855d35f4-a334-46e7-b7d7-23fc1a22be65}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34816</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>{683b8d26-5471-4212-82fb-8148427ca281}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34622</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>165240000</pkc:Start>
			<pkc:End>165539999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{23af83d3-8520-491e-88fb-3f6d7ab3783a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34620</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>164540000</pkc:Start>
			<pkc:End>164889999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b4d69df9-cdc5-48aa-8b88-dcadf9b558ba}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34823</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>703845000</pkc:Start>
			<pkc:End>703859999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{855d35f4-a334-46e7-b7d7-23fc1a22be65}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34817:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>702820000</pkc:Start>
			<pkc:End>702969999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{683b8d26-5471-4212-82fb-8148427ca281}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34623:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>165540000</pkc:Start>
			<pkc:End>165839999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{23af83d3-8520-491e-88fb-3f6d7ab3783a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34621:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>164890000</pkc:Start>
			<pkc:End>165239999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{cda18cf3-c196-46ad-b289-60c072869994}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34624</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>1000010</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f14c8ee3-560d-441e-aee1-325c2e9ae74a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55283</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>732000000</pkc:Start>
			<pkc:End>733999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f14c8ee3-560d-441e-aee1-325c2e9ae74a}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55284:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>734000000</pkc:Start>
			<pkc:End>735999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9a159de8-d114-41d7-a5bf-d3574edb42fa}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55266</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>736000000</pkc:Start>
			<pkc:End>745999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9a159de8-d114-41d7-a5bf-d3574edb42fa}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55267:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>746000000</pkc:Start>
			<pkc:End>755999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34659</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>190000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a60c85a9-7eff-4690-8aa1-010ddf5d38f0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34654</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1015500</pkc:Start>
			<pkc:End>1017999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34662</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>228400000</pkc:Start>
			<pkc:End>231799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{039998e3-3ef5-4adf-b758-d25fa0128ff4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34641</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>166080000</pkc:Start>
			<pkc:End>166254999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{039998e3-3ef5-4adf-b758-d25fa0128ff4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34644</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>179000000</pkc:Start>
			<pkc:End>180999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{039998e3-3ef5-4adf-b758-d25fa0128ff4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34646</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>2000000</pkc:Start>
			<pkc:End>2999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{039998e3-3ef5-4adf-b758-d25fa0128ff4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34639</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>176850000</pkc:Start>
			<pkc:End>177649999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34664</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>4000000</pkc:Start>
			<pkc:End>4999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34656</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>272999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a60c85a9-7eff-4690-8aa1-010ddf5d38f0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34652</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1010500</pkc:Start>
			<pkc:End>1012999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34660</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>200000000</pkc:Start>
			<pkc:End>214199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34658:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>183000000</pkc:Start>
			<pkc:End>189999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a60c85a9-7eff-4690-8aa1-010ddf5d38f0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34655:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1018000</pkc:Start>
			<pkc:End>1020499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34663:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>231800000</pkc:Start>
			<pkc:End>235199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{039998e3-3ef5-4adf-b758-d25fa0128ff4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34642:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>166255000</pkc:Start>
			<pkc:End>166429999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{039998e3-3ef5-4adf-b758-d25fa0128ff4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34645:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>181000000</pkc:Start>
			<pkc:End>182999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{039998e3-3ef5-4adf-b758-d25fa0128ff4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34647:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>3000000</pkc:Start>
			<pkc:End>3999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{039998e3-3ef5-4adf-b758-d25fa0128ff4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34640:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>177650000</pkc:Start>
			<pkc:End>178449999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34665:Virtual</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>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34657:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>369999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a60c85a9-7eff-4690-8aa1-010ddf5d38f0}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34653:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1013000</pkc:Start>
			<pkc:End>1015499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34661:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>214200000</pkc:Start>
			<pkc:End>228399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{039998e3-3ef5-4adf-b758-d25fa0128ff4}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34643:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>166430000</pkc:Start>
			<pkc:End>166729999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{68531fb9-5511-4989-97be-d11a0f55633f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34649</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000042</pkc:Start>
			<pkc:End>1000052</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{da71774d-b2c9-4c42-bb7b-a66365d5abb2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34648</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000032</pkc:Start>
			<pkc:End>1000041</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34727</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>13000000</pkc:Start>
			<pkc:End>15999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34728</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>16000000</pkc:Start>
			<pkc:End>17999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34726</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6925000</pkc:Start>
			<pkc:End>6927499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34738</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>312870000</pkc:Start>
			<pkc:End>312879999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34737</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>702700000</pkc:Start>
			<pkc:End>702819999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34739</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>507000000</pkc:Start>
			<pkc:End>529999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34741</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>627000000</pkc:Start>
			<pkc:End>628499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34742</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>580999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34740</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>628500000</pkc:Start>
			<pkc:End>628999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-36425</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259990000</pkc:Start>
			<pkc:End>259999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34729</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>260000000</pkc:Start>
			<pkc:End>261999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34730</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259240000</pkc:Start>
			<pkc:End>259989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34731</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>262000000</pkc:Start>
			<pkc:End>263999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34732</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>264000000</pkc:Start>
			<pkc:End>264999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34733</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>265000000</pkc:Start>
			<pkc:End>265999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34734</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>266000000</pkc:Start>
			<pkc:End>268999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34735</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>178800000</pkc:Start>
			<pkc:End>178949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34736</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>664800000</pkc:Start>
			<pkc:End>664919999</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>{1393c801-f389-4c5b-bb4e-bd7d3478ea60}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34670</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>20499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1393c801-f389-4c5b-bb4e-bd7d3478ea60}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34672</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236800000</pkc:Start>
			<pkc:End>236899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1393c801-f389-4c5b-bb4e-bd7d3478ea60}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34674</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21000000</pkc:Start>
			<pkc:End>21499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1393c801-f389-4c5b-bb4e-bd7d3478ea60}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34667</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>235200000</pkc:Start>
			<pkc:End>235999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{280f12e2-5412-4482-9004-b4c90a66e829}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34691</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6000000</pkc:Start>
			<pkc:End>6799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4d3ae49a-0bea-4cea-9a9f-a6fbdf699b28}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34678</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1020500</pkc:Start>
			<pkc:End>1022999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{280f12e2-5412-4482-9004-b4c90a66e829}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34693</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>240000000</pkc:Start>
			<pkc:End>240899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1393c801-f389-4c5b-bb4e-bd7d3478ea60}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34671:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20500000</pkc:Start>
			<pkc:End>20999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1393c801-f389-4c5b-bb4e-bd7d3478ea60}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34673:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236900000</pkc:Start>
			<pkc:End>236999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1393c801-f389-4c5b-bb4e-bd7d3478ea60}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34675:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21500000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1393c801-f389-4c5b-bb4e-bd7d3478ea60}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34668:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>236000000</pkc:Start>
			<pkc:End>236799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{280f12e2-5412-4482-9004-b4c90a66e829}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34692:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>238600000</pkc:Start>
			<pkc:End>238999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4d3ae49a-0bea-4cea-9a9f-a6fbdf699b28}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34679:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1023000</pkc:Start>
			<pkc:End>1025499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{280f12e2-5412-4482-9004-b4c90a66e829}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34694:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>241000000</pkc:Start>
			<pkc:End>241899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1393c801-f389-4c5b-bb4e-bd7d3478ea60}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34669:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1700000</pkc:Start>
			<pkc:End>1999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a78b8bd9-8017-4df5-b86a-09f756affa7c}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34677</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000063</pkc:Start>
			<pkc:End>1000073</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1bc49a17-9894-49c8-ba63-1b52852556a3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34676</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000053</pkc:Start>
			<pkc:End>1000062</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>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34748</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>341999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34749</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>364500000</pkc:Start>
			<pkc:End>364999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34747</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6987500</pkc:Start>
			<pkc:End>6989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-36426</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6990000</pkc:Start>
			<pkc:End>6999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34758</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34760</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>660000000</pkc:Start>
			<pkc:End>661499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34761</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>581000000</pkc:Start>
			<pkc:End>610999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34759</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>661500000</pkc:Start>
			<pkc:End>661999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-36427</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>664970000</pkc:Start>
			<pkc:End>664979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34750</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>463500000</pkc:Start>
			<pkc:End>463999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34751</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>549200000</pkc:Start>
			<pkc:End>549949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34752</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>333000000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34753</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>18000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34754</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>336999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34755</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>342000000</pkc:Start>
			<pkc:End>344999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34756</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>663800000</pkc:Start>
			<pkc:End>663949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{506fb694-7202-4d00-9069-f696ebf921f2}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34757</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>702970000</pkc:Start>
			<pkc:End>703089999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e3913f37-c311-4a0d-b603-ad3d61be9e39}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55265</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>729000000</pkc:Start>
			<pkc:End>730999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cbae191-195f-43b4-b53c-368b61652b74}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55282</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>731000000</pkc:Start>
			<pkc:End>731999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0e0d125d-173f-4752-8c1b-ced62118977f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-53994</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1573000</pkc:Start>
			<pkc:End>1577999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fe0e7d01-192a-47c1-858e-95df10baa491}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-53995</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>705000000</pkc:Start>
			<pkc:End>705999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fe0e7d01-192a-47c1-858e-95df10baa491}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-53996</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>707000000</pkc:Start>
			<pkc:End>707999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{402ffdaa-6813-424a-b07b-c31f8d24054e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-54011</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>708000000</pkc:Start>
			<pkc:End>708999999</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>{c837408d-3762-4dea-a4d7-6dba48f6c305}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-59687</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1578000</pkc:Start>
			<pkc:End>1580499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c837408d-3762-4dea-a4d7-6dba48f6c305}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-59688:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1580500</pkc:Start>
			<pkc:End>1582999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-59685</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>766000000</pkc:Start>
			<pkc:End>766999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6a4bd364-4b60-4856-a727-efb59d94348e}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-59686</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>767000000</pkc:Start>
			<pkc:End>767999999</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>{2b1690e6-1066-4b17-883f-4f759db1a7dd}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-59689</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1583000</pkc:Start>
			<pkc:End>1585499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fe0e7d01-192a-47c1-858e-95df10baa491}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-53995</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>706100000</pkc:Start>
			<pkc:End>706999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{fe0e7d01-192a-47c1-858e-95df10baa491}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-28780</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>706000000</pkc:Start>
			<pkc:End>706099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{862e432e-a461-42cf-b5dd-abc373943a4a}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-29893</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>768000000</pkc:Start>
			<pkc:End>769999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{db1b36e0-f543-4f4d-8ce6-814fa5dea00d}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-29892</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>704485000</pkc:Start>
			<pkc:End>704487499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{511bf083-7a59-4f5c-b41e-81c97e039fe9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-29906</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>776900000</pkc:Start>
			<pkc:End>777699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{511bf083-7a59-4f5c-b41e-81c97e039fe9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-29904</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>824000000</pkc:Start>
			<pkc:End>853999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{511bf083-7a59-4f5c-b41e-81c97e039fe9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-29902</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>801000000</pkc:Start>
			<pkc:End>823999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{511bf083-7a59-4f5c-b41e-81c97e039fe9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-29903</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>774900000</pkc:Start>
			<pkc:End>776399999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{511bf083-7a59-4f5c-b41e-81c97e039fe9}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-29905</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>776400000</pkc:Start>
			<pkc:End>776899999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{f772515c-0e87-48d5-a676-e6962c3e1195}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-29894</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000160</pkc:Start>
			<pkc:End>1000170</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{20fd891c-4d02-425c-9840-3f762d993737}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63156</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>624000000</pkc:Start>
			<pkc:End>624999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{20fd891c-4d02-425c-9840-3f762d993737}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63157:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>625000000</pkc:Start>
			<pkc:End>625999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63136</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302848000</pkc:Start>
			<pkc:End>302857999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63137:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302858000</pkc:Start>
			<pkc:End>302867999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63132</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1770000</pkc:Start>
			<pkc:End>1829999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63133:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1830000</pkc:Start>
			<pkc:End>1889999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63140</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>621000000</pkc:Start>
			<pkc:End>621999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63141:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>622000000</pkc:Start>
			<pkc:End>622999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63144</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>594000000</pkc:Start>
			<pkc:End>616999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63145:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>720000000</pkc:Start>
			<pkc:End>742999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63148</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>768000000</pkc:Start>
			<pkc:End>768499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e6df6197-1508-45e5-8ddd-3d07b674f5cd}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63150:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>768500000</pkc:Start>
			<pkc:End>768999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{780ac8a3-9312-4077-98a2-dd957cf8b7dc}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63160</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110851020</pkc:Start>
			<pkc:End>110851029</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9534497b-0bba-4fae-bf3d-1a7597eeb188}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63152</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110994500</pkc:Start>
			<pkc:End>110996999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8fcad604-c17b-4620-b073-470555f273d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63187</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>639000000</pkc:Start>
			<pkc:End>639999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8fcad604-c17b-4620-b073-470555f273d5}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63188:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>640000000</pkc:Start>
			<pkc:End>640999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63173</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>628000000</pkc:Start>
			<pkc:End>628999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63174:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>629000000</pkc:Start>
			<pkc:End>629999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63177</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>812000000</pkc:Start>
			<pkc:End>834999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63178:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>835000000</pkc:Start>
			<pkc:End>857999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63181</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>770000000</pkc:Start>
			<pkc:End>770499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63182:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>770500000</pkc:Start>
			<pkc:End>770999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63169</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302888000</pkc:Start>
			<pkc:End>302897999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63170:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302898000</pkc:Start>
			<pkc:End>302907999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63164</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110912000</pkc:Start>
			<pkc:End>110971999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{72d9dfa0-00bd-4152-8d49-11f16632d9a2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63165:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302768000</pkc:Start>
			<pkc:End>302827999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{82f26cca-d9f0-4259-be0f-7b86c382eec7}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63190</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110851040</pkc:Start>
			<pkc:End>110851049</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4ca3ecfc-432d-43f7-91c5-4d0226a07f41}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63184</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>129600000</pkc:Start>
			<pkc:End>129602499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1dbe6f30-a618-4909-ba6e-aa5a66f1e96a}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63154:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>623000000</pkc:Start>
			<pkc:End>623999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63138</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>619000000</pkc:Start>
			<pkc:End>619999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63139:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>620000000</pkc:Start>
			<pkc:End>620999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63142</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>305000000</pkc:Start>
			<pkc:End>327999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63143:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>571000000</pkc:Start>
			<pkc:End>593999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63146</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>767000000</pkc:Start>
			<pkc:End>767499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63147:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>767500000</pkc:Start>
			<pkc:End>767999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63135:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302838000</pkc:Start>
			<pkc:End>302847999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63131:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1710000</pkc:Start>
			<pkc:End>1769999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1dbe6f30-a618-4909-ba6e-aa5a66f1e96a}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63153</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>772000000</pkc:Start>
			<pkc:End>772999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63134</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302828000</pkc:Start>
			<pkc:End>302837999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{314d9cd5-b80b-46b9-b7d5-2dc3ae9e807f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63130</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1650000</pkc:Start>
			<pkc:End>1709999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{161135e2-8a99-42ee-912c-4161e4056d7c}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63158</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110851010</pkc:Start>
			<pkc:End>110851019</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{66c86c35-a315-468a-8dfd-b0a36f9d3584}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63151</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110992000</pkc:Start>
			<pkc:End>110994499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6b43d071-dbe7-472d-8c0f-d33295fcddd6}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63128</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>331000000</pkc:Start>
			<pkc:End>333499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6b43d071-dbe7-472d-8c0f-d33295fcddd6}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63129</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>196000000</pkc:Start>
			<pkc:End>196999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9a7ceac4-1f33-4e4b-a866-34f00b8a2438}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63186:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>638000000</pkc:Start>
			<pkc:End>638999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63171</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>626000000</pkc:Start>
			<pkc:End>626999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63172:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>627000000</pkc:Start>
			<pkc:End>627999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63175</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>743000000</pkc:Start>
			<pkc:End>765999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63176:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>789000000</pkc:Start>
			<pkc:End>811999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63179</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>769000000</pkc:Start>
			<pkc:End>769499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63180:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>769500000</pkc:Start>
			<pkc:End>769999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63168:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302878000</pkc:Start>
			<pkc:End>302887999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63163:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110852000</pkc:Start>
			<pkc:End>110911999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9a7ceac4-1f33-4e4b-a866-34f00b8a2438}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63185</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>637000000</pkc:Start>
			<pkc:End>637999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63166</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302868000</pkc:Start>
			<pkc:End>302877999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{722105e6-be37-4c48-9a08-4cd6a5e0bd55}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63161</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1890000</pkc:Start>
			<pkc:End>1949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29fb0edc-c2fd-413c-a72e-9fe36075c9de}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63189</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110851030</pkc:Start>
			<pkc:End>110851039</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{1a07362f-15ee-4af8-a374-75157d6b6fbb}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63183</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110997000</pkc:Start>
			<pkc:End>110999499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29b15bf5-8d7f-47e2-a0a7-ce1061254a0f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63224</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>419000000</pkc:Start>
			<pkc:End>419999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29b15bf5-8d7f-47e2-a0a7-ce1061254a0f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63232</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>601000000</pkc:Start>
			<pkc:End>623999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29b15bf5-8d7f-47e2-a0a7-ce1061254a0f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63228</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>418500000</pkc:Start>
			<pkc:End>418999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29b15bf5-8d7f-47e2-a0a7-ce1061254a0f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63240</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>333500000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29b15bf5-8d7f-47e2-a0a7-ce1061254a0f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63236</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>571000000</pkc:Start>
			<pkc:End>600999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29b15bf5-8d7f-47e2-a0a7-ce1061254a0f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63244</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20650000</pkc:Start>
			<pkc:End>20669999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29b15bf5-8d7f-47e2-a0a7-ce1061254a0f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63256</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20690000</pkc:Start>
			<pkc:End>20699999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29b15bf5-8d7f-47e2-a0a7-ce1061254a0f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63250</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>321000000</pkc:Start>
			<pkc:End>325999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{29b15bf5-8d7f-47e2-a0a7-ce1061254a0f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63220</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20705000</pkc:Start>
			<pkc:End>20705999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16cc978a-cf08-44f4-b02b-dfeb8bdacac2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63198</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>111000000</pkc:Start>
			<pkc:End>111999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16cc978a-cf08-44f4-b02b-dfeb8bdacac2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63196</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>88000000</pkc:Start>
			<pkc:End>110999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16cc978a-cf08-44f4-b02b-dfeb8bdacac2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63197</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>183000000</pkc:Start>
			<pkc:End>183499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16cc978a-cf08-44f4-b02b-dfeb8bdacac2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63199</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>13000000</pkc:Start>
			<pkc:End>14499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16cc978a-cf08-44f4-b02b-dfeb8bdacac2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63200</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>58000000</pkc:Start>
			<pkc:End>87999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6c47797a-fdba-4ac8-b402-d4b937bb7edb}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63194</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>5999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6c47797a-fdba-4ac8-b402-d4b937bb7edb}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63195</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>6000000</pkc:Start>
			<pkc:End>10999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16cc978a-cf08-44f4-b02b-dfeb8bdacac2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63191</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>11000000</pkc:Start>
			<pkc:End>12999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16cc978a-cf08-44f4-b02b-dfeb8bdacac2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63201</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>282460000</pkc:Start>
			<pkc:End>282479999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16cc978a-cf08-44f4-b02b-dfeb8bdacac2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63192</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>282440000</pkc:Start>
			<pkc:End>282459999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{16cc978a-cf08-44f4-b02b-dfeb8bdacac2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63202</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>267246000</pkc:Start>
			<pkc:End>267255999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d26969d7-e588-4ec8-9e52-911cbe0f744a}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63203</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>14502500</pkc:Start>
			<pkc:End>14502509</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3ff36ff8-6220-484c-9fb0-165ac44e0a91}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63193</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>14500000</pkc:Start>
			<pkc:End>14502499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{005cf8e0-d40e-458f-8982-9ea5a37c080c}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63932:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>617000000</pkc:Start>
			<pkc:End>618999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4539dd83-aa84-4cb8-aa73-bc89daf53a3a}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63935:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>265000000</pkc:Start>
			<pkc:End>267999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b0830b97-08a6-4370-b4da-2d136616827e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63936</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>328000000</pkc:Start>
			<pkc:End>330999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b0830b97-08a6-4370-b4da-2d136616827e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63937</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1950000</pkc:Start>
			<pkc:End>1999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{005cf8e0-d40e-458f-8982-9ea5a37c080c}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63931</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>268000000</pkc:Start>
			<pkc:End>269999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{4539dd83-aa84-4cb8-aa73-bc89daf53a3a}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63934</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>262000000</pkc:Start>
			<pkc:End>264999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{ba480d59-94fc-46de-81f7-baf821e43488}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63933</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>129602500</pkc:Start>
			<pkc:End>129604999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63226</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>336000000</pkc:Start>
			<pkc:End>336999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63234</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63230</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>420000000</pkc:Start>
			<pkc:End>420499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63242</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>417000000</pkc:Start>
			<pkc:End>418499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63238</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>939000000</pkc:Start>
			<pkc:End>968999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-73216:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>86000000</pkc:Start>
			<pkc:End>115999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0957c488-4993-4b07-a2a4-0097b2f8c37d}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63211</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15000000</pkc:Start>
			<pkc:End>16999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0957c488-4993-4b07-a2a4-0097b2f8c37d}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63208</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>8000000</pkc:Start>
			<pkc:End>14999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0957c488-4993-4b07-a2a4-0097b2f8c37d}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63216</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>415000000</pkc:Start>
			<pkc:End>416999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63246</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20670000</pkc:Start>
			<pkc:End>20689999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63258</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81587000</pkc:Start>
			<pkc:End>81596999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63252</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>326000000</pkc:Start>
			<pkc:End>330999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63248</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>427000000</pkc:Start>
			<pkc:End>428999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a685cfa9-39ff-4d7d-a7ff-26e492314852}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63222</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20706000</pkc:Start>
			<pkc:End>20706999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{b5f35387-daeb-4901-a253-c6001f14fda7}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63260</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20707000</pkc:Start>
			<pkc:End>20707009</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2b756fa4-e8d3-4eac-8722-07b044e7b6b1}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63219</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20702500</pkc:Start>
			<pkc:End>20704999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a2855032-266b-45e6-8739-311652feeb28}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63212:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15000000</pkc:Start>
			<pkc:End>16999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a2855032-266b-45e6-8739-311652feeb28}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63209:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>8000000</pkc:Start>
			<pkc:End>14999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a2855032-266b-45e6-8739-311652feeb28}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63217:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>79000000</pkc:Start>
			<pkc:End>80999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63227:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>85000000</pkc:Start>
			<pkc:End>85999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63235:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>51000000</pkc:Start>
			<pkc:End>73999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63247:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>215850000</pkc:Start>
			<pkc:End>215869999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63231:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>50500000</pkc:Start>
			<pkc:End>50999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63259:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>215870000</pkc:Start>
			<pkc:End>215879999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63253:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>74000000</pkc:Start>
			<pkc:End>78999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63249:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>81000000</pkc:Start>
			<pkc:End>82999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63243:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>83000000</pkc:Start>
			<pkc:End>84499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{3180af80-a6fe-4521-99cd-98808707f510}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63223:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>84500000</pkc:Start>
			<pkc:End>84500999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63225:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>766000000</pkc:Start>
			<pkc:End>766999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63245:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>110972000</pkc:Start>
			<pkc:End>110991999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63229:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>771000000</pkc:Start>
			<pkc:End>771499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63257:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>302908000</pkc:Start>
			<pkc:End>302917999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63251:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>191000000</pkc:Start>
			<pkc:End>195999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63241:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>333500000</pkc:Start>
			<pkc:End>334999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63237:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>161000000</pkc:Start>
			<pkc:End>190999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63221:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>129605000</pkc:Start>
			<pkc:End>129605999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9bc8998c-0d54-4d44-b299-fb778ec57230}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63206</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>7999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9bc8998c-0d54-4d44-b299-fb778ec57230}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63213</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>17000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0dbe8d16-b9e1-435f-9fc8-5e011438eb4c}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63218</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20700000</pkc:Start>
			<pkc:End>20702499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{28e73646-24dc-4222-bf00-de8ded35ce13}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63207:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1000000</pkc:Start>
			<pkc:End>7999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{28e73646-24dc-4222-bf00-de8ded35ce13}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63215:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>17000000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{171ad3f3-e1f3-41e1-9d6f-0a0b9b6aba3f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63233:Virtual</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>864000000</pkc:Start>
			<pkc:End>886999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e1808e9b-b84c-4b3e-a351-d9820702720c}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63254</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>331000000</pkc:Start>
			<pkc:End>333499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e1808e9b-b84c-4b3e-a351-d9820702720c}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63255</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20600000</pkc:Start>
			<pkc:End>20649999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56cd5000-40b0-4e44-97a7-245191e7dfe3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55280</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1360000</pkc:Start>
			<pkc:End>1389999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{56cd5000-40b0-4e44-97a7-245191e7dfe3}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-55281</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1390000</pkc:Start>
			<pkc:End>1419999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5662c706-f571-4c83-9649-3916a56a2b74}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92699</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>773000000</pkc:Start>
			<pkc:End>774999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{5662c706-f571-4c83-9649-3916a56a2b74}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92700</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>775000000</pkc:Start>
			<pkc:End>776999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{74e20158-a356-46aa-bb8a-fc200f20a9c2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92701</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>129606000</pkc:Start>
			<pkc:End>129608499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92702</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>777000000</pkc:Start>
			<pkc:End>777999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c8ffd775-fd93-4b7d-b622-20244a71009b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92703</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>778000000</pkc:Start>
			<pkc:End>778999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{07acd797-a4c1-49d2-84a8-c08a14fb83b2}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92704</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>129608500</pkc:Start>
			<pkc:End>129610999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{31d69fd1-8967-417e-9464-59d6ca58190f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92705</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>779000000</pkc:Start>
			<pkc:End>781499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e267bacf-b3bf-45e5-a2ba-057855b3c59f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92706</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>858000000</pkc:Start>
			<pkc:End>880999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e267bacf-b3bf-45e5-a2ba-057855b3c59f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92713</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>771500000</pkc:Start>
			<pkc:End>771999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e267bacf-b3bf-45e5-a2ba-057855b3c59f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92708</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>570850000</pkc:Start>
			<pkc:End>570869999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e267bacf-b3bf-45e5-a2ba-057855b3c59f}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-92709</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>570870000</pkc:Start>
			<pkc:End>570879999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{e1808e9b-b84c-4b3e-a351-d9820702720c}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-63255</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>306010000</pkc:Start>
			<pkc:End>306059999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7a68f0c7-9dee-433d-b1da-e9779be95ab3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96359</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>551000000</pkc:Start>
			<pkc:End>573999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7a68f0c7-9dee-433d-b1da-e9779be95ab3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96360</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>574000000</pkc:Start>
			<pkc:End>596999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7a68f0c7-9dee-433d-b1da-e9779be95ab3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96361</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>259000000</pkc:Start>
			<pkc:End>259799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7a68f0c7-9dee-433d-b1da-e9779be95ab3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96362</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>95000000</pkc:Start>
			<pkc:End>95799999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7a68f0c7-9dee-433d-b1da-e9779be95ab3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96363</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>99000000</pkc:Start>
			<pkc:End>99499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{7a68f0c7-9dee-433d-b1da-e9779be95ab3}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96364</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>99500000</pkc:Start>
			<pkc:End>99999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{8402d835-3b9f-4cba-81f5-22922afa7366}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96351</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10000100</pkc:Start>
			<pkc:End>10000109</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96311</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>172000000</pkc:Start>
			<pkc:End>194999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96312</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>339000000</pkc:Start>
			<pkc:End>361999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96319</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>11000000</pkc:Start>
			<pkc:End>12499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96320</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>13000000</pkc:Start>
			<pkc:End>14499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96327</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>29000000</pkc:Start>
			<pkc:End>58999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96328</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>59000000</pkc:Start>
			<pkc:End>88999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96335</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>92500000</pkc:Start>
			<pkc:End>92999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96336</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>94500000</pkc:Start>
			<pkc:End>94999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96343</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>95950000</pkc:Start>
			<pkc:End>95959999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{d91b7562-a935-4752-a42f-f6614fe708be}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96344</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>95960000</pkc:Start>
			<pkc:End>95969999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c135606-f8d0-4b88-8bca-78403696e1ef}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96356</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10900000</pkc:Start>
			<pkc:End>10999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c135606-f8d0-4b88-8bca-78403696e1ef}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96365</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>100200000</pkc:Start>
			<pkc:End>100202499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{9c135606-f8d0-4b88-8bca-78403696e1ef}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96368</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>95800000</pkc:Start>
			<pkc:End>95949999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96305</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>12500000</pkc:Start>
			<pkc:End>12999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96306</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>14500000</pkc:Start>
			<pkc:End>14999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96313</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>368000000</pkc:Start>
			<pkc:End>390999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96314</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>391000000</pkc:Start>
			<pkc:End>413999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96321</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>15000000</pkc:Start>
			<pkc:End>16499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96322</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>17000000</pkc:Start>
			<pkc:End>18499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96329</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>112000000</pkc:Start>
			<pkc:End>141999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96330</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>142000000</pkc:Start>
			<pkc:End>171999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96337</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>96000000</pkc:Start>
			<pkc:End>96499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96338</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>96500000</pkc:Start>
			<pkc:End>96999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96345</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>95970000</pkc:Start>
			<pkc:End>95979999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0cb1d6b4-3c07-487f-82fc-886d44a646aa}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96346</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>95980000</pkc:Start>
			<pkc:End>95989999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{2d727362-1f80-4a74-9e4d-e7c79826e659}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96352</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10000110</pkc:Start>
			<pkc:End>10000119</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{46c2cc67-6a50-4a66-8048-9334f4a3914e}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96353</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10000120</pkc:Start>
			<pkc:End>10000129</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96307</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>16500000</pkc:Start>
			<pkc:End>16999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96308</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>18500000</pkc:Start>
			<pkc:End>18999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96315</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>437000000</pkc:Start>
			<pkc:End>459999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96316</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>471000000</pkc:Start>
			<pkc:End>493999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96323</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>20000000</pkc:Start>
			<pkc:End>21499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96324</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>89000000</pkc:Start>
			<pkc:End>90499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96331</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>199000000</pkc:Start>
			<pkc:End>228999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96332</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>229000000</pkc:Start>
			<pkc:End>258999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96339</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>97000000</pkc:Start>
			<pkc:End>97499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96340</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>97500000</pkc:Start>
			<pkc:End>97999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96347</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>95990000</pkc:Start>
			<pkc:End>95999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{47188d7c-b5ef-4336-91a9-3857b219fe95}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96348</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>195150000</pkc:Start>
			<pkc:End>195159999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{a7dad4b1-8065-4576-9e61-2fd025fe16cc}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96354</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10000130</pkc:Start>
			<pkc:End>10000139</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c60b048b-8071-4532-8398-f15f4c981861}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96357</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>100000000</pkc:Start>
			<pkc:End>100099999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c60b048b-8071-4532-8398-f15f4c981861}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96366</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1015000</pkc:Start>
			<pkc:End>1017499</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c60b048b-8071-4532-8398-f15f4c981861}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96369</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>195000000</pkc:Start>
			<pkc:End>195149999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{01fd368f-a172-45d7-b147-273aa1aba00b}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96355</pkc:PartNumber>
			<pkc:EulaType>EVAL</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>10000140</pkc:Start>
			<pkc:End>10000149</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96309</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>21500000</pkc:Start>
			<pkc:End>21999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96310</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>90500000</pkc:Start>
			<pkc:End>90999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96317</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>494000000</pkc:Start>
			<pkc:End>516999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96318</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>517000000</pkc:Start>
			<pkc:End>539999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96325</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>91000000</pkc:Start>
			<pkc:End>92499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96326</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>93000000</pkc:Start>
			<pkc:End>94499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96333</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>271000000</pkc:Start>
			<pkc:End>300999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96334</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>301000000</pkc:Start>
			<pkc:End>330999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96341</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>98000000</pkc:Start>
			<pkc:End>98499999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96342</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>98500000</pkc:Start>
			<pkc:End>98999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96349</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>195160000</pkc:Start>
			<pkc:End>195169999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{643144fe-8557-4a94-bc0d-5a8348398156}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96350</pkc:PartNumber>
			<pkc:EulaType>Retail</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>195170000</pkc:Start>
			<pkc:End>195179999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0eee96cb-116a-4109-852a-e3797b6c4260}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96358</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>100100000</pkc:Start>
			<pkc:End>100199999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0eee96cb-116a-4109-852a-e3797b6c4260}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96367</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>1017500</pkc:Start>
			<pkc:End>1019999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{0eee96cb-116a-4109-852a-e3797b6c4260}</pkc:RefActConfigId>
			<pkc:PartNumber>X16-96370</pkc:PartNumber>
			<pkc:EulaType>Volume</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>195200000</pkc:Start>
			<pkc:End>195349999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X17-07629</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>273000000</pkc:Start>
			<pkc:End>273209999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X17-07630:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>370000000</pkc:Start>
			<pkc:End>370209999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c74dc7f6-ea35-4bd7-9776-333ab5dddae6}</pkc:RefActConfigId>
			<pkc:PartNumber>X17-07631</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>349910000</pkc:Start>
			<pkc:End>349999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{c74dc7f6-ea35-4bd7-9776-333ab5dddae6}</pkc:RefActConfigId>
			<pkc:PartNumber>X17-07632:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>354910000</pkc:Start>
			<pkc:End>354999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34656</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>273210000</pkc:Start>
			<pkc:End>304999999</pkc:End>
		</pkc:KeyRange><pkc:KeyRange>
			<pkc:RefActConfigId>{6d47464d-e43d-4228-b051-fddd47fd403f}</pkc:RefActConfigId>
			<pkc:PartNumber>X15-34657:Virtual</pkc:PartNumber>
			<pkc:EulaType>OEM</pkc:EulaType>
			<pkc:IsValid>true</pkc:IsValid>
			<pkc:Start>370210000</pkc:Start>
			<pkc:End>401999999</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>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>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>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>168</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>d2ZVRAABAAEzAQAAMyIRAAABAAEADg4DAAAAAgAAAAAAAAAAAAAAAAAAAA4AAAApAAAAyAAAAB8AAAAjAQMIDw8PHwMDAwMDBz9lRlQkZQyCO4odm4yzK+95rQH3Rhg7ih2bjLMrBAEAAQIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADaFNTfbm0EpMA/0x9NAU3mwCIgcXWY/gwmaFsSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMrE6xe4tKdfquOTUb8E4OAsLct++Kjv6bQ5xAB6zT5X2UWDd2OHNFWADb9mMARPDbvWSGzaNmYm1kUR2k86VM2mNXjvjQUylq6zfM4ifmnhQmL/Dm3tJfGRfLa5jlhdrb8nAcmhF4OWOWU6fxN/LQRoy2wSIbxq9vOpFSs6CgwrzucK/YZYo83NZJEhGxQWR2FxiqgupV22BxHSZtnqEHPzhaNSmwohDgrgrcuB7foFAjdCz3sU+yLYKJYDEXCDkM5j6yJP/V1umCad9XSgolApDpRd+CGZStle4qNbuPkJvb/QjP0B1xZFXW2EHyr6DXnmsU/stjeCHTc3KzbRKSQJpKY2X2MiOdkKOGNN8LDFPSVdNvQP8xSUtoLxQGMA0ySZUMbdAI+gZdAyVfp8Cmv0alUGN5rg9US+5BiAM6LL5AsBvYHZsqSjm2SSQV/pBwIHOfnxjVYCEiWa/MwEH8EWmb7PG3coC5pWThCsUlXSwCHFEAg3fm4XDAm/n8ITFBnAxlvnEZsc9YDHfxZpWzvIOVs1HRadV197Ql6wJKpMFtrfJxF3zQXK7Frr5BbE3AUnIp+I9dlL7eWBCo0ugynpJ3k055H2wE6e+2P/FLy1ONPhsd9u0DCu9qwlau6SjiggJP03IT0G/SaDgEecOLn+MBBi37WNHdEEWV+JrmlMYxJ43TQM0pRs/4JtLVhG+fNU+wZ+sCt4caclMfknmn0mJ1445laIRN9+V+ReOJ4Am53P2vRmE71FJbaDuxXtMkEF64oSWHL/iGGtE8r4DhcxSluf7ZKiplocqpDEA8VoXSYkXrvUzwJE1SGuvS+JZcIqHJJ1KblWN3asGL1wKI0JtusaRWifekQiP+Pbal30aR4fR3p6kwlWX7NiNN9EFgrx07CgH1wlZOQ+FPwTiA8M87piSMv1k06GpxiddcZFrCi5UsJtA+4vKuWQTzCqZfrXKZeYSHUUVRlL3FuPhAWkEjOV3BWlUdzJBg9bi+4clbf6KhGOcfox1ArPXzaWNxIiZKAeumyMgyziCdFMohkAwCroW/8dj2guIIsxCMsDFEtk0sedYxMj9wsVQ1cMl1ds4TeHT0KmSwTBuJl9mOt8OO7zYsdOAonqEGg+iBdUy8IiflIZyk1yvsUaxe4s5YkMrA7JOY4XPG484hbjcb8bI3fug0Xc/a9mICYaGlEmP/tCxunDBog0dG//Yghgmg7BkRZd7Qhmme6lGNioT0VVxRyK2TxO7vgc5XmppmdgXDCKQBG9PxR9mIWn6oQxsGIZHD+JKtgFhx2zLMcMJnypaewLTre1kQFoXkEZl55+sw0+mo7qdJm10FbW4dHmBXvsu5rZBOEjBnpldjgkssKBGxoL3l8o+NFOngTyvO8gLDs3uvR+srIvG5VVjqHDoz1BhAjmp60AMKylyelPcHOJq8jWhQ4zb6e9vOal/6GKJC2BBK2v6IaNRr66ulGCOgElJ6bcy7ElKFpPk2ElKx3S16GJhsniaHQqBRtjC/4ujTZPhEiVvKPcs4IXiQll0mh7Gh/OFb4WpyjzPYnBFi6ITHRDIURsEuriHmPHaCY71R/p9BIPfKwDbjQ4G6J3Yjfhughn5zm6im5P3Yp8E0AxDxXsS+/l3a4AGkdrer4RNAnqhtsQBYJ6CvBM1B9rs1N4809j6TCkUUfvDQ==</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>170</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>174</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>d2ZVRAABAAEzAQAAMyIRAAABAAEADg4DAAAAAgAAAAAAAAAAAAAAAAAAAA4AAAApAAAAyAAAAB8AAAAjAQMIDw8PHwMDAwMDBz9lRlQkZQyCO4odm4yzK+95rQH3Rhg7ih2bjLMrBAEAAQIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADaFNTfbm0EpMA/0x9NAU3mwCIgcXWY/gwmaFsSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEraqb2LFFnk0VZAP/0bcHVdCs/wWxVq6BD5YSE22Ikf2tZroadwtT35JBe647LkqRSJnmeDjmIYkKMVTASZpwaRW90OdigGKu5qUY4jBBNMDN/ICy2qiII7TJbZhHv8bfMaeGjNb7Hx+xR6N9goWRszMGOd+H1GKMWjau8RE6mWvBFZlZm7gFFs2AMCIx+N4SyRZyxdRlFH0B1bOskbAy5/nsyE/EKqArCXt7zM4p/eqeQdc7QJVr7u9J+ijqtrdNYJzSiNI76ADpueFtttnux/Hw8OsEWfdbgfUc3dsT8UxJPZOCPyI7dexTQOHRBlPvNR7HkG5v7olC52DCEFW9k6Z712rRf3SF8m3K28RiH/IpCBMXebQSvkou4nSxbhqFDnpqTACKoVP5dWjC/lIBJprn8O6iIPfpMmAdCFeTOwaQnW+MrYBNlOcsZkzyrLCYdo43wk7S5N/aRjm2Ij91sfecYdkX1DLiLopg0CdGwDCYphxMaCN05SBNrYAtsIPwyBSqP9vzgNi3Cxh93GfTSi7qZ5DwCjxdIY8dF+RXZWV7bhGbd+UJKdXbSY3uIXq0cGNZJODKH5lteEqT+KIxZukaG1mI2rfWtJqEPmIrhYFw5c4JVYXsKDZD4rXjKbvBwo2otewS7ngBwYUymzK12xwwUZO/4NDu/0qW8Mf1h75YrjhZMrXxitoq8D6c5D/32p6AkKPuyYx0dUcK7jXZr5Eateu1JpYvU7Sc9CHg0orF7MvZo/sCCaFRTGEhqYNJavFIydi432ohZiGqlchQZ1nRrnbDiMO9kXCRsdT8NXH3aeSFAxsQuAh9kY4epBmfXbJGiQBipLUNaO2j4uVoPgHPwBzIwODZ2D2iYtuqzFQBP1c/TtFIdnH/c14qm7Cj/Uvc0cwgNOXrvsQUkVNE6LGNeSb42b0OjnVR7mNy1o1l0jOTei0OjUJkPIh9PQFbvuZQ8kI04odK59sewmvjAYJkO/wQPQINHdf4pq6xZ7LDdtGmkJqFXXEK8kpI/NMwQocCnBppHVsFl8XADqrRTVo2bHiAHdH8lbYRZeF6waGnml38AyMsSCAD4Bph4TNmsWtd5kZVjN/QW5URBBJcpojdDR2CTrJOocZ7CuoegcXARSM0oYHtIm1RDqfFuiSLzbNR53vt+GZ01/YuBqQXiyFX+JNcjU4Avqw4iHcPwGnFk6HAj/4L7WkRLZ7ymTQPJoF3p55Ey9BjjaBsg4fuSx8dNmFHe16/ADua/doUPy/lpzgGS9OBTkaKECKcbXMnbRSGkoIQb5c3vOMkV5eGmBOQ4bbYK1NbiLhHUon2E82wIT/wrnfDEwpszkpv8/HbOveCsL9g95e+JhtlojgRz2zlxpicP0uwKcyxwImRuWhZFS8u/BwV6iBgYb8UvGT3VnmdfQuNQDfOwq1K6djOcOCFeIIyCGd1VWCiXC7uU5Z9sqHTnpmRxnDNi3jaipxJooesu66QId1mfyONooziXgbOLc48xNosNoZSnkKT3x+sEbw+rUiA5Bp9sHz/EPj2iOvXlO4LgP+BvGazx1YCug15tlaXZKFfg+XUvmLNsvJCdBGdghU2aw7wbnBbTY0GxxhBgLv6c8XGGm9SdB3tR/AIkLBa9kw/Cg2S0Qla8poJ2u/i0GK4LVy/y2hyrSPEgT1i+9jqaSCrWGGQ==</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>176</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>d2ZVRAABAAEzAQAAMyIRAAABAAEADg4DAAAAAgAAAAAAAAAAAAAAAAAAAA4AAAApAAAAyAAAAB8AAAAjAQMIDw8PHwMDAwMDBz9lRlQkZQyCO4odm4yzK+95rQH3Rhg7ih2bjLMrBAEAAQIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADaFNTfbm0EpMA/0x9NAU3mwCIgcXWY/gwmaFsSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANSGeOoa2UEvAb6sL7wiULhOApvhHjIfEC4eUg6jRJe6NAmhGBSIBHl3DuKTrBBEp1J31oPK5ssSm6dW2TDPha1NIGA1YhcaV4G45qcB1sVCda7ACcJ88EoyoF+rJsOv0UwfhosCO0uuw0B1rGC52iKPQjhaj9FOYVbez7BdG/5+mJCzA3M71eVgSIUnvPjTcVS1pdtGFFQ5LhW3tkJwWMLb48A9jBfeIQnmXcCfeooauxpjQWMk1Nvve3VJ50k9CEg9HiETFSkj13M96JrWP4XgKVWPhkwk3SHhbT9UF3IIG7Wa219IXbd84gnNQAkSMjbUMf0aGnyxSZ+xCZzvkB95YODnurd/NhEdQ0eQH+yHfuPK2BKwoyhH/Yh43WW+eDzBlWeuGMdT9oJrgbxo9EiJiFkaEVWjzU5QcvyOv5xNTiX6lQYTv3nip3rPrP/HJNq7RYL1NhZCtiWOoMcqmpnzMgIjX8IS/wsNDBw8Ci9JhOUHPHqRJfDyDWhLUlmz0D1787ErD4QpchP4B2M/XXx6R7WzDhWgsDaY9afBC9SwmoqTFdn+tGghtbIM1lFmyn0pClgZd7Dxmd949sQN2wdGF+oojHFuMKeYRsgMKE4IAgdOLyDENYNZMoEAlyeTjv9Kn2b/MvOZyRrVq7cdGoorsQ8SpewIIhHHgCXDWY4EvIDgMs4jWNQoKMAZq9wJPDR8qCZTqggmQZO2u9HpCoxJBIVE71XJzrukLOHGwoAW3Kkq8Q0pO3IITSIYFCX0xuMjMss4X6k8blumDV4mq8llKHpp6t8awccpr2G0uCbPz4C3OqsoaiBSptYjoxfuC8qKRFV3CYO40K4C3OicWzM2ePgIWKbVQL/sMWqmBvoRQwOncG+bddgfKqKJiYJdJP/dHHfq2qHXz1Zk+aAnNXha3NQ59Ee4u+2ZmhC6zD1AEXsX+pSOOLJAJre2DBL47nn4R27thQoPW026ZHYSvC3FfRoXexa3WFNuNiCKkZLwkflnD8+82Gl4NUOFEFX0CqYXeo2XweI/niG2JGaAnyH+Z5zFyYYMXifGkhLUBB6JeI4Plvl6ScMj1a8jDUiqMfuMZWRjwew2FSPUGPQnoZYkyMRnu9lbIis4BCLK/EdLVk0vSAwAtW/I9J8tkY6w0l/YsBGwsorJ14/7xy1uDUbTEgCRBUse0HKREU3Kj1gGSK7E86rgnzQBhYQ2aikSPg0hhhyBGY402ylKAQ4zR6zYvwQYiTVj9vMC97rcWPkhHxPwdbTQHxd9nbpctFLheYwBuTcGJM33+j9+fD3/gYizTqgQHvYX8jFDY56Dd93UFgfkrtCYsMrJodqAn/sABcTUIBdBpQEeSSTuXAsEM5JHyMhEkZIwcDqIqxtKXJiHq+8xfYya6MUqBRO7Dulxiu4h2WLXhBIDOTra8IA5McMaXKl15CgHGZufTLufCBlntXZjEatIDOanDRjLVcpyjdkSWxcqX/1bgNcnNXGg7gcA+OihKDcYelaXeoEKHhiVGsyp7sjm2GcGDokg6XXxEFHX8HQcgTrcLB1DMWVz37potzZ/y2YJHGE5voJ0bLQXj9Zc5GoElWBoAQ65IH2/5Wa4uha22XSa2bUG8WtL/VhkJyHsw2El+JbW1MGZA6YJ5TES9g4bdpMbDl9qRQXEsbTpoxshPHOqDaOxHw==</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>180</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>d2ZVRAABAAEzAQAAMyIRAAABAAEADg4DAAAAAgAAAAAAAAAAAAAAAAAAAA4AAAApAAAAyAAAAB8AAAAjAQMIDw8PHwMDAwMDBz9lRlQkZQyCO4odm4yzK+95rQH3Rhg7ih2bjLMrBAEAAQIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADaFNTfbm0EpMA/0x9NAU3mwCIgcXWY/gwmaFsSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEGpaXYCcy2NMqDWia0AZn8C3AD6I/V5FA+yERrztGM5nR30BzYht52aKBFf0wN1TFIHT9UqvuscqOE77GO0g6y0A+4CChsZS7tcTAACeO83J0B7JjEkqkCjGWReNwGJgRYJyyII7qIr0wnoXS+olB46WrCc/Rn3De4XK3mWIWzcgYT4jA5w+6Y9VVoQLUfqtHXi34F9oBZ8LwMhKM3FiFsF5QYGrEaEGCuc6ud5wuygTbZVcE8GR9h/Y3bQbuZcNx7uHwGZ3EbNw8YwByW2gfj/H07SsInlgw+adzDAFEgdiyRcFce1A0sixbE/sRomdBpaFBFScdjZjV5cIwpTtXzIuc/C4vtaKiEhIj5M+6e8T4V+ThcqGwD8XUC7Fu9iFgCTXMDjBdmt1xWO+gSUhm5fYVQPVkxt61SzUTvfSx7Naw6hPmuAjrpKIG+B4mgzDlqblZlzuJBs6WvOwe8YVlSukkDp1KSBo4M3nRVHTATJOVwbkzkCMQ1KDfbtm2P7z6R7aQhFJ28nKdKUc8IcTbu7wYHT/wPsNRqGh0pxYsXsVyL4EMuhNUyL7VUDRYPtUKsDA+TSSaIELah/BxUVIQLNrHaoGQWbPpZywEi1CVESgYS3a0bqyMIKVPYVthM2pHqvGjxCAbcM1yixGeuEs5ADpDLnwPhAD5aW8m/vjUqtJomIdWApQ5C7cV1x8zSDRuBfVx3Z4h+v8j6kbMd+dfV4AGujvVgq75TSP8Rn7UgRkAMZScCGEPQJvNQF4QO3gNqHdGDoiOmdMfgfFs4X9s4/sj6chgawQQ0kWH6pimo+Dr5EN5EB1gYUUHvlABu+DMaD/oWlCPuYYKJoFhuO7M11CZIF6m2Z//vY1csxm4Ye0wu0zTn8lJfQ5rXAEwYIBls6dZody5zU+A2BChwFwqSFmm9MoEi/f3andgCNi9NFtRnWRmt5uYo4EeYIveidNhJFriIcFfEJcPQDX33nVSNWhHuaYBw4vXB+wrYFD/ZpQq5oILK8HyBbJcugBID83R4Bm48ClyLB3NEIkxFx5A3an9FP4Sgz+g+2k2cyBjedKvrmNAjuBjud1+wZKKVeRt1mu3m/2gbWhRs5n2ahoq+RtqP9u0OhGL+HNKBD++gQDdNxW1gnLmC9tZaOzrkH5WLFqwmYd2hoW7f2pBVinx2+BXdhCjRSOGSTepEdB0YO9xRJQOP9wvJTkV3EYhHOBrA0UpIJMy1gzcc+AoCdcHxS6tPfx9zIxSsUA9FRXKtsW436pkwbIChhjgm6T+GLAWQxaN7NBRIwbdYd6J3PMxaEpFAVQ9g4DbyIl5pEgVAFkQ2Xae5KyYB0C3+LkqruKc3fadwO7Y/EyMTIUA8liP57sbD+ognTqzzhKQXXnj73l2XbWQFZxdosHV+NWARuQz3e2T7yP48JhK8zHBfB7GvfJI4rLioDbnWZd8We05WzaOJ8BYwDbGAXUuDHiFwW+Kker9DcSXQgvKHToFJB4A6uLYgYXbC2pRS4HSgyKHF78RwNFV7VxZmDdfARNLQMZowQLOMeeS34Bin8DenboFadzDoUkH1qKQc40nGhGEN9NFWapEYG4mmYJyjU2NDkrj8tsB+tVVmYNQPGPJbYfkI3KIIei0XCaOcJwtAX1kQQraX0myBB+5mPP/4HvCntuPw62vulK5rXThtBHA==</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>182</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>d2ZVRAABAAEzAQAAMyIRAAABAAEADg4DAAAAAgAAAAAAAAAAAAAAAAAAAA4AAAApAAAAyAAAAB8AAAAjAQMIDw8PHwMDAwMDBz9lRlQkZQyCO4odm4yzK+95rQH3Rhg7ih2bjLMrBAEAAQIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADaFNTfbm0EpMA/0x9NAU3mwCIgcXWY/gwmaFsSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtGZss6uU4b0LQbdZ8hnnMvbcv4CcR1oemswgq9UJrSPUleE3YcZF0JFEcTe2vp2+0chnUxdRsN/NEztxvqZ6o2Uj7GQA/t1ILuwvxsh76aN4yFEmxMMVZliKtDS580yAQSLsv9CroG5BMcdpCFqAOouuumB7mgHBtNJ+kYDMMhBWzKaEfZFFVGYxIObyrZBlJ1zolSpdyU8wIfl/rejuZJDa46H9PtJs+DN29YgSp/BjRPwgEARXbV8GAF2rSUwIJpZijmlEn+Gyiwxdnbesy/KGqA31KvTmOFJ/0tPMYHvR9mJ5R/c9JRDFqnDxNwYtc6pAHCEwbZIqQHKboSGiZYcZ61FFUIpIIe+ISZSc+3M/7viKRB9CCEI7RAn5nFNqFCNy0KDYIUvnlwIFotcJefG7AqhdQcw51wQDn/DRifZwxEvDgKBeOJAeInAVmWDnPl+kndm/glKvpspbgcWDkHg5AN69SihpRHUClRPkSBYkxJ3Y+2i+qIIhf+UwOF18NQ5hmLbwgf6TgNFXW9Hvc8r+aUewnJ1EJ3E9ujXgv8jbEJDYXwaqRrJHFibotUh3sKgscgIft5VeYSTmHABCFUSz7tymCw5oqxxRfAInPD0ZBHbQ5McXzKJlQXq92d5ScMZ580iT5PLhMpxsFnwgdnbJs0UNz6EHsvxNBGfxHnOsHRR/QntlmPwQFvkZJpn/0+uBN4Jz1eL5tm7P28zy6KGaCumqPli5+5bpNQY3oAwmTIX5UqV8HDEds2lxUY2fsgYLvNS95Q6NJrArActnLnFPt1Qqjfag0UQ3kQgTYKvnUSgssbXBRpV7TMO00qv/cPtkY4CGMAHKrr2IIRVV91nMUHjAPwNG9jUQfSXmxpmRoRn+i4e077Bu1FlMw1AdscB4MQ0Ku4zcPwxqwAZbVxV1iVGerix/AEkBk6Hd9jU06U8IxyPJfcBgNyX2cghGq65J83FrwTXsKJvIdawXGF9AmWrQmpJXelJv081VCtvmNnBwNTizeCQL08Shy1FS0UlYeIG7qbWj+3oqDFZhMcgq4RQaNM4xDE+ifkIIOPFrHs0ea3E0qiS9UXdgSo3L1wjlsTkfWu0RHBFmKTdVyJBGS/yOBdKZWhOnwFLgjXmrlVOwwXRpttk/JJr9c5K0QZsCpDesaNy2/F2lIdW8/iFu59a/dlVH2vkfSITYYDPH4NgZ+MCcba6Ub/1hMWYKxArl6aCE0ZgyD9JD029qFzaXr4WS/Tlz8cDR5zCya17qAeAQfxrhFiMEd6rUObHrjin/59GTB+x3Tdpdjbf7tULFsAR+nM4Yxde/5IrJ28nAUcM7Qa87414FeXcPF3AeD4PpdQZcMfryDuUfwIrWY3fvvSyJV6Z2TdlCF48EMtwJPyjcIiV8i+I9GYhNHQqcu3a5rKEpYAjGfquDp94KS1dvc6mCbwyllqF3aX7JgIjNX6ITk8UkkKzIUQ138YscUDqEmDxHM5P8oWEuP4+BWTb26Wc53Z6YyfSjKSCZ0F1LrYEx00kmy2ysoRR1Iq+Hkj5IB0w4nhpRdKphGQFDdCB4FyqjETERjEaVA1JXhywrtMuNEX+APJZyuNkhFuBT881RmP35V5bNTpk9rD80tGHxfjHmcsnL2Lh/Wzw3ER4NuxOkrE9ufEJ3T6DiFszy12lP446bek+gglDw==</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>184</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>186</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>188</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>190</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>192</pkc:GroupId>
			<pkc:AlgorithmId>msft:rm/algorithm/pkey/2005</pkc:AlgorithmId>
			<pkc:PublicKeyValue>d2ZVRAABAAEzAQAAMyIRAAABAAEADg4DAAAAAgAAAAAAAAAAAAAAAAAAAA4AAAApAAAAyAAAAB8AAAAjAQMIDw8PHwMDAwMDBz9lRlQkZQyCO4odm4yzK+95rQH3Rhg7ih2bjLMrBAEAAQIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADaFNTfbm0EpMA/0x9NAU3mwCIgcXWY/gwmaFsSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHG3+xByeMd4lE7droMSvKXrkvFzfVQ7RJbuWxkKZjylz8m0SbDghB/fKhcec+3P4R7kS/lSGOQquGODPC+XqvCjzi7zrRFYsp7bcF/k3IuDG54cD53Av71snKKYWIm7ppkVjwAWqz5Xn988t7fbYChuOdgwFa6ngQ33/1+3JU46CJTdMa/47JLAgO8oc7S72qmqZhO9VXdNUAMClXcFMQpoFlmFT3KVH3fdOJMh6wytkSC5lZsnXG6a9HGMzBbQRuDtww8BVAGk7Mp4izNHRNnMGBNur7Eh0brzX9fORQocuoktPOLvMQxCxgwK+wn5YgLJDOcTphjuO7+7B+xTZaq1mdKdxf5cXa8ak2yhVt9yQimdYy3tfR8fwimuZnavoWLV4CMYFEoWXxWwY48N2uLU2sETbBhdTwG98AmX0tguAR2qUTA1WOal1lKc7M2DJGtMhZs4XslVNTGUM8sCYbg7Hzkg8/iD7vtVxwPL5Bh+17PD4qrU1VlYKTUUw7s+qfxAjPaI6ZIboC+TfwzeZxOxGtG3JwQY+SesLlk5xR2528V3IyQkIU44ecWHwBkxQ8gQbyi8na8et1PQi0lCryBk729anrRof6Ejz8nRE07WFPYJ5IZ/BXB7C7Mj0wwsMDHud3GpiXujryL0MgEIyFAnBEvxE3onA66VunREXQJX+qhHkk8kMClVcMhEWm1axL9DVgF0DbFKzdIghJPzJJ8ZCTuQYb+oRQ3e/i4lpyIUK4m/1ScjjVD5usYbUh13wjScY1WPp/8Hla/uI8sYzeujDI7s2VqJAv0ZRniZZ9GQxh2iI5bwEACkfXGwHjLyLjMpELOyGI+Ms6+Fl3tSvh3Pra8AfHIAMpjXtPWslV3jaQBdRcLb07vYcgrS1o0eD+v7wozzWZ3BSbUM0MsNDLuppkgJWsp8abcjeyc9ETPH9Cnt4r0xTaa5Au031akcjB0Rfv4erjch/BHZiLXVo0PrfycN5CGVmSr3I3RXZZ1gDpjoAYIOAaT28VWY/YbyLmErcEirev4h4MNFwPOS9xr8OH+RMn6A+i1v6Q3jHGLspJvgoedbxDGbDHUrrPr8WKzDl6S/N0slHCvmAyn3TMktGB4nv8FnAilpZ3nSutik4AWx79cc70pd1oXz88Dy7l50sClLgq9Z9b5JnlZcMzJyBS261EYsAlYidWgFDmsFYltSMfOfQysxEgQpwyMU6veAPHm/0FJB94PAHL1uGKBM7F8WTrgFv5YVaSEBfoQEurzTj74RhAjT+kDOCZ0Mc++LRjxRHBVI08Cx4xSkW73UVRoVdjqONs6dTmbQ76FrNB7ds5YXv/oFnuaG5NQ7ETHoNl3Vz3vyLg8AoAQHNN7ZKNlsiHtA3snVrCQ+2GVNYh8ftGlW4prfAlRpODOcA1Ybq0tyZgMLrvRzqyDDGJw9YBbwsgdqV2e2exIn3/1sq6HODH56vSH/AuBCKMiNPjEfudqhfHzx2HXPfoq1ZwyUKkwsnqbdHDt7pFG3KIPIgxDvzS2ANyfJFUwba2uKjRcWicUVIdLUXAfD8NWgjEXRkwfX2ypJCmPYSaf+DYLFgYSYYCAD1BoEw6W3CxfeoCoBGCgGlbj6FJt7gfTqSMXRHogkADAZyd70m3HmxSAqtX9Qbr1tFtbAyLsMkxqT86EE22wfL+P1i/RVEg==</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>194</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>196</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>198</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>d2ZVRAABAAEzAQAAMyIRAAABAAEADg4DAAAAAgAAAAAAAAAAAAAAAAAAAA4AAAApAAAAyAAAAB8AAAAjAQMIDw8PHwMDAwMDBz9lRlQkZQyCO4odm4yzK+95rQH3Rhg7ih2bjLMrBAEAAQIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADaFNTfbm0EpMA/0x9NAU3mwCIgcXWY/gwmaFsSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5m8v5q3sSP02Y01kAGIhotU18UAcHzbe1TIwDvTFmqtkoCTJMmo+vCBC+zOi43YWB9AEprGQMam464gSeFuX76npOf6BE2Q0AEquOLGralRoZvHjmPgVr7QpwAbMdbTUgmxqiUf0Z1he7GWl8NmQrVZT2WM/O1XuVr3kKWERURji6tQMyaxtXr49sCJnw9tSnyzCRgr/vruRHid4v8GUIlCS1g3OMDAEYvYfaSSfwYWbmvzukWhLUxE2egSW+nbzlkaBPoi/6Dr8+RaxspphNRFHSvdH3n8n9MW1ccyNAi6vxghWs27E8bD3jbwRSYhmOCV9uHZdVjfpUVEmASEgMnzlJpQupHGTYSpZ04aPqxEoCqlaqPrhklPaURghFJL8yfzmYMF23aX5GA6FRmshIL7vgOfRed6MTXZCtvP+Vk1yefygy475XnWoeYjsJnIVKYkZnwu8L3lcy85P8dg03mXC6h4xWnnBn4HQGwsWlVCcSjV/QGthyhES2mLut8I+hjbgbFz+sGPBzDHWCIXwzDMwi9wirgvcpY7PEfrR84I/FjDiBqrQLscmKVYLAn5t0DUvO695drx0A+tnClRBTDTjAYJyrSHMD46KJaI1d6y1nxclnlhljaQxQlkyYvfsheGHE12HdMmw181WzxE/iCat44TW0UBC5ali4a8bG+ouqSQnkZ0MJbnucdbGdkcW1pzCN4ZRyTCqpJKTaXTb64IPBr5/LL95sNiAaUciMj3jp7FB0d7NCFp/TpqhA5pBQMR4rgWdFa+5SQA1PMbU7UQ7V6fUO1Jl0gTu/F0Hc3Pzpf0/v9vR7MqTCp0pEm+aS7lot6HnVg758reZL410FHlRUMnSEHTCUZDii1gTGZaSZ8H7i4X6pG5D3NFNVKDFAk/g9vpj/J3smuyxwUei36QSs2XJtC0mmwKyNMdj9H4BbYNOzj585mIWGKt8ruM8p+mjPMrCQYUU5U6Ya83WRjt8wg0hF0AATDGTp6ZvXtSJQQJ4kKtNodiDZRkQdX/GURyl9dplnTvHFu2FtWQAfBE2ObXTALqPREfQ4AKjtYZkd7QzIMdE3OOAErGJ4nTTmxKjHv1H7gpSu36zGUA5IyYNvimqD6DIOhyysP/FBi//f//+gSeHlzsK3RQojt5zjogRkv+1j1QyPM9TG87LGbF86j0oungcb6oEdf+KAY5c2e71svL74Qd0spehi0gRGU7BlE2LL29l+bApc9h84a9DPNDjmxsAwVh64J2uNa2VZw/zQD3ijvrcEtDe6QpruLLTU5IfcOroxqmNRmJDGMLXMBD54V00iccDDU8QtdxSkCvZ3ZU22NpXWaCL74GERAkJV0jmLEZVYmSMsMn1jlw31GA4oEpqkPVwzj1oq6tP8vnvnhTQg5AEF4LNBkmGFcM4caITMkmWHQQpYPrtlVm4VR4iBdd4WBkWuE8MT3dYu9CVU/yG0S/O7+uOSBgr0Fllaw+D+I/K4eDnvbnxSwVSWnZ69YJS5rJnWQI3ikHbRA3B7kH/KPv6cfIG5zoHnAGKweud4ExymTpSs+k6Ro0JeTzY/xExupOAJczqWgqVNxtxgYK59qdZ4EgExgGJ+rgx+qv8FjNm49axXIiQJ1ET6lmHPBX8jBfq+/7csj4sqtCWoFjync42qqqBRwiFXqsqN2cglK1WWlFg==</pkc:PublicKeyValue>
		</pkc:PublicKey><pkc:PublicKey>
			<pkc:GroupId>208</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>212</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>