Initial commitVPS

16 files changed, 427 insertions, 266 deletions

diff --git a/WinKeyRecover/KeyChecker/CheckKey.cs b/WinKeyRecover/KeyChecker/CheckKey.cs
new file mode 100644
index 0000000..96b1f0e
--- /dev/null
+++ b/WinKeyRecover/KeyChecker/CheckKey.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WinKeyRecover
+{
+    internal class CheckKey
+    {        
+        private readonly IntPtr hModule;
+        private readonly string fileXml;
+        private readonly string mspid = "00000";
+        private readonly byte[] array = new byte[50];
+        private readonly byte[] array2 = new byte[164];
+        private readonly byte[] array3 = new byte[1272];
+        private readonly IntPtr intPtr = Marshal.AllocHGlobal(50);
+        private readonly IntPtr intPtr2 = Marshal.AllocHGlobal(164);
+        private readonly IntPtr intPtr3 = Marshal.AllocHGlobal(1272);
+        private readonly GetProductDescription getProductDescription = new GetProductDescription();
+        private readonly GetString getString = new GetString();
+        private string result;
+
+        public CheckKey(IntPtr hModule, string fileXml)
+        {
+            this.hModule = hModule;
+            this.fileXml = fileXml;
+            array[0] = 50;
+            array2[0] = 164;
+            array3[0] = 248;
+            array3[1] = 4;
+            Marshal.Copy(array, 0, intPtr, 50);
+            Marshal.Copy(array2, 0, intPtr2, 164);
+            Marshal.Copy(array3, 0, intPtr3, 1272);
+        }
+
+        public string Check(string key)
+        {
+            int num = ((NativeMethods.PidGenX)Marshal.GetDelegateForFunctionPointer(NativeMethods.GetProcAddress(hModule, "PidGenX"), typeof(NativeMethods.PidGenX)))(key, fileXml, mspid, 0, intPtr, intPtr2, intPtr3);
+            if (num == 0)
+            {
+                Marshal.Copy(intPtr3, array3, 0, array3.Length);
+                string @string = getString.Get(array3, 136);
+                result = getProductDescription.Get("{" + @string + "}", fileXml);
+            }
+            else
+            {
+                result = "Invalid";
+            }
+
+            return result;
+        }
+
+        public void FreeMemory()
+        {
+            Marshal.FreeHGlobal(intPtr);
+            Marshal.FreeHGlobal(intPtr2);
+            Marshal.FreeHGlobal(intPtr3);
+        }
+    }
+}
diff --git a/WinKeyRecover/KeyChecker/GetProductDescription.cs b/WinKeyRecover/KeyChecker/GetProductDescription.cs
new file mode 100644
index 0000000..3a42418
--- /dev/null
+++ b/WinKeyRecover/KeyChecker/GetProductDescription.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace WinKeyRecover
+{
+    internal class GetProductDescription
+    {
+        public string Get(string aid, string fileXml)
+        {
+            XmlDocument xmlDocument = new XmlDocument();
+            xmlDocument.Load(fileXml);
+            Stream inStream = new MemoryStream(Convert.FromBase64String(xmlDocument.GetElementsByTagName("tm:infoBin")[0].InnerText));
+            xmlDocument.Load(inStream);
+            XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(xmlDocument.NameTable);
+            xmlNamespaceManager.AddNamespace("pkc", "http://www.microsoft.com/DRM/PKEY/Configuration/2.0");
+            XmlNode xmlNode = xmlDocument.SelectSingleNode("/pkc:ProductKeyConfiguration/pkc:Configurations/pkc:Configuration[pkc:ActConfigId='" + aid + "']", xmlNamespaceManager);
+            if (xmlNode == null)
+            {
+                xmlNode = xmlDocument.SelectSingleNode("/pkc:ProductKeyConfiguration/pkc:Configurations/pkc:Configuration[pkc:ActConfigId='" + aid.ToUpper() + "']", xmlNamespaceManager);
+            }
+            return xmlNode.ChildNodes.Item(3).InnerText;
+        }
+    }
+}
diff --git a/WinKeyRecover/KeyChecker/GetString.cs b/WinKeyRecover/KeyChecker/GetString.cs
new file mode 100644
index 0000000..bad8722
--- /dev/null
+++ b/WinKeyRecover/KeyChecker/GetString.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WinKeyRecover
+{
+    internal class GetString
+    {
+        public string Get(byte[] bytes, int index)
+        {
+            int num = index;
+
+            while (bytes[num] != 0 || bytes[num + 1] != 0)
+            {
+                num++;
+            }
+
+            return Encoding.ASCII.GetString(bytes, index, num - index).Replace("\0", "");
+        }
+    }
+}
diff --git a/WinKeyRecover/NativeMethods/NativeMethods.cs b/WinKeyRecover/NativeMethods/NativeMethods.cs
new file mode 100644
index 0000000..f0817ae
--- /dev/null
+++ b/WinKeyRecover/NativeMethods/NativeMethods.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WinKeyRecover
+{
+    internal class NativeMethods
+    {
+        [DllImport("kernel32.dll")]
+        public static extern IntPtr LoadLibrary(string dllToLoad);
+
+        [DllImport("kernel32.dll")]
+        public static extern bool FreeLibrary(IntPtr hModule);
+
+        [DllImport("kernel32.dll")]
+        public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        public delegate int PidGenX([MarshalAs(UnmanagedType.LPWStr)] string ProductKey, [MarshalAs(UnmanagedType.LPWStr)] string PkeyPath, [MarshalAs(UnmanagedType.LPWStr)] string MSPID, int UnknownUsage, IntPtr ProductID, IntPtr DigitalProductID, IntPtr DigitalProductID4);
+    }
+}
diff --git a/WinKeyRecover/Program.cs b/WinKeyRecover/Program.cs
index 8df11f3..ddf3d27 100644
--- a/WinKeyRecover/Program.cs
+++ b/WinKeyRecover/Program.cs
@@ -10,285 +10,67 @@ using System.Runtime.InteropServices;
 
 namespace WinKeyRecover
 {
-	class NativeMethods
-	{
-		[DllImport("kernel32.dll")]
-		public static extern IntPtr LoadLibrary(string dllToLoad);
-
-		[DllImport("kernel32.dll")]
-        public static extern bool FreeLibrary(IntPtr hModule);
-
-		[DllImport("kernel32.dll")]
-		public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
-
-		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-		public delegate int PidGenX([MarshalAs(UnmanagedType.LPWStr)] string ProductKey, [MarshalAs(UnmanagedType.LPWStr)] string PkeyPath, [MarshalAs(UnmanagedType.LPWStr)] string MSPID, int UnknownUsage, IntPtr ProductID, IntPtr DigitalProductID, IntPtr DigitalProductID4);
-	}
-
-
-	class Cli
-	{
-		public static void Intro(char[] validChars)
-		{
-			string validCharsString = string.Join(", ", validChars);
-			string intro =
-				  "\n    ###########################"
-				+ "\n    # Récupérateur de license #"
-				+ "\n    ###########################\n"
-				+ "\nInstructions:"
-				+ "\n- Renseigner la clé en remplacant les characters manquants par des '*'."
-				+ "\n- La clé doit être renseignée comme ceci: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX'."
-				+ "\n- Les characters autorisés sont: " + validCharsString
-				+ "\n- Un fichier nommé 'clés_trouvées.txt' contenant les clés sera créé sur votre bureau.\n";
-			Console.WriteLine(intro);
-		}
-
-		public static string Get_key(char[] validChars)
-		{
-			string key;
-			Console.Write("Entrez votre clé: ");
-			key = Console.ReadLine().ToUpper();
-			return key;
-		}
-
-		public static void Found_keys(List<List<string>> keysFound)
-		{
-			string found =
-			  "\n    ###########################"
-			+ "\n    # Récupérateur de license #"
-			+ "\n    ###########################\n"
-			+ "\nClés trouvées:\n";
-			Console.Clear();
-			Console.WriteLine(found);
-			for (int j = 0; j < keysFound.Count; j++)
-			{
-				Console.WriteLine("[>] " + keysFound[j][0] + " Version: " + keysFound[j][1]);
-			}
-			Console.WriteLine("[+] Travail en cour sur les clés...");
-			Console.WriteLine();
-		}
-
-		public static void End()
-		{
-			Console.WriteLine("\n    ###########################");
-			Console.WriteLine("Appuyer sur 'Entrer' pour quitter.");
-			Console.ReadLine();
-			System.Environment.Exit(0);
-		}
-	}
-
-
 	class Program
 	{
-		// Partie PKChekcer
-		private static readonly IntPtr hModule = NativeMethods.LoadLibrary(".\\pidgenx2.dll");
-		private static readonly string fileXml = ".\\Win10pkeyconfig.xrm-ms";
-		private static readonly string mspid = "00000";
-		private static readonly byte[] array = new byte[50];
-		private static readonly byte[] array2 = new byte[164];
-		private static readonly byte[] array3 = new byte[1272];
-		private static readonly IntPtr intPtr = Marshal.AllocHGlobal(50);
-		private static readonly IntPtr intPtr2 = Marshal.AllocHGlobal(164);
-		private static readonly IntPtr intPtr3 = Marshal.AllocHGlobal(1272);
-		private static string result;
-		// Partie Program
-		private static int missing = 0;
-		private static readonly List<int> missingPosition = new List<int>();
-		private static readonly List<string> allPatterns = new List<string>();
-		private static readonly List<List<string>> keysFound = new List<List<string>>();
-		private static readonly char[] validChars = new char[]
-			{
-			'B', 'C', 'D', 'F', 'G',
-			'H', 'J', 'K', 'M', 'N',
-			'P', 'Q', 'R', 'T', 'V',
-			'W', 'X', 'Y', '2', '3',
-			'4', '6', '7', '8', '9'
+		public static void Main()
+		{
+            // Pour 4 manquants liste a 390625 posssibilités pour 19 819 368 octets (20Mo)
+            // Pour 5 manquants liste a 9765625  posssibilités pour 356 225 912 octets (357Mo) !!!
+            //11F "TDC2B-NG8YF-JH2BQ-46JJW-J8F7G"
+
+            IntPtr hModule = NativeMethods.LoadLibrary(".\\pidgenx2.dll");
+			string fileXml = ".\\Win10pkeyconfig.xrm-ms";
+            string keyTest = "TDC2B-NG2YF-****Q-46JJW-J8F7G";
+			char[] patternChars = new char[]
+			{
+				'B', 'C', 'D', 'F', 'G',
+				'H', 'J', 'K', 'M', 'N',
+				'P', 'Q', 'R', 'T', 'V',
+				'W', 'X', 'Y', '2', '3',
+				'4', '6', '7', '8', '9'
 			};
 
-		private static string Check_key(string keyTest)
-		{
-			int num = ((NativeMethods.PidGenX)Marshal.GetDelegateForFunctionPointer(NativeMethods.GetProcAddress(hModule, "PidGenX"), typeof(NativeMethods.PidGenX)))(keyTest, fileXml, mspid, 0, intPtr, intPtr2, intPtr3);
-			if (num == 0)
-			{
-				Marshal.Copy(intPtr3, array3, 0, array3.Length);
-				string @string = GetString(array3, 136);
-				GetProductDescription("{" + @string + "}");
-			}
-			else
-			{
-				result = "Invalid";
-			}
-			return result;
-		}
+			CheckIsValid checkIsValid = new CheckIsValid();
+			bool isValidKey = checkIsValid.CheckKey(patternChars, keyTest);
 
-		private static string GetString(byte[] bytes, int index)
-		{
-			int num = index;
-			while (bytes[num] != 0 || bytes[num + 1] != 0)
+			if (isValidKey)
 			{
-				num++;
-			}
-			return Encoding.ASCII.GetString(bytes, index, num - index).Replace("\0", "");
-        }
+				CountMissingChars countMissingChars = new CountMissingChars();
+				int numberOfMissings = countMissingChars.Count(keyTest);
 
-		private static void GetProductDescription(string aid)
-		{
-			XmlDocument xmlDocument = new XmlDocument();
-			xmlDocument.Load(fileXml);
-			Stream inStream = new MemoryStream(Convert.FromBase64String(xmlDocument.GetElementsByTagName("tm:infoBin")[0].InnerText));
-			xmlDocument.Load(inStream);
-			XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(xmlDocument.NameTable);
-			xmlNamespaceManager.AddNamespace("pkc", "http://www.microsoft.com/DRM/PKEY/Configuration/2.0");
-			XmlNode xmlNode = xmlDocument.SelectSingleNode("/pkc:ProductKeyConfiguration/pkc:Configurations/pkc:Configuration[pkc:ActConfigId='" + aid + "']", xmlNamespaceManager);
-			if (xmlNode == null)
-			{
-				xmlNode = xmlDocument.SelectSingleNode("/pkc:ProductKeyConfiguration/pkc:Configurations/pkc:Configuration[pkc:ActConfigId='" + aid.ToUpper() + "']", xmlNamespaceManager);
-			}
-			result = xmlNode.ChildNodes.Item(3).InnerText;
-		}
+				GetMissingPositions getMissingPositions = new GetMissingPositions();
+				List<int> positions = getMissingPositions.GetPositions(keyTest);
 
-		private static bool Key_isvalid(char[] validChars, string key)
-		{
-			bool validKey = true;
-			if (key != string.Empty && key.Length == 29 && key.Contains('*'))
-			{
-				for (int i = 0; i < key.Length; i++)
-				{
-					if (key[i] != '-')
-					{
-						if (!validChars.Contains(key[i]) && key[i] != '*')
-						{
-							validKey = false;
-						}
-					}
-				}
-			}
-			else
-			{
-				validKey = false;
-			}
-			if (!validKey)
-			{
-				Console.WriteLine("Clé invalide.");
-			}
-			else
-            {
-				Console.WriteLine();
-            }
-			return validKey;
-		}
+				GeneratePattern patternGenerator = new GeneratePattern();
+				List<string> pattern = patternGenerator.Generate(patternChars, numberOfMissings);
 
-		private static void Missing_count(string key)
-		{
-			for (int i = 0; i < key.Length; i++)
-			{
-				if (key[i] == '*')
-				{
-					missing++;
-				}
-			}
-		}
+				ReplaceMissings replaceMissings = new ReplaceMissings(keyTest, positions);
+				CheckKey checkKey = new CheckKey(hModule, fileXml);
+				SaveAsJson saveToJson = new SaveAsJson();
 
-        private static void Missing_positions(string key)
-		{
-			for (int i = 0; i < key.Length; i++)
-			{
-				if (key[i] == '*')
+				List<List<string>> resultats = new List<List<string>>();
+				for (int i = 0; i < pattern.Count; i++)
 				{
-					missingPosition.Add(i);
-				}
-			}
-		}
+					string key = replaceMissings.Replace(pattern[i]);
 
-		private static string Replace_missing(char[] key, string patternFinal)
-		{
-			char[] keyTest = new List<char>(key).ToArray();
-			for (int j = 0; j < patternFinal.Length; j++)
-			{
-				keyTest[missingPosition[j]] = patternFinal[j];
-			}
-			return new string(keyTest);
-		}
-
-		private static void Save_to_file(char[] key, List<List<string>> keysFound)
-		{
-			string fileName = Environment.GetEnvironmentVariable("userprofile") + "\\Desktop\\clés_trouvées.txt";
-			StreamWriter writer = new StreamWriter(fileName);
-			writer.WriteLine("Clé initiale: " + new string(key) + "\n");
-			writer.WriteLine("Clés trouvées: ");
-			for (int i = 0; i < keysFound.Count; i++)
-			{
-				writer.WriteLine(keysFound[i][0] + " Version: " + keysFound[i][1]);
-			}
-			writer.Close();
-			Console.WriteLine(new string(key));
-		}
-
-		private static void Start(char[] key)
-		{
-			Console.WriteLine("[+] Travail en cour sur les clés...");
-			_ = Parallel.For(0, allPatterns.Count, i =>
-			{
-				string resultat = Check_key(allPatterns[i]);
-				if (resultat != "Invalid")
-				{
-					keysFound.Add(new List<string>() { allPatterns[i], resultat });
-					Save_to_file(key, keysFound);
-					Cli.Found_keys(keysFound);
-				}
-			});
-		}
+                    string result = checkKey.Check(key);
+					if (result != "Invalid")
+					{
+						resultats.Add(new List<string>() { key, result });
+                        saveToJson.Save(resultats);
+                    }
+					Console.WriteLine("Clés numéro: {0}/{1} Trouvés:{3}", i, pattern.Count(), resultats.Count());
+                    Console.CursorTop -= 1;
+                    Console.CursorLeft = 0;
+                }
+
+				checkKey.FreeMemory();
+            }
 
-		private static void Generate_patterns(char[] key, string pattern, int missing)
-		{
-			if (missing == 1)
-			{
-				for (int i = 0; i < validChars.Length; i++)
-				{
-					allPatterns.Add(Replace_missing(key, pattern + validChars[i]));
-				}
-			}
-			else
-			{
-				for (int i = 0; i < validChars.Length; i++)
-				{
-					string newPattern = pattern + validChars[i];
-					Generate_patterns(key, newPattern, missing - 1);
-				}
-			}
-		}
+            NativeMethods.FreeLibrary(hModule);
 
-		public static void Main()
-		{
-			bool validKey = false;
-			string key = string.Empty;
-			array[0] = 50;
-			array2[0] = 164;
-			array3[0] = 248;
-			array3[1] = 4;
-			Marshal.Copy(array, 0, intPtr, 50);
-			Marshal.Copy(array2, 0, intPtr2, 164);
-			Marshal.Copy(array3, 0, intPtr3, 1272);
-			Cli.Intro(validChars);
-            while (!validKey)
-            {
-                key = Cli.Get_key(validChars);
-                validKey = Key_isvalid(validChars, key);
-            }
-			Missing_count(key);
-			Missing_positions(key);
-			Console.WriteLine("[+] Génération des clés...");
-			var watch = System.Diagnostics.Stopwatch.StartNew();
-			Generate_patterns(key.ToCharArray(), String.Empty, missing);
-			Console.WriteLine("[+] Nombre de clés possible: " + allPatterns.Count);
-			Start(key.ToCharArray());
-			watch.Stop();
-			Console.WriteLine("Temps: " + watch.Elapsed + " ");
-			Marshal.FreeHGlobal(intPtr);
-			Marshal.FreeHGlobal(intPtr2);
-			Marshal.FreeHGlobal(intPtr3);
-			NativeMethods.FreeLibrary(hModule);
-			Cli.End();
+            Console.WriteLine("Fin.");
+			Console.ReadLine();
 		}
 	}
-}
+}
\ No newline at end of file
diff --git a/WinKeyRecover/Saver/ISaver.cs b/WinKeyRecover/Saver/ISaver.cs
new file mode 100644
index 0000000..876fccf
--- /dev/null
+++ b/WinKeyRecover/Saver/ISaver.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WinKeyRecover
+{
+    internal interface ISaver
+    {
+        void Save(List<List<string>> keysFound);
+    }
+}
diff --git a/WinKeyRecover/Saver/SaveAsJson.cs b/WinKeyRecover/Saver/SaveAsJson.cs
new file mode 100644
index 0000000..3ea55de
--- /dev/null
+++ b/WinKeyRecover/Saver/SaveAsJson.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+
+namespace WinKeyRecover
+{
+    internal class SaveAsJson: ISaver
+    {
+        public void Save(List<List<string>> keysFound)
+        {
+            string jsonString = JsonSerializer.Serialize(keysFound);
+            string fileName = Environment.GetEnvironmentVariable("userprofile") + "\\Desktop\\keys.json";
+            StreamWriter writer = new StreamWriter(fileName);
+            writer.WriteLine(jsonString);
+            writer.Close();
+
+            Console.WriteLine(jsonString);
+        }
+    }
+}
diff --git a/WinKeyRecover/Saver/SaveAsTxt.cs b/WinKeyRecover/Saver/SaveAsTxt.cs
new file mode 100644
index 0000000..f0b7d80
--- /dev/null
+++ b/WinKeyRecover/Saver/SaveAsTxt.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WinKeyRecover.Saver
+{
+    internal class SaveAsTxt : ISaver
+    {
+        public void Save(List<List<string>> keysFound)
+        {
+            string fileName = Environment.GetEnvironmentVariable("userprofile") + "\\Desktop\\keys.txt";
+            StreamWriter writer = new StreamWriter(fileName);
+            writer.WriteLine("Clés trouvées: ");
+            for (int i = 0; i < keysFound.Count; i++)
+            {
+                writer.WriteLine(keysFound[i][0] + " Version: " + keysFound[i][1]);
+            }
+            writer.Close();
+        }
+    }
+}
diff --git a/WinKeyRecover/Win10pkeyconfig.xrm-ms b/WinKeyRecover/Win10pkeyconfig.xrm-ms
new file mode 100644
index 0000000..28eabd5
--- /dev/null
+++ b/WinKeyRecover/Win10pkeyconfig.xrm-ms
@@ -0,0 +1 @@
+<?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>0sx4fPj9CXuTuDXUidCUcuKV7hY=</DigestValue></Reference></SignedInfo><SignatureValue>xhPx512eRNq97wJG2akYi2JAeXpe74SnX0zy1Kpfh5eimxdQaU0SvwtRQh5y1VZ96lC6fUlMG4+LhQmsgmr+ptkOdkWZBi91ILco8rLQJgVwfi97az6d9/vkqgH/KinEf9vZHXkiCkJnXOCzlF/wLZ6SraQzkFIcd6Euqt06VNp7DoHJURWtgRLyUbpzgStvAVqxmnHhyu1jfeykntFcZyKRcsnfeCIYxCJZjPlxH7Q362p32BVvuZdkQQq/7wit5RyERom+ix62wqqTNH/I++NPBI4mxeyRVCjwoFJ1P7jzMcxf2WMcCAb2Sa5ZUb9lcBsq1ZFoIhXVFAsc32ui9Q==</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>2016-01-01T00:00:00Z</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"?>
<ProductKeyConfiguration xmlns="http://www.microsoft.com/DRM/PKEY/Configuration/2.0">
<Configurations>
<Configuration>
<ActConfigId>{afd55ac6-d0b0-4812-9047-6c756d82bedf}</ActConfigId>
<RefGroupId>3763</RefGroupId>
<EditionId>ServerStandard</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandard Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{21c56779-b449-4d20-adfc-eece0e1ad74b}</ActConfigId>
<RefGroupId>3764</RefGroupId>
<EditionId>ServerDatacenter</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenter Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</ActConfigId>
<RefGroupId>3765</RefGroupId>
<EditionId>ServerDatacenter;ServerDatacenterACor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenter;ServerDatacenterACor Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{562634bb-b8d8-43eb-8325-bf63a42c4174}</ActConfigId>
<RefGroupId>3766</RefGroupId>
<EditionId>ServerDatacenter</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenter VT:IA</ProductDescription>
<ProductKeyType>VT:IA</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{a43f7b89-8023-413a-9f58-b8aec2c04d00}</ActConfigId>
<RefGroupId>3767</RefGroupId>
<EditionId>ServerDatacenter</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenter OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{942efa8f-516f-46d8-8541-b1ee1bce08c6}</ActConfigId>
<RefGroupId>3768</RefGroupId>
<EditionId>ServerDatacenter</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenter OEM:NONSLP (MUI locked to zh-CN)</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{cbf3499f-848e-488b-a165-ac6d7e27439d}</ActConfigId>
<RefGroupId>3769</RefGroupId>
<EditionId>ServerDatacenter</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenter OEM:SLP</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{58448dfb-6ac0-4e06-b491-07f2b657b268}</ActConfigId>
<RefGroupId>3770</RefGroupId>
<EditionId>ServerDatacenter</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenter OEM:SLP (MUI locked to zh-CN)</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{01398239-85ff-487f-9e90-0e3cc5bcc92e}</ActConfigId>
<RefGroupId>3771</RefGroupId>
<EditionId>ServerDatacenterEval</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenterEval Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{a2ae7054-d580-4c06-a79b-1662e6f6955c}</ActConfigId>
<RefGroupId>3772</RefGroupId>
<EditionId>ServerStandard</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandard OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{60d99e35-ba21-46e5-abf9-877d5dd815de}</ActConfigId>
<RefGroupId>3773</RefGroupId>
<EditionId>ServerStandard</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandard OEM:NONSLP (MUI locked to zh-CN)</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{f70cf82b-0a95-4f14-a0a9-cb968d337962}</ActConfigId>
<RefGroupId>3774</RefGroupId>
<EditionId>ServerStandard</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandard OEM:SLP</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{f3d100a3-7544-4580-be0b-88d452b4a881}</ActConfigId>
<RefGroupId>3775</RefGroupId>
<EditionId>ServerStandard</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandard OEM:SLP (MUI locked to zh-CN)</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{8c1c5410-9f39-4805-8c9d-63a07706358f}</ActConfigId>
<RefGroupId>3776</RefGroupId>
<EditionId>ServerStandard</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandard Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</ActConfigId>
<RefGroupId>3777</RefGroupId>
<EditionId>ServerStandard;ServerStandardACor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandard;ServerStandardACor Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{179bbfdb-3b18-4fa6-af8f-86f740f28fef}</ActConfigId>
<RefGroupId>3778</RefGroupId>
<EditionId>ServerStandard</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandard VT:IA</ProductDescription>
<ProductKeyType>VT:IA</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</ActConfigId>
<RefGroupId>3779</RefGroupId>
<EditionId>ServerDatacenter</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenter Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{9dfa8ec0-7665-4b9d-b2cb-bfc2dc37c9f4}</ActConfigId>
<RefGroupId>3780</RefGroupId>
<EditionId>ServerStandardEval</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandardEval Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{9297796b-3972-4347-906e-78905da547e2}</ActConfigId>
<RefGroupId>3788</RefGroupId>
<EditionId>ServerAzureNano</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerAzureNano Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{b3404d38-04ef-4811-b233-570e528096d1}</ActConfigId>
<RefGroupId>3789</RefGroupId>
<EditionId>ServerAzureCor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerAzureCor Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3dbf341b-5f6c-4fa7-b936-699dce9e263f}</ActConfigId>
<RefGroupId>3839</RefGroupId>
<EditionId>ServerAzureCor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerAzureCor Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{c9b7954b-4a2f-427a-af9a-4a25dc869452}</ActConfigId>
<RefGroupId>3840</RefGroupId>
<EditionId>ServerAzureCor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerAzureCor VT:IA</ProductDescription>
<ProductKeyType>VT:IA</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{9d0790a8-71df-4851-8f23-9bcd0ccab465}</ActConfigId>
<RefGroupId>3841</RefGroupId>
<EditionId>ServerDatacenterCor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenterCor Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{15721ddf-5d40-4108-bbb2-ca005a47a3ba}</ActConfigId>
<RefGroupId>3842</RefGroupId>
<EditionId>ServerDatacenterEvalCor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenterEvalCor Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{16697af0-f804-42f5-a271-10806ffa3f34}</ActConfigId>
<RefGroupId>3843</RefGroupId>
<EditionId>ServerStandardCor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandardCor Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{a2d15679-7192-43a9-b4dd-37c32061c07b}</ActConfigId>
<RefGroupId>3844</RefGroupId>
<EditionId>ServerStandardEvalCor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandardEvalCor Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{61c5ef22-f14f-4553-a824-c4b31e84b100}</ActConfigId>
<RefGroupId>3955</RefGroupId>
<EditionId>ServerStandardACor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandardACor Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e49c08e7-da82-42f8-bde2-b570fbcae76c}</ActConfigId>
<RefGroupId>3956</RefGroupId>
<EditionId>ServerDatacenterACor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenterACor Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3cf7fce2-a4fd-4edb-80ce-b020caac39fd}</ActConfigId>
<RefGroupId>3958</RefGroupId>
<EditionId>ServerStandardACor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandardACor Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e8ab9c3d-05b1-4ca1-9144-ad80ffea5dbf}</ActConfigId>
<RefGroupId>3959</RefGroupId>
<EditionId>ServerDatacenterACor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenterACor Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{dba63591-83f3-44e9-8ff3-b6f2deb308e6}</ActConfigId>
<RefGroupId>3960</RefGroupId>
<EditionId>ServerStandardACor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandardACor Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{a9bfffb5-7eac-403d-82a6-8cbbca73c6d4}</ActConfigId>
<RefGroupId>3961</RefGroupId>
<EditionId>ServerDatacenterACor</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenterACor Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{7ff5e56b-e3f8-429a-920a-74825b406659}</ActConfigId>
<RefGroupId>3909</RefGroupId>
<EditionId>ServerDatacenter</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerDatacenter OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{f26b07ed-d2ff-41ed-b63f-a3f0d7eb73b6}</ActConfigId>
<RefGroupId>3910</RefGroupId>
<EditionId>ServerStandard</EditionId>
<ProductDescription>Windows Server 2016 RTM ServerStandard OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{0cd7a57e-c051-4f21-8496-7205beebdcc2}</ActConfigId>
<RefGroupId>3754</RefGroupId>
<EditionId>ServerSolution</EditionId>
<ProductDescription>Windows Server Essentials 2016 RTM ServerSolution OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{dcf779a7-90ef-4138-a9d2-df5aecfb0fb2}</ActConfigId>
<RefGroupId>3755</RefGroupId>
<EditionId>ServerSolution</EditionId>
<ProductDescription>Windows Server Essentials 2016 RTM ServerSolution OEM:NONSLP (MUI locked to zh-CN)</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3f05fe09-7744-473b-8813-8481f4656e7b}</ActConfigId>
<RefGroupId>3756</RefGroupId>
<EditionId>ServerSolution</EditionId>
<ProductDescription>Windows Server Essentials 2016 RTM ServerSolution OEM:SLP</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3ab9cd8b-ed58-4b51-846a-f013d7748591}</ActConfigId>
<RefGroupId>3757</RefGroupId>
<EditionId>ServerSolution</EditionId>
<ProductDescription>Windows Server Essentials 2016 RTM ServerSolution OEM:SLP (MUI locked to zh-CN)</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</ActConfigId>
<RefGroupId>3758</RefGroupId>
<EditionId>ServerSolution</EditionId>
<ProductDescription>Windows Server Essentials 2016 RTM ServerSolution Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{64129a84-6d47-48e0-ad16-20232e617f07}</ActConfigId>
<RefGroupId>3759</RefGroupId>
<EditionId>ServerSolution</EditionId>
<ProductDescription>Windows Server Essentials 2016 RTM ServerSolution Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2b5a1b0f-a5ab-4c54-ac2f-a6d94824a283}</ActConfigId>
<RefGroupId>3760</RefGroupId>
<EditionId>ServerSolution</EditionId>
<ProductDescription>Windows Server Essentials 2016 RTM ServerSolution Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{23d0905e-567b-4bde-992d-a1abf86a77d5}</ActConfigId>
<RefGroupId>3761</RefGroupId>
<EditionId>ServerSolution</EditionId>
<ProductDescription>Windows Server Essentials 2016 RTM ServerSolution Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e59d8f3c-05ee-4c5e-9c0f-80200ed0bb54}</ActConfigId>
<RefGroupId>3762</RefGroupId>
<EditionId>ServerSolution</EditionId>
<ProductDescription>Windows Server Essentials 2016 RTM ServerSolution VT:IA</ProductDescription>
<ProductKeyType>VT:IA</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{64e9f058-1cea-4c7b-8f81-6583d6af71dc}</ActConfigId>
<RefGroupId>3748</RefGroupId>
<EditionId>ServerStorageStandard</EditionId>
<ProductDescription>Storage Server 2016 RTM ServerStorageStandard OEM:SLP</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{47ab5c9d-fd76-470d-8b59-c6cd09ae0324}</ActConfigId>
<RefGroupId>3749</RefGroupId>
<EditionId>ServerStorageStandard</EditionId>
<ProductDescription>Storage Server 2016 RTM ServerStorageStandard OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{32546532-818a-4b0e-91d2-41aa58b25e40}</ActConfigId>
<RefGroupId>3750</RefGroupId>
<EditionId>ServerStorageStandard</EditionId>
<ProductDescription>Storage Server 2016 RTM ServerStorageStandard Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3b324c32-ca8f-432b-bc1f-36258140c556}</ActConfigId>
<RefGroupId>3751</RefGroupId>
<EditionId>ServerStorageWorkgroup</EditionId>
<ProductDescription>Storage Server 2016 RTM ServerStorageWorkgroup OEM:SLP</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{886ed35a-3eac-4503-9d31-bcac0ad881be}</ActConfigId>
<RefGroupId>3752</RefGroupId>
<EditionId>ServerStorageWorkgroup</EditionId>
<ProductDescription>Storage Server 2016 RTM ServerStorageWorkgroup OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{dc74cbcb-75e0-4bc9-a706-b4281839e1fe}</ActConfigId>
<RefGroupId>3753</RefGroupId>
<EditionId>ServerStorageWorkgroup</EditionId>
<ProductDescription>Storage Server 2016 RTM ServerStorageWorkgroup Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{bf85655c-0b5b-4c9e-b9cf-5a64e0c053b0}</ActConfigId>
<RefGroupId>3744</RefGroupId>
<EditionId>ServerCloudStorage</EditionId>
<ProductDescription>ServerCloudStorage 2016 RTM ServerCloudStorage OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{36147ad0-32d4-49da-93cd-99cc9c03522b}</ActConfigId>
<RefGroupId>3745</RefGroupId>
<EditionId>ServerCloudStorage</EditionId>
<ProductDescription>ServerCloudStorage 2016 RTM ServerCloudStorage OEM:SLP</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{13649426-c2a8-4211-9b5c-b5c012a37a80}</ActConfigId>
<RefGroupId>3746</RefGroupId>
<EditionId>ServerCloudStorage</EditionId>
<ProductDescription>ServerCloudStorage 2016 RTM ServerCloudStorage Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{7b4433f4-b1e7-4788-895a-c45378d38253}</ActConfigId>
<RefGroupId>3747</RefGroupId>
<EditionId>ServerCloudStorage</EditionId>
<ProductDescription>ServerCloudStorage 2016 RTM ServerCloudStorage Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</ActConfigId>
<RefGroupId>3258</RefGroupId>
<EditionId>Core</EditionId>
<ProductDescription>Win 10 RTM Core OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</ActConfigId>
<RefGroupId>3259</RefGroupId>
<EditionId>Core</EditionId>
<ProductDescription>Win 10 RTM Core OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</ActConfigId>
<RefGroupId>3260</RefGroupId>
<EditionId>Core</EditionId>
<ProductDescription>Win 10 RTM Core OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</ActConfigId>
<RefGroupId>3261</RefGroupId>
<EditionId>Core</EditionId>
<ProductDescription>Win 10 RTM Core Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e371d89a-73e8-4b24-a7ff-23a3641dd18e}</ActConfigId>
<RefGroupId>3262</RefGroupId>
<EditionId>Core</EditionId>
<ProductDescription>Win 10 RTM Core Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{58e97c99-f377-4ef1-81d5-4ad5522b5fd8}</ActConfigId>
<RefGroupId>3263</RefGroupId>
<EditionId>Core</EditionId>
<ProductDescription>Win 10 RTM Core Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</ActConfigId>
<RefGroupId>3264</RefGroupId>
<EditionId>CoreCountrySpecific</EditionId>
<ProductDescription>Win 10 RTM CoreCountrySpecific OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</ActConfigId>
<RefGroupId>3265</RefGroupId>
<EditionId>CoreCountrySpecific</EditionId>
<ProductDescription>Win 10 RTM CoreCountrySpecific OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{1d1bac85-7365-4fea-949a-96978ec91ae0}</ActConfigId>
<RefGroupId>3266</RefGroupId>
<EditionId>CoreCountrySpecific</EditionId>
<ProductDescription>Win 10 RTM CoreCountrySpecific Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{a9107544-f4a0-4053-a96a-1479abdef912}</ActConfigId>
<RefGroupId>3267</RefGroupId>
<EditionId>CoreCountrySpecific</EditionId>
<ProductDescription>Win 10 RTM CoreCountrySpecific Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</ActConfigId>
<RefGroupId>3268</RefGroupId>
<EditionId>CoreN</EditionId>
<ProductDescription>Win 10 RTM CoreN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</ActConfigId>
<RefGroupId>3269</RefGroupId>
<EditionId>CoreN</EditionId>
<ProductDescription>Win 10 RTM CoreN OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</ActConfigId>
<RefGroupId>3270</RefGroupId>
<EditionId>CoreN</EditionId>
<ProductDescription>Win 10 RTM CoreN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{06e74065-465d-4e14-ab23-c34a28aa54aa}</ActConfigId>
<RefGroupId>3271</RefGroupId>
<EditionId>CoreN</EditionId>
<ProductDescription>Win 10 RTM CoreN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{7b9e1751-a8da-4f75-9560-5fadfe3d8e38}</ActConfigId>
<RefGroupId>3272</RefGroupId>
<EditionId>CoreN</EditionId>
<ProductDescription>Win 10 RTM CoreN Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</ActConfigId>
<RefGroupId>3273</RefGroupId>
<EditionId>CoreSingleLanguage</EditionId>
<ProductDescription>Win 10 RTM CoreSingleLanguage OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</ActConfigId>
<RefGroupId>3274</RefGroupId>
<EditionId>CoreSingleLanguage</EditionId>
<ProductDescription>Win 10 RTM CoreSingleLanguage OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</ActConfigId>
<RefGroupId>3275</RefGroupId>
<EditionId>CoreSingleLanguage</EditionId>
<ProductDescription>Win 10 RTM CoreSingleLanguage OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3ae2cc14-ab2d-41f4-972f-5e20142771dc}</ActConfigId>
<RefGroupId>3276</RefGroupId>
<EditionId>CoreSingleLanguage</EditionId>
<ProductDescription>Win 10 RTM CoreSingleLanguage Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{cd918a57-a41b-4c82-8dce-1a538e221a83}</ActConfigId>
<RefGroupId>3277</RefGroupId>
<EditionId>CoreSingleLanguage</EditionId>
<ProductDescription>Win 10 RTM CoreSingleLanguage Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</ActConfigId>
<RefGroupId>3278</RefGroupId>
<EditionId>Education</EditionId>
<ProductDescription>Win 10 RTM Education OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2936d1d2-913a-4542-b54e-ce5a602a2a38}</ActConfigId>
<RefGroupId>3279</RefGroupId>
<EditionId>Education</EditionId>
<ProductDescription>Win 10 RTM Education OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</ActConfigId>
<RefGroupId>3280</RefGroupId>
<EditionId>Education</EditionId>
<ProductDescription>Win 10 RTM Education Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e0c42288-980c-4788-a014-c080d2e1926e}</ActConfigId>
<RefGroupId>3281</RefGroupId>
<EditionId>Education</EditionId>
<ProductDescription>Win 10 RTM Education Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</ActConfigId>
<RefGroupId>3282</RefGroupId>
<EditionId>Education</EditionId>
<ProductDescription>Win 10 RTM Education Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</ActConfigId>
<RefGroupId>3285</RefGroupId>
<EditionId>EducationN</EditionId>
<ProductDescription>Win 10 RTM EducationN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</ActConfigId>
<RefGroupId>3283</RefGroupId>
<EditionId>EducationN</EditionId>
<ProductDescription>Win 10 RTM EducationN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{c6c0a31e-7003-4dff-b4f9-ddc9f8d20af9}</ActConfigId>
<RefGroupId>3284</RefGroupId>
<EditionId>EducationN</EditionId>
<ProductDescription>Win 10 RTM EducationN OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</ActConfigId>
<RefGroupId>3308</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3c102355-d027-42c6-ad23-2e7ef8a02585}</ActConfigId>
<RefGroupId>3286</RefGroupId>
<EditionId>EducationN</EditionId>
<ProductDescription>Win 10 RTM EducationN Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</ActConfigId>
<RefGroupId>3287</RefGroupId>
<EditionId>EducationN</EditionId>
<ProductDescription>Win 10 RTM EducationN Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</ActConfigId>
<RefGroupId>3316</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</ActConfigId>
<RefGroupId>3288</RefGroupId>
<EditionId>Enterprise</EditionId>
<ProductDescription>Win 10 RTM Enterprise OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</ActConfigId>
<RefGroupId>3289</RefGroupId>
<EditionId>Enterprise</EditionId>
<ProductDescription>Win 10 RTM Enterprise OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{73111121-5638-40f6-bc11-f1d7b0d64300}</ActConfigId>
<RefGroupId>3290</RefGroupId>
<EditionId>Enterprise</EditionId>
<ProductDescription>Win 10 RTM Enterprise Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</ActConfigId>
<RefGroupId>3291</RefGroupId>
<EditionId>Enterprise</EditionId>
<ProductDescription>Win 10 RTM Enterprise Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3f4c0546-36c6-46a8-a37f-be13cdd0cf25}</ActConfigId>
<RefGroupId>3292</RefGroupId>
<EditionId>EnterpriseEval</EditionId>
<ProductDescription>Win 10 RTM EnterpriseEval Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</ActConfigId>
<RefGroupId>3293</RefGroupId>
<EditionId>EnterpriseS</EditionId>
<ProductDescription>Win 10 RTM EnterpriseS OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e272e3e2-732f-4c65-a8f0-484747d0d947}</ActConfigId>
<RefGroupId>3299</RefGroupId>
<EditionId>EnterpriseN</EditionId>
<ProductDescription>Win 10 RTM EnterpriseN Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</ActConfigId>
<RefGroupId>3300</RefGroupId>
<EditionId>EnterpriseN</EditionId>
<ProductDescription>Win 10 RTM EnterpriseN Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{1f8dbfe8-defa-4676-b5a6-f76949a01540}</ActConfigId>
<RefGroupId>3301</RefGroupId>
<EditionId>EnterpriseNEval</EditionId>
<ProductDescription>Win 10 RTM EnterpriseNEval Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2a6137f3-75c0-4f26-8e3e-d83d802865a4}</ActConfigId>
<RefGroupId>3304</RefGroupId>
<EditionId>PPIPro</EditionId>
<ProductDescription>Win 10 RTM PPIPro OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</ActConfigId>
<RefGroupId>3305</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</ActConfigId>
<RefGroupId>3306</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</ActConfigId>
<RefGroupId>3425</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</ActConfigId>
<RefGroupId>3307</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{377333b1-8b5d-48d6-9679-1225c872d37c}</ActConfigId>
<RefGroupId>3309</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{b0773a15-df3a-4312-9ad2-83d69648e356}</ActConfigId>
<RefGroupId>3310</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2de67392-b7a7-462a-b1ca-108dd189f588}</ActConfigId>
<RefGroupId>3311</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</ActConfigId>
<RefGroupId>3312</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{ef51e000-2659-4f25-8345-3de70a9cf4c4}</ActConfigId>
<RefGroupId>3313</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</ActConfigId>
<RefGroupId>3314</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</ActConfigId>
<RefGroupId>3315</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalN OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{9c4a7917-c857-4bd5-b109-d21866014b5c}</ActConfigId>
<RefGroupId>3317</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{8a9e86e9-057b-40ca-b11b-307d8f167ae8}</ActConfigId>
<RefGroupId>3318</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{a80b5abf-76ad-428b-b05d-a47d2dffeebf}</ActConfigId>
<RefGroupId>3319</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalN Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</ActConfigId>
<RefGroupId>3320</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalN Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{5694ba59-213b-468a-b2c9-82a4dd09877d}</ActConfigId>
<RefGroupId>3321</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalN Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</ActConfigId>
<RefGroupId>3422</RefGroupId>
<EditionId>Core</EditionId>
<ProductDescription>Win 10 RTM Core OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</ActConfigId>
<RefGroupId>3423</RefGroupId>
<EditionId>CoreCountrySpecific</EditionId>
<ProductDescription>Win 10 RTM CoreCountrySpecific OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{8a292df8-d653-4057-8133-a0701792f912}</ActConfigId>
<RefGroupId>3424</RefGroupId>
<EditionId>CoreSingleLanguage</EditionId>
<ProductDescription>Win 10 RTM CoreSingleLanguage OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{411b3d4f-be6d-4a06-baaa-9cabfc256cae}</ActConfigId>
<RefGroupId>3504</RefGroupId>
<EditionId>Core</EditionId>
<ProductDescription>Win 10 RTM Core Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{74436dbb-cc17-46de-867f-14906ba4a938}</ActConfigId>
<RefGroupId>3505</RefGroupId>
<EditionId>Core</EditionId>
<ProductDescription>Win 10 RTM Core Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{c86d5194-4840-4dae-9c1c-0301003a5ab0}</ActConfigId>
<RefGroupId>3506</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{d6eadb3b-5ca8-4a6b-986e-35b550756111}</ActConfigId>
<RefGroupId>3507</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{fe74f55b-0338-41d6-b267-4a201abe7285}</ActConfigId>
<RefGroupId>3556</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{040fa323-92b1-4baf-97a2-5b67feaefddb}</ActConfigId>
<RefGroupId>3557</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{4053f6e4-20bb-49f2-b808-8385c48b5cd5}</ActConfigId>
<RefGroupId>3558</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{6ccd24e5-8cc4-49ae-8996-dcfdcb4e1dc2}</ActConfigId>
<RefGroupId>3559</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</ActConfigId>
<RefGroupId>3560</RefGroupId>
<EditionId>Core</EditionId>
<ProductDescription>Win 10 RTM Core OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</ActConfigId>
<RefGroupId>3561</RefGroupId>
<EditionId>CoreCountrySpecific</EditionId>
<ProductDescription>Win 10 RTM CoreCountrySpecific OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</ActConfigId>
<RefGroupId>3562</RefGroupId>
<EditionId>CoreSingleLanguage</EditionId>
<ProductDescription>Win 10 RTM CoreSingleLanguage OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</ActConfigId>
<RefGroupId>3563</RefGroupId>
<EditionId>Professional</EditionId>
<ProductDescription>Win 10 RTM Professional OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{8859e3f7-43b0-4a38-87cb-ca00202651c6}</ActConfigId>
<RefGroupId>3678</RefGroupId>
<EditionId>AnalogOneCore</EditionId>
<ProductDescription>Win 10 RTM AnalogOneCore Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{ee7b1257-5c57-42b4-9fe8-4915deb2f679}</ActConfigId>
<RefGroupId>3679</RefGroupId>
<EditionId>AnalogOneCoreEnterprise</EditionId>
<ProductDescription>Win 10 RTM AnalogOneCoreEnterprise Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3c0e0ac0-ae70-462e-9c38-5d48e1cd220f}</ActConfigId>
<RefGroupId>3720</RefGroupId>
<EditionId>IoTUAP</EditionId>
<ProductDescription>Win 10 RTM IoTUAP Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{86a309b8-45f0-4c6c-a637-da4f8fa9a5d7}</ActConfigId>
<RefGroupId>3721</RefGroupId>
<EditionId>IoTUAPCommercial</EditionId>
<ProductDescription>Win 10 RTM IoTUAPCommercial Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</ActConfigId>
<RefGroupId>3802</RefGroupId>
<EditionId>EnterpriseS</EditionId>
<ProductDescription>Win 10 RTM EnterpriseS Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</ActConfigId>
<RefGroupId>3803</RefGroupId>
<EditionId>EnterpriseSN</EditionId>
<ProductDescription>Win 10 RTM EnterpriseSN Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{b47dd250-fd6a-44c8-9217-03aca6e4812e}</ActConfigId>
<RefGroupId>3804</RefGroupId>
<EditionId>EnterpriseSEval</EditionId>
<ProductDescription>Win 10 RTM EnterpriseSEval Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{6162e8c2-3c30-46e1-b964-0de603498e2d}</ActConfigId>
<RefGroupId>3805</RefGroupId>
<EditionId>EnterpriseSNEval</EditionId>
<ProductDescription>Win 10 RTM EnterpriseSNEval Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</ActConfigId>
<RefGroupId>3806</RefGroupId>
<EditionId>EnterpriseS</EditionId>
<ProductDescription>Win 10 RTM EnterpriseS OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</ActConfigId>
<RefGroupId>3807</RefGroupId>
<EditionId>EnterpriseS</EditionId>
<ProductDescription>Win 10 RTM EnterpriseS OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2d5a5a60-3040-48bf-beb0-fcd770c20ce0}</ActConfigId>
<RefGroupId>3782</RefGroupId>
<EditionId>EnterpriseS</EditionId>
<ProductDescription>Win 10 RTM EnterpriseS Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{9f776d83-7156-45b2-8a5c-359b9c9f22a3}</ActConfigId>
<RefGroupId>3783</RefGroupId>
<EditionId>EnterpriseSN</EditionId>
<ProductDescription>Win 10 RTM EnterpriseSN Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{62f0c100-9c53-4e02-b886-a3528ddfe7f6}</ActConfigId>
<RefGroupId>3800</RefGroupId>
<EditionId>ProfessionalEducation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalEducation Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{13a38698-4a49-4b9e-8e83-98fe51110953}</ActConfigId>
<RefGroupId>3801</RefGroupId>
<EditionId>ProfessionalEducationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalEducationN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e7a950a2-e548-4f10-bf16-02ec848e0643}</ActConfigId>
<RefGroupId>3792</RefGroupId>
<EditionId>ProfessionalEducation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalEducation OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{4f3da0d2-271d-4508-ae81-626b60809a38}</ActConfigId>
<RefGroupId>3793</RefGroupId>
<EditionId>ProfessionalEducation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalEducation OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{d559863d-8e3d-4854-b5ea-8e43ffa8079b}</ActConfigId>
<RefGroupId>3794</RefGroupId>
<EditionId>ProfessionalEducationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalEducationN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{58a01bdf-695f-441b-b7c5-bba7b495b894}</ActConfigId>
<RefGroupId>3795</RefGroupId>
<EditionId>ProfessionalEducationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalEducationN OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3f1afc82-f8ac-4f6c-8005-1d233e606eee}</ActConfigId>
<RefGroupId>3784</RefGroupId>
<EditionId>ProfessionalEducation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalEducation Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{5300b18c-2e33-4dc2-8291-47ffcec746dd}</ActConfigId>
<RefGroupId>3785</RefGroupId>
<EditionId>ProfessionalEducationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalEducationN Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{345a5db0-d94f-4e3b-a0c0-7c42f7bc3ebf}</ActConfigId>
<RefGroupId>3786</RefGroupId>
<EditionId>ProfessionalEducation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalEducation Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{550a7080-123a-4c1c-ad73-adebffe64cb0}</ActConfigId>
<RefGroupId>3787</RefGroupId>
<EditionId>ProfessionalEducationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalEducationN Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{be42a013-f6cd-4a01-9e02-7da242d5dab7}</ActConfigId>
<RefGroupId>3854</RefGroupId>
<EditionId>EnterpriseG</EditionId>
<ProductDescription>Win 10 RTM EnterpriseG OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{1ca0bfa8-d96b-4815-a732-7756f30c29e2}</ActConfigId>
<RefGroupId>3855</RefGroupId>
<EditionId>EnterpriseG</EditionId>
<ProductDescription>Win 10 RTM EnterpriseG OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e0b2d383-d112-413f-8a80-97f373a5820c}</ActConfigId>
<RefGroupId>3856</RefGroupId>
<EditionId>EnterpriseG</EditionId>
<ProductDescription>Win 10 RTM EnterpriseG Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</ActConfigId>
<RefGroupId>3857</RefGroupId>
<EditionId>EnterpriseG</EditionId>
<ProductDescription>Win 10 RTM EnterpriseG Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{c03ad91f-6809-42f1-95d9-f59ac06e64b7}</ActConfigId>
<RefGroupId>3859</RefGroupId>
<EditionId>EnterpriseGN</EditionId>
<ProductDescription>Win 10 RTM EnterpriseGN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{8d6f6ffe-0c30-40ec-9db2-aad7b23bb6e3}</ActConfigId>
<RefGroupId>3860</RefGroupId>
<EditionId>EnterpriseGN</EditionId>
<ProductDescription>Win 10 RTM EnterpriseGN OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e38454fb-41a4-4f59-a5dc-25080e354730}</ActConfigId>
<RefGroupId>3861</RefGroupId>
<EditionId>EnterpriseGN</EditionId>
<ProductDescription>Win 10 RTM EnterpriseGN Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</ActConfigId>
<RefGroupId>3862</RefGroupId>
<EditionId>EnterpriseGN</EditionId>
<ProductDescription>Win 10 RTM EnterpriseGN Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{dcc5f846-873c-4a0b-acfc-e6c54257be79}</ActConfigId>
<RefGroupId>3864</RefGroupId>
<EditionId>Cloud</EditionId>
<ProductDescription>Win 10 RTM Cloud OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{d4ef7282-3d2c-4cf0-9976-8854e64a8d1e}</ActConfigId>
<RefGroupId>3865</RefGroupId>
<EditionId>Cloud</EditionId>
<ProductDescription>Win 10 RTM Cloud Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{0c8be5d6-5b9d-4c6c-8065-eec218df39ed}</ActConfigId>
<RefGroupId>3867</RefGroupId>
<EditionId>CloudN</EditionId>
<ProductDescription>Win 10 RTM CloudN OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{af5c9381-9240-417d-8d35-eb40cd03e484}</ActConfigId>
<RefGroupId>3868</RefGroupId>
<EditionId>CloudN</EditionId>
<ProductDescription>Win 10 RTM CloudN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</ActConfigId>
<RefGroupId>3863</RefGroupId>
<EditionId>Cloud</EditionId>
<ProductDescription>Win 10 RTM Cloud OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</ActConfigId>
<RefGroupId>3866</RefGroupId>
<EditionId>CloudN</EditionId>
<ProductDescription>Win 10 RTM CloudN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</ActConfigId>
<RefGroupId>3913</RefGroupId>
<EditionId>Cloud</EditionId>
<ProductDescription>Win 10 RTM Cloud Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</ActConfigId>
<RefGroupId>3914</RefGroupId>
<EditionId>CloudN</EditionId>
<ProductDescription>Win 10 RTM CloudN Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{3502365a-f88a-4ba4-822a-5769d3073b65}</ActConfigId>
<RefGroupId>3915</RefGroupId>
<EditionId>ProfessionalWorkstation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstation OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{95dca82f-385d-4d39-b85b-5c73fa285d6f}</ActConfigId>
<RefGroupId>3916</RefGroupId>
<EditionId>ProfessionalWorkstation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstation OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{eb6d346f-1c60-4643-b960-40ec31596c45}</ActConfigId>
<RefGroupId>3917</RefGroupId>
<EditionId>ProfessionalWorkstation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstation Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{82bbc092-bc50-4e16-8e18-b74fc486aec3}</ActConfigId>
<RefGroupId>3918</RefGroupId>
<EditionId>ProfessionalWorkstation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstation Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</ActConfigId>
<RefGroupId>3919</RefGroupId>
<EditionId>ProfessionalWorkstation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstation Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{608e9c8c-895c-47ad-a336-4abd5ae221a4}</ActConfigId>
<RefGroupId>3920</RefGroupId>
<EditionId>ProfessionalWorkstationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstationN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{9252fc78-051d-4eef-b4e1-ae263a885708}</ActConfigId>
<RefGroupId>3921</RefGroupId>
<EditionId>ProfessionalWorkstationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstationN OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{89e87510-ba92-45f6-8329-3afa905e3e83}</ActConfigId>
<RefGroupId>3922</RefGroupId>
<EditionId>ProfessionalWorkstationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstationN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{4b1571d3-bafb-4b40-8087-a961be2caf65}</ActConfigId>
<RefGroupId>3923</RefGroupId>
<EditionId>ProfessionalWorkstationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstationN Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</ActConfigId>
<RefGroupId>3924</RefGroupId>
<EditionId>ProfessionalWorkstationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstationN Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{6365275e-368d-46ca-a0ef-fc0404119333}</ActConfigId>
<RefGroupId>3798</RefGroupId>
<EditionId>ProfessionalWorkstation</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstation Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e9a93439-eac5-4d1b-9123-f29bd20cc8fc}</ActConfigId>
<RefGroupId>3799</RefGroupId>
<EditionId>ProfessionalWorkstationN</EditionId>
<ProductDescription>Win 10 RTM ProfessionalWorkstationN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{46fc26ea-6671-4d0f-955b-7d984f0bcdad}</ActConfigId>
<RefGroupId>3631</RefGroupId>
<EditionId>MobileCore</EditionId>
<ProductDescription>Win 10 Pre-Release MobileCore Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{ba782239-2781-43bd-b6ce-9fbeb5cec154}</ActConfigId>
<RefGroupId>3632</RefGroupId>
<EditionId>MobileEnterprise</EditionId>
<ProductDescription>Win 10 Pre-Release MobileEnterprise Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{81f9b6d3-8aa5-43d3-abbb-8f8e226e2c63}</ActConfigId>
<RefGroupId>3495</RefGroupId>
<EditionId>MobileCore</EditionId>
<ProductDescription>Win Next Pre-Release MobileCore Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{71153417-69a6-4767-84e3-dd75ad09b44c}</ActConfigId>
<RefGroupId>3496</RefGroupId>
<EditionId>MobileEnterprise</EditionId>
<ProductDescription>Win Next Pre-Release MobileEnterprise Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{ee8464ba-bcf0-4af1-b1b1-b1850b91bfa9}</ActConfigId>
<RefGroupId>3510</RefGroupId>
<EditionId>ServerARM64</EditionId>
<ProductDescription>Windows Server Next Beta ServerARM64 Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{35cc0c20-01a2-4ec5-8f0e-664e5025008f}</ActConfigId>
<RefGroupId>3728</RefGroupId>
<EditionId>CoreSystemServer</EditionId>
<ProductDescription>Windows Server 12 R2 RTM CoreSystemServer Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2bf74405-283d-46ff-a37e-6828c5a5c7c0}</ActConfigId>
<RefGroupId>3732</RefGroupId>
<EditionId>ServerDatacenterNano</EditionId>
<ProductDescription>Windows Server Next RTM ServerDatacenterNano Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{6301fd75-0488-4b9e-b8c2-ae095b1c86bf}</ActConfigId>
<RefGroupId>3733</RefGroupId>
<EditionId>ServerStandardNano</EditionId>
<ProductDescription>Windows Server Next RTM ServerStandardNano Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{df96023b-dcd9-4be2-afa0-c6c871159ebe}</ActConfigId>
<RefGroupId>3892</RefGroupId>
<EditionId>ServerRdsh</EditionId>
<ProductDescription>Windows Server Next Beta ServerRdsh Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{fa755fe6-6739-40b9-8d84-6d0ea3b6d1ab}</ActConfigId>
<RefGroupId>3893</RefGroupId>
<EditionId>ServerRdsh</EditionId>
<ProductDescription>Windows Server Next Beta ServerRdsh OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{0ad2ac98-7bb9-4201-8d92-312299201369}</ActConfigId>
<RefGroupId>3894</RefGroupId>
<EditionId>ServerRdsh</EditionId>
<ProductDescription>Windows Server Next Beta ServerRdsh OEM:SLP</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e4db50ea-bda1-4566-b047-0ca50abc6f07}</ActConfigId>
<RefGroupId>3895</RefGroupId>
<EditionId>ServerRdsh</EditionId>
<ProductDescription>Windows Server Next Beta ServerRdsh Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{291ece0e-9c38-40ca-a9e1-32cc7ec19507}</ActConfigId>
<RefGroupId>3896</RefGroupId>
<EditionId>ServerRdsh</EditionId>
<ProductDescription>Windows Server Next Beta ServerRdsh Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{b13d53d4-1a21-4d49-9eb1-20c7eafc77d4}</ActConfigId>
<RefGroupId>1790</RefGroupId>
<EditionId>CoreN</EditionId>
<ProductDescription>Win 8 RTM CoreN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{73416275-0240-425f-90d9-d92590083699}</ActConfigId>
<RefGroupId>1798</RefGroupId>
<EditionId>ProfessionalN</EditionId>
<ProductDescription>Win 8 RTM ProfessionalN OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{ed36b7fc-be9b-4889-b89d-0243f716df2b}</ActConfigId>
<RefGroupId>1792</RefGroupId>
<EditionId>CoreCountrySpecific</EditionId>
<ProductDescription>Win 8 RTM CoreCountrySpecific OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{b0f8a518-2c58-4eb8-9319-084f0eb4ddc4}</ActConfigId>
<RefGroupId>1913</RefGroupId>
<EditionId>CoreSingleLanguage</EditionId>
<ProductDescription>Win 8 RTM CoreSingleLanguage OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{71f411ae-7b4b-41bd-b68c-c519c499f950}</ActConfigId>
<RefGroupId>1794</RefGroupId>
<EditionId>CoreSingleLanguage</EditionId>
<ProductDescription>Win 8 RTM CoreSingleLanguage OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{23505d51-32d6-41f0-8ca7-e78ad0f16e71}</ActConfigId>
<RefGroupId>100054</RefGroupId>
<EditionId>Starter</EditionId>
<ProductDescription>Win Next Starter Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{211b80cc-7f64-482c-89e9-4ba21ff827ad}</ActConfigId>
<RefGroupId>100055</RefGroupId>
<EditionId>StarterN</EditionId>
<ProductDescription>Win Next StarterN Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{0aa31bde-a50d-4544-9434-a8154e1f4ebe}</ActConfigId>
<RefGroupId>1875</RefGroupId>
<EditionId>Embedded</EditionId>
<ProductDescription>Windows Embedded Standard 8 RC Embedded Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{98f1827a-79be-4945-8957-304d283c95e5}</ActConfigId>
<RefGroupId>1873</RefGroupId>
<EditionId>Embedded</EditionId>
<ProductDescription>Windows Embedded Standard 8 RC Embedded Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e1ef459b-eb4c-4609-baee-9b8b3d9aa222}</ActConfigId>
<RefGroupId>1884</RefGroupId>
<EditionId>EmbeddedE</EditionId>
<ProductDescription>Windows Embedded Standard 8 RC EmbeddedE Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{215f2ffd-4c88-416f-966c-0315549c5a26}</ActConfigId>
<RefGroupId>1885</RefGroupId>
<EditionId>EmbeddedE</EditionId>
<ProductDescription>Windows Embedded Standard 8 RC EmbeddedE Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{0d17ff59-c618-4007-ab49-d48c941a8bcc}</ActConfigId>
<RefGroupId>1058</RefGroupId>
<EditionId>ServerWeb</EditionId>
<ProductDescription>WinServer Next ServerWeb OEM:DM</ProductDescription>
<ProductKeyType>OEM:DM</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{cb20a646-4bcb-4615-820a-e832a5e79942}</ActConfigId>
<RefGroupId>1059</RefGroupId>
<EditionId>ServerWeb</EditionId>
<ProductDescription>WinServer Next ServerWeb OEM:SLP</ProductDescription>
<ProductKeyType>OEM:SLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{89dda8f4-eefe-498d-9f25-201a763c0824}</ActConfigId>
<RefGroupId>1060</RefGroupId>
<EditionId>ServerWeb</EditionId>
<ProductDescription>WinServer Next ServerWeb OEM:NONSLP</ProductDescription>
<ProductKeyType>OEM:NONSLP</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{793fbec3-7313-469e-bfd3-938123de3e85}</ActConfigId>
<RefGroupId>1061</RefGroupId>
<EditionId>ServerWeb</EditionId>
<ProductDescription>WinServer Next ServerWeb OEM:COA</ProductDescription>
<ProductKeyType>OEM:COA</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{1be52dfa-347b-4ea9-a5a0-903fe990a797}</ActConfigId>
<RefGroupId>1345</RefGroupId>
<EditionId>ServerWeb</EditionId>
<ProductDescription>WinServer Next ServerWeb Retail</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{53cfae25-4180-4d86-bfcf-ff4d1adb9caa}</ActConfigId>
<RefGroupId>1346</RefGroupId>
<EditionId>ServerWeb</EditionId>
<ProductDescription>WinServer Next ServerWeb Retail:TB:Eval</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{972ba9b4-65c4-47c2-9b12-febfdd2604b3}</ActConfigId>
<RefGroupId>1347</RefGroupId>
<EditionId>ServerWeb</EditionId>
<ProductDescription>WinServer Next ServerWeb Volume:MAK</ProductDescription>
<ProductKeyType>Volume:MAK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e5676f13-9b66-4a1f-8b0c-43490e236202}</ActConfigId>
<RefGroupId>1348</RefGroupId>
<EditionId>ServerWeb</EditionId>
<ProductDescription>WinServer Next ServerWeb Volume:GVLK</ProductDescription>
<ProductKeyType>Volume:GVLK</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{80ed1ba0-2fe4-432e-9430-150359e7679b}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>EmbeddedEval</EditionId>
<ProductDescription>VV6W8-NF7BJ-FKHGQ-P424D-FHC7K</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{a1564da7-3cb5-4ac3-b70c-7e6c0c4a8bf1}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>EmbeddedEEval</EditionId>
<ProductDescription>VKKC6-NQQQH-JW3QX-XRVKX-KJJK9</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{0cc8648c-345c-4576-a335-69f12dcbc9e3}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>J2ND2-BCW98-8669Y-HPBF3-RDY99</EditionId>
<ProductDescription>J2ND2-BCW98-8669Y-HPBF3-RDY99</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{a72a7c81-fe67-46b5-a69c-7624a1bfe5e9}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>ServerStorageStandardEval</EditionId>
<ProductDescription>3HDCN-87G3V-FPCDF-C6HTB-79Q3X</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{fb91c3ec-ea4d-42f4-a765-2dcd66bb1ece}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>ServerStorageWorkgroupEval</EditionId>
<ProductDescription>NXCTR-YXXWC-TK368-HGGTF-8YB99</ProductDescription>
<ProductKeyType>Retail:TB:Eval</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{f7af7d09-40e4-419c-a49b-eae366689ebd}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>ProfessionalCountrySpecific</EditionId>
<ProductDescription>HNGCC-Y38KG-QVK8D-WMWRK-X86VK</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{a48938aa-62fa-4966-9d44-9f04da3f72f2}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>ProfessionalSingleLanguage</EditionId>
<ProductDescription>G3KNM-CHG6T-R36X3-9QDG6-8M8K9</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{9c4d84ee-befc-4c86-9dde-af7d36267a8a}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>VQ7FC-RTNC8-RHDFR-8THVR-J633X</EditionId>
<ProductDescription>VQ7FC-RTNC8-RHDFR-8THVR-J633X</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{237f6a98-d028-474d-93ed-226c70a90e68}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>N3FPV-KQP4R-4M6H6-7Q8TK-HYMDX</EditionId>
<ProductDescription>N3FPV-KQP4R-4M6H6-7Q8TK-HYMDX</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{b71515d9-89a2-4c60-88c8-656fbcca7f3a}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>MNMRC-69F8V-2FCXX-GFQVY-BXQ3X</EditionId>
<ProductDescription>MNMRC-69F8V-2FCXX-GFQVY-BXQ3X</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{884e5c0c-c968-4182-a7c3-a37d2f716531}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>P7CCN-72DMB-93C9B-C9PD7-379HK</EditionId>
<ProductDescription>P7CCN-72DMB-93C9B-C9PD7-379HK</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{55da3f53-5faa-4d2b-9a0f-e49094d7e942}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>48FWV-TNW4T-CQ6F4-KVGQB-K3D3X</EditionId>
<ProductDescription>48FWV-TNW4T-CQ6F4-KVGQB-K3D3X</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{583f15fe-fbc2-44de-9cb3-bc196b9a8f0d}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>Embedded</EditionId>
<ProductDescription>NMGYT-GD9DR-298BC-TXK84-4TGVK</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{735dc33a-d41d-442b-9b70-61f680da0917}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>EmbeddedE</EditionId>
<ProductDescription>MNKW8-HYCCD-G88JY-283WV-W9FX9</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{65d62b33-ca15-4d93-b446-e3473ebc341c}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>J427X-9NHBK-VRWQQ-B8Y42-T927K</EditionId>
<ProductDescription>J427X-9NHBK-VRWQQ-B8Y42-T927K</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{6fb525d4-9952-4b70-ac7b-ff0aa7e20e41}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>KD69N-VWMRK-Y9KBG-FCBM3-KF7QX</EditionId>
<ProductDescription>KD69N-VWMRK-Y9KBG-FCBM3-KF7QX</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{ce7dd669-1230-444f-a107-2c5bd1ba8117}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>THYVN-T3TXR-Q6WQP-694PR-BVC7K</EditionId>
<ProductDescription>THYVN-T3TXR-Q6WQP-694PR-BVC7K</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{e35a5d2a-7de6-4266-893e-b9e5bf950dcd}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>JH8W6-VMNWP-6QBDM-PBP4B-J9FX9</EditionId>
<ProductDescription>JH8W6-VMNWP-6QBDM-PBP4B-J9FX9</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{47305a46-dd4b-469e-bf7d-fd5ceef69c41}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>9XMK8-N3FG8-KH2T4-T9QJM-HPHQX</EditionId>
<ProductDescription>9XMK8-N3FG8-KH2T4-T9QJM-HPHQX</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{442fc1f5-021c-48f7-945b-563e762c95fe}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>BGN6F-KCBM8-HCFMM-Q744R-W3P7K</EditionId>
<ProductDescription>BGN6F-KCBM8-HCFMM-Q744R-W3P7K</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{326eb516-f215-49c4-9fe2-41065a739d6a}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>H7XNC-JYM86-7B27X-8MJ9W-TKFX9</EditionId>
<ProductDescription>H7XNC-JYM86-7B27X-8MJ9W-TKFX9</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{b1c1e105-597d-4aac-9e1d-c7e264c4c91f}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>XMMNR-TCVTR-DK8GY-KKJ33-3HM99</EditionId>
<ProductDescription>XMMNR-TCVTR-DK8GY-KKJ33-3HM99</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{050d1eb7-2345-4eb7-a0b2-0a2c147db37b}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>RGT4M-CYNRC-2JMPJ-GRVWC-7YMDX</EditionId>
<ProductDescription>RGT4M-CYNRC-2JMPJ-GRVWC-7YMDX</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{d09822a3-9040-4510-8242-9fc1cfd558d3}</ActConfigId>
<RefGroupId>999999</RefGroupId>
<EditionId>NTVV8-X6TR6-CPVQK-KHDV4-9RBDX</EditionId>
<ProductDescription>NTVV8-X6TR6-CPVQK-KHDV4-9RBDX</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
<Configuration>
<ActConfigId>{2cf1c8d6-ebe1-4ce9-83c6-c4877fae1355}</ActConfigId>
<RefGroupId>152</RefGroupId>
<EditionId>ServerHyper</EditionId>
<ProductDescription>Hyper-V ProdAct All Programs</ProductDescription>
<ProductKeyType>Retail</ProductKeyType>
<IsRandomized>false</IsRandomized>
</Configuration>
</Configurations>
<KeyRanges>
<KeyRange>
<RefActConfigId>{afd55ac6-d0b0-4812-9047-6c756d82bedf}</RefActConfigId>
<PartNumber>[RS1]X21-03125:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{afd55ac6-d0b0-4812-9047-6c756d82bedf}</RefActConfigId>
<PartNumber>[RS1]X21-03126:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>11499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{afd55ac6-d0b0-4812-9047-6c756d82bedf}</RefActConfigId>
<PartNumber>[RS1]X21-03127:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>11500000</Start>
<End>41499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{afd55ac6-d0b0-4812-9047-6c756d82bedf}</RefActConfigId>
<PartNumber>[RS1]X21-03128:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>41500000</Start>
<End>71499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{afd55ac6-d0b0-4812-9047-6c756d82bedf}</RefActConfigId>
<PartNumber>[RS1]X21-03129:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>71500000</Start>
<End>81499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{afd55ac6-d0b0-4812-9047-6c756d82bedf}</RefActConfigId>
<PartNumber>[RS1]X21-03219:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>81500000</Start>
<End>141499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{afd55ac6-d0b0-4812-9047-6c756d82bedf}</RefActConfigId>
<PartNumber>[RS1]X21-03220:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>141500000</Start>
<End>146499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{afd55ac6-d0b0-4812-9047-6c756d82bedf}</RefActConfigId>
<PartNumber>[RS1]X21-03221:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>146500000</Start>
<End>146999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{21c56779-b449-4d20-adfc-eece0e1ad74b}</RefActConfigId>
<PartNumber>[RS1]X21-03130</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>29</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{21c56779-b449-4d20-adfc-eece0e1ad74b}</RefActConfigId>
<PartNumber>[RS1]X21-03131</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>30</Start>
<End>59</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03132:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>6499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03133:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>6500000</Start>
<End>9499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03134:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9500000</Start>
<End>12499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03135:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>12500000</Start>
<End>18499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03136:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18500000</Start>
<End>24999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03137:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>25000000</Start>
<End>31499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03138:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>31500000</Start>
<End>37999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03139:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38000000</Start>
<End>44499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03140:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>44500000</Start>
<End>50999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03141:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>51000000</Start>
<End>57499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03142:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>57500000</Start>
<End>63999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03143:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>64000000</Start>
<End>70499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03144:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>70500000</Start>
<End>71499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03145:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>71500000</Start>
<End>71999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03146:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>72000000</Start>
<End>72999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03147:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>73000000</Start>
<End>73999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03148:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>74000000</Start>
<End>74999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03149:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>75000000</Start>
<End>75999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03150:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>76000000</Start>
<End>76999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03151:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>77000000</Start>
<End>77999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03152:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>78000000</Start>
<End>78999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03153:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>79000000</Start>
<End>79999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03154:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>80000000</Start>
<End>80999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03155:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>81000000</Start>
<End>85999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03156:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>86000000</Start>
<End>86049999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]X21-03157:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>86050000</Start>
<End>86249999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{562634bb-b8d8-43eb-8325-bf63a42c4174}</RefActConfigId>
<PartNumber>[RS1]X21-03158:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{562634bb-b8d8-43eb-8325-bf63a42c4174}</RefActConfigId>
<PartNumber>[RS1]X21-03159:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>50</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a43f7b89-8023-413a-9f58-b8aec2c04d00}</RefActConfigId>
<PartNumber>[RS1]X21-03160:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>5999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a43f7b89-8023-413a-9f58-b8aec2c04d00}</RefActConfigId>
<PartNumber>[RS1]X21-03161:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>6000000</Start>
<End>7999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a43f7b89-8023-413a-9f58-b8aec2c04d00}</RefActConfigId>
<PartNumber>[RS1]X21-03162:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>8000000</Start>
<End>8099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a43f7b89-8023-413a-9f58-b8aec2c04d00}</RefActConfigId>
<PartNumber>[RS1]X21-03163:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>8100000</Start>
<End>10099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a43f7b89-8023-413a-9f58-b8aec2c04d00}</RefActConfigId>
<PartNumber>[RS1]X21-03164:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10100000</Start>
<End>16599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a43f7b89-8023-413a-9f58-b8aec2c04d00}</RefActConfigId>
<PartNumber>[RS1]X21-03165:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>16600000</Start>
<End>36599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a43f7b89-8023-413a-9f58-b8aec2c04d00}</RefActConfigId>
<PartNumber>[RS1]X21-03166:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>36600000</Start>
<End>38599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a43f7b89-8023-413a-9f58-b8aec2c04d00}</RefActConfigId>
<PartNumber>[RS1]X21-03222:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>38600000</Start>
<End>45099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{942efa8f-516f-46d8-8541-b1ee1bce08c6}</RefActConfigId>
<PartNumber>[RS1]X21-03167:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>19999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{942efa8f-516f-46d8-8541-b1ee1bce08c6}</RefActConfigId>
<PartNumber>[RS1]X21-03169:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000</Start>
<End>519999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{cbf3499f-848e-488b-a165-ac6d7e27439d}</RefActConfigId>
<PartNumber>[RS1]X21-03168</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>19999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{cbf3499f-848e-488b-a165-ac6d7e27439d}</RefActConfigId>
<PartNumber>[RS1]X21-03170</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000</Start>
<End>39999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{cbf3499f-848e-488b-a165-ac6d7e27439d}</RefActConfigId>
<PartNumber>[RS1]X21-03171</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40000</Start>
<End>59999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{cbf3499f-848e-488b-a165-ac6d7e27439d}</RefActConfigId>
<PartNumber>[RS1]X21-03172</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60000</Start>
<End>79999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{cbf3499f-848e-488b-a165-ac6d7e27439d}</RefActConfigId>
<PartNumber>[RS1]X21-03173</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>80000</Start>
<End>99999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58448dfb-6ac0-4e06-b491-07f2b657b268}</RefActConfigId>
<PartNumber>[RS1]X21-03174</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>19999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58448dfb-6ac0-4e06-b491-07f2b657b268}</RefActConfigId>
<PartNumber>[RS1]X21-03218</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000</Start>
<End>39999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{01398239-85ff-487f-9e90-0e3cc5bcc92e}</RefActConfigId>
<PartNumber>[RS1]X21-03175:Virtual</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a2ae7054-d580-4c06-a79b-1662e6f6955c}</RefActConfigId>
<PartNumber>[RS1]X21-03176:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a2ae7054-d580-4c06-a79b-1662e6f6955c}</RefActConfigId>
<PartNumber>[RS1]X21-03177:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a2ae7054-d580-4c06-a79b-1662e6f6955c}</RefActConfigId>
<PartNumber>[RS1]X21-03178:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>43999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a2ae7054-d580-4c06-a79b-1662e6f6955c}</RefActConfigId>
<PartNumber>[RS1]X21-03179:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>44000000</Start>
<End>44999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a2ae7054-d580-4c06-a79b-1662e6f6955c}</RefActConfigId>
<PartNumber>[RS1]X21-03180:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>45000000</Start>
<End>46999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a2ae7054-d580-4c06-a79b-1662e6f6955c}</RefActConfigId>
<PartNumber>[RS1]X21-03181:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>47000000</Start>
<End>47999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a2ae7054-d580-4c06-a79b-1662e6f6955c}</RefActConfigId>
<PartNumber>[RS1]X21-03182:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>48000000</Start>
<End>48099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{60d99e35-ba21-46e5-abf9-877d5dd815de}</RefActConfigId>
<PartNumber>[RS1]X21-03183:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>2999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{60d99e35-ba21-46e5-abf9-877d5dd815de}</RefActConfigId>
<PartNumber>[RS1]X21-03184:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>3000000</Start>
<End>5999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{60d99e35-ba21-46e5-abf9-877d5dd815de}</RefActConfigId>
<PartNumber>[RS1]X21-03185:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>6000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f70cf82b-0a95-4f14-a0a9-cb968d337962}</RefActConfigId>
<PartNumber>[RS1]X21-03186</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>19999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f70cf82b-0a95-4f14-a0a9-cb968d337962}</RefActConfigId>
<PartNumber>[RS1]X21-03187</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000</Start>
<End>39999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f70cf82b-0a95-4f14-a0a9-cb968d337962}</RefActConfigId>
<PartNumber>[RS1]X21-03188</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40000</Start>
<End>59999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f70cf82b-0a95-4f14-a0a9-cb968d337962}</RefActConfigId>
<PartNumber>[RS1]X21-03189</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60000</Start>
<End>60099</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f3d100a3-7544-4580-be0b-88d452b4a881}</RefActConfigId>
<PartNumber>[RS1]X21-03190</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>19999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f3d100a3-7544-4580-be0b-88d452b4a881}</RefActConfigId>
<PartNumber>[RS1]X21-03192</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000</Start>
<End>39999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8c1c5410-9f39-4805-8c9d-63a07706358f}</RefActConfigId>
<PartNumber>[RS1]X21-03191</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03193:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>2999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03194:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>3000000</Start>
<End>5999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03195:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>6000000</Start>
<End>6099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03196:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>6100000</Start>
<End>12599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03197:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>12600000</Start>
<End>19099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03198:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>19100000</Start>
<End>25599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03199:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>25600000</Start>
<End>32099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03200:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>32100000</Start>
<End>38599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03201:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38600000</Start>
<End>45099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03202:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>45100000</Start>
<End>51599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03203:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>51600000</Start>
<End>58099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03204:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>58100000</Start>
<End>64599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03205:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>64600000</Start>
<End>71099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]X21-03206:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>71100000</Start>
<End>71599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{179bbfdb-3b18-4fa6-af8f-86f740f28fef}</RefActConfigId>
<PartNumber>[RS1]X21-03210:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</RefActConfigId>
<PartNumber>[RS1]X21-03207:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</RefActConfigId>
<PartNumber>[RS1]X21-03208:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>60999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</RefActConfigId>
<PartNumber>[RS1]X21-03209:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>61000000</Start>
<End>90999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</RefActConfigId>
<PartNumber>[RS1]X21-03211:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>91000000</Start>
<End>91999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</RefActConfigId>
<PartNumber>[RS1]X21-03212:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>92000000</Start>
<End>100999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</RefActConfigId>
<PartNumber>[RS1]X21-03213:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>101000000</Start>
<End>130999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</RefActConfigId>
<PartNumber>[RS1]X21-03214:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>131000000</Start>
<End>131999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</RefActConfigId>
<PartNumber>[RS1]X21-03215:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>132000000</Start>
<End>132999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</RefActConfigId>
<PartNumber>[RS1]X21-03216:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>133000000</Start>
<End>133499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9dfa8ec0-7665-4b9d-b2cb-bfc2dc37c9f4}</RefActConfigId>
<PartNumber>[RS1]X21-03217:Virtual</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9297796b-3972-4347-906e-78905da547e2}</RefActConfigId>
<PartNumber>[RS1]X21-14947:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b3404d38-04ef-4811-b233-570e528096d1}</RefActConfigId>
<PartNumber>[RS1]X21-14946:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3dbf341b-5f6c-4fa7-b936-699dce9e263f}</RefActConfigId>
<PartNumber>[RS1]X21-14945</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c9b7954b-4a2f-427a-af9a-4a25dc869452}</RefActConfigId>
<PartNumber>[RS1]X21-14944:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9d0790a8-71df-4851-8f23-9bcd0ccab465}</RefActConfigId>
<PartNumber>[RS1]X21-14951:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{15721ddf-5d40-4108-bbb2-ca005a47a3ba}</RefActConfigId>
<PartNumber>[RS1]X21-14948:Virtual</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{16697af0-f804-42f5-a271-10806ffa3f34}</RefActConfigId>
<PartNumber>[RS1]X21-14950:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a2d15679-7192-43a9-b4dd-37c32061c07b}</RefActConfigId>
<PartNumber>[RS1]X21-14949:Virtual</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{61c5ef22-f14f-4553-a824-c4b31e84b100}</RefActConfigId>
<PartNumber>[RS3]X21-47421</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e49c08e7-da82-42f8-bde2-b570fbcae76c}</RefActConfigId>
<PartNumber>[RS3]X21-47420</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3cf7fce2-a4fd-4edb-80ce-b020caac39fd}</RefActConfigId>
<PartNumber>[RS3]X21-48274:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e8ab9c3d-05b1-4ca1-9144-ad80ffea5dbf}</RefActConfigId>
<PartNumber>[RS3]X21-48273:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dba63591-83f3-44e9-8ff3-b6f2deb308e6}</RefActConfigId>
<PartNumber>[RS3]X21-48276:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a9bfffb5-7eac-403d-82a6-8cbbca73c6d4}</RefActConfigId>
<PartNumber>[RS3]X21-48275:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7ff5e56b-e3f8-429a-920a-74825b406659}</RefActConfigId>
<PartNumber>[RS3]X21-41758:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7ff5e56b-e3f8-429a-920a-74825b406659}</RefActConfigId>
<PartNumber>[RS3]X21-41757:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>204999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7ff5e56b-e3f8-429a-920a-74825b406659}</RefActConfigId>
<PartNumber>[RS3]X21-41760:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>205000000</Start>
<End>209999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f26b07ed-d2ff-41ed-b63f-a3f0d7eb73b6}</RefActConfigId>
<PartNumber>[RS3]X21-41759:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f26b07ed-d2ff-41ed-b63f-a3f0d7eb73b6}</RefActConfigId>
<PartNumber>[RS3]X21-41761:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>204999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f26b07ed-d2ff-41ed-b63f-a3f0d7eb73b6}</RefActConfigId>
<PartNumber>[RS3]X21-41762:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>205000000</Start>
<End>209999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{afd55ac6-d0b0-4812-9047-6c756d82bedf}</RefActConfigId>
<PartNumber>[RS1]res-v3763:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>147000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{21c56779-b449-4d20-adfc-eece0e1ad74b}</RefActConfigId>
<PartNumber>[RS1]res-v3764</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>60</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fea51083-1906-44ed-9072-86af9be7ab9a}</RefActConfigId>
<PartNumber>[RS1]res-v3765:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>86250000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{562634bb-b8d8-43eb-8325-bf63a42c4174}</RefActConfigId>
<PartNumber>[RS1]res-v3766:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a43f7b89-8023-413a-9f58-b8aec2c04d00}</RefActConfigId>
<PartNumber>[RS1]res-v3767:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>45100000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{942efa8f-516f-46d8-8541-b1ee1bce08c6}</RefActConfigId>
<PartNumber>[RS1]res-v3768:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>520000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{cbf3499f-848e-488b-a165-ac6d7e27439d}</RefActConfigId>
<PartNumber>[RS1]res-v3769</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58448dfb-6ac0-4e06-b491-07f2b657b268}</RefActConfigId>
<PartNumber>[RS1]res-v3770</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{01398239-85ff-487f-9e90-0e3cc5bcc92e}</RefActConfigId>
<PartNumber>[RS1]res-v3771:Virtual</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>50</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a2ae7054-d580-4c06-a79b-1662e6f6955c}</RefActConfigId>
<PartNumber>[RS1]res-v3772:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>48100000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{60d99e35-ba21-46e5-abf9-877d5dd815de}</RefActConfigId>
<PartNumber>[RS1]res-v3773:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f70cf82b-0a95-4f14-a0a9-cb968d337962}</RefActConfigId>
<PartNumber>[RS1]res-v3774</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f3d100a3-7544-4580-be0b-88d452b4a881}</RefActConfigId>
<PartNumber>[RS1]res-v3775</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8c1c5410-9f39-4805-8c9d-63a07706358f}</RefActConfigId>
<PartNumber>[RS1]res-v3776</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>50</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c0b765fd-6e2e-42f9-80d7-4a7ca0d118cf}</RefActConfigId>
<PartNumber>[RS1]res-v3777:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>71600000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{179bbfdb-3b18-4fa6-af8f-86f740f28fef}</RefActConfigId>
<PartNumber>[RS1]res-v3778:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>50</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d839f159-1128-480b-94b6-77fa9943a16a}</RefActConfigId>
<PartNumber>[RS1]res-v3779:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>133500000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9dfa8ec0-7665-4b9d-b2cb-bfc2dc37c9f4}</RefActConfigId>
<PartNumber>[RS1]res-v3780:Virtual</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dba63591-83f3-44e9-8ff3-b6f2deb308e6}</RefActConfigId>
<PartNumber>[RS3]res-v3960:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a9bfffb5-7eac-403d-82a6-8cbbca73c6d4}</RefActConfigId>
<PartNumber>[RS3]res-v3961:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7ff5e56b-e3f8-429a-920a-74825b406659}</RefActConfigId>
<PartNumber>[RS3]res-v3909:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>210000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f26b07ed-d2ff-41ed-b63f-a3f0d7eb73b6}</RefActConfigId>
<PartNumber>[RS3]res-v3910:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>210000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0cd7a57e-c051-4f21-8496-7205beebdcc2}</RefActConfigId>
<PartNumber>[RS1]X21-03223:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0cd7a57e-c051-4f21-8496-7205beebdcc2}</RefActConfigId>
<PartNumber>[RS1]X21-03224:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000</Start>
<End>6199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0cd7a57e-c051-4f21-8496-7205beebdcc2}</RefActConfigId>
<PartNumber>[RS1]X21-03246:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>6200000</Start>
<End>26199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcf779a7-90ef-4138-a9d2-df5aecfb0fb2}</RefActConfigId>
<PartNumber>[RS1]X21-03245:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>1999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3f05fe09-7744-473b-8813-8481f4656e7b}</RefActConfigId>
<PartNumber>[RS1]X21-03226</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>2499</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ab9cd8b-ed58-4b51-846a-f013d7748591}</RefActConfigId>
<PartNumber>[RS1]X21-03225</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>2499</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</RefActConfigId>
<PartNumber>[RS1]X21-03227:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</RefActConfigId>
<PartNumber>[RS1]X21-03228:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>1099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</RefActConfigId>
<PartNumber>[RS1]X21-03229:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1100000</Start>
<End>31099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</RefActConfigId>
<PartNumber>[RS1]X21-03230:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>31100000</Start>
<End>86099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</RefActConfigId>
<PartNumber>[RS1]X21-03231:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>86100000</Start>
<End>93099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</RefActConfigId>
<PartNumber>[RS1]X21-03232:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>93100000</Start>
<End>97099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</RefActConfigId>
<PartNumber>[RS1]X21-03233:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>97100000</Start>
<End>103099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</RefActConfigId>
<PartNumber>[RS1]X21-03235:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>103100000</Start>
<End>131099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</RefActConfigId>
<PartNumber>[RS1]X21-03244:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>131100000</Start>
<End>132099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{64129a84-6d47-48e0-ad16-20232e617f07}</RefActConfigId>
<PartNumber>[RS1]X21-03234:Virtual</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>29</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b5a1b0f-a5ab-4c54-ac2f-a6d94824a283}</RefActConfigId>
<PartNumber>[RS1]X21-03237</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{23d0905e-567b-4bde-992d-a1abf86a77d5}</RefActConfigId>
<PartNumber>[RS1]X21-03236:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>5999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{23d0905e-567b-4bde-992d-a1abf86a77d5}</RefActConfigId>
<PartNumber>[RS1]X21-03238:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>6000000</Start>
<End>7999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{23d0905e-567b-4bde-992d-a1abf86a77d5}</RefActConfigId>
<PartNumber>[RS1]X21-03239:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>8000000</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{23d0905e-567b-4bde-992d-a1abf86a77d5}</RefActConfigId>
<PartNumber>[RS1]X21-03240:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>10499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{23d0905e-567b-4bde-992d-a1abf86a77d5}</RefActConfigId>
<PartNumber>[RS1]X21-03241:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>10500000</Start>
<End>11499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{23d0905e-567b-4bde-992d-a1abf86a77d5}</RefActConfigId>
<PartNumber>[RS1]X21-03243:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>11500000</Start>
<End>16499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e59d8f3c-05ee-4c5e-9c0f-80200ed0bb54}</RefActConfigId>
<PartNumber>[RS1]X21-03242:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>29</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0cd7a57e-c051-4f21-8496-7205beebdcc2}</RefActConfigId>
<PartNumber>[RS1]res-v3754:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>26200000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcf779a7-90ef-4138-a9d2-df5aecfb0fb2}</RefActConfigId>
<PartNumber>[RS1]res-v3755:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>2000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3f05fe09-7744-473b-8813-8481f4656e7b}</RefActConfigId>
<PartNumber>[RS1]res-v3756</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>2500</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ab9cd8b-ed58-4b51-846a-f013d7748591}</RefActConfigId>
<PartNumber>[RS1]res-v3757</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>2500</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2804c327-d727-4813-b230-18c73e11f7cc}</RefActConfigId>
<PartNumber>[RS1]res-v3758:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>132100000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{64129a84-6d47-48e0-ad16-20232e617f07}</RefActConfigId>
<PartNumber>[RS1]res-v3759:Virtual</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>30</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b5a1b0f-a5ab-4c54-ac2f-a6d94824a283}</RefActConfigId>
<PartNumber>[RS1]res-v3760</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>50</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{23d0905e-567b-4bde-992d-a1abf86a77d5}</RefActConfigId>
<PartNumber>[RS1]res-v3761:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>16500000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e59d8f3c-05ee-4c5e-9c0f-80200ed0bb54}</RefActConfigId>
<PartNumber>[RS1]res-v3762:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>30</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{64e9f058-1cea-4c7b-8f81-6583d6af71dc}</RefActConfigId>
<PartNumber>[RS1]X21-03247</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{64e9f058-1cea-4c7b-8f81-6583d6af71dc}</RefActConfigId>
<PartNumber>[RS1]X21-03264</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000</Start>
<End>7499</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{64e9f058-1cea-4c7b-8f81-6583d6af71dc}</RefActConfigId>
<PartNumber>[RS1]X21-03265</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>7500</Start>
<End>13999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{47ab5c9d-fd76-470d-8b59-c6cd09ae0324}</RefActConfigId>
<PartNumber>[RS1]X21-03251:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>2999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{47ab5c9d-fd76-470d-8b59-c6cd09ae0324}</RefActConfigId>
<PartNumber>[RS1]X21-03266:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>3000000</Start>
<End>5999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{32546532-818a-4b0e-91d2-41aa58b25e40}</RefActConfigId>
<PartNumber>[RS1]X21-03248:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{32546532-818a-4b0e-91d2-41aa58b25e40}</RefActConfigId>
<PartNumber>[RS1]X21-03249:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>500000</Start>
<End>3499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{32546532-818a-4b0e-91d2-41aa58b25e40}</RefActConfigId>
<PartNumber>[RS1]X21-03250:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>3500000</Start>
<End>6499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{32546532-818a-4b0e-91d2-41aa58b25e40}</RefActConfigId>
<PartNumber>[RS1]X21-03254:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>6500000</Start>
<End>9499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3b324c32-ca8f-432b-bc1f-36258140c556}</RefActConfigId>
<PartNumber>[RS1]X21-03252</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3b324c32-ca8f-432b-bc1f-36258140c556}</RefActConfigId>
<PartNumber>[RS1]X21-03253</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5000</Start>
<End>5999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3b324c32-ca8f-432b-bc1f-36258140c556}</RefActConfigId>
<PartNumber>[RS1]X21-03255</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>6000</Start>
<End>10999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{886ed35a-3eac-4503-9d31-bcac0ad881be}</RefActConfigId>
<PartNumber>[RS1]X21-03256:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>2999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{886ed35a-3eac-4503-9d31-bcac0ad881be}</RefActConfigId>
<PartNumber>[RS1]X21-03258:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>3000000</Start>
<End>5999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{886ed35a-3eac-4503-9d31-bcac0ad881be}</RefActConfigId>
<PartNumber>[RS1]X21-03259:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>6000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dc74cbcb-75e0-4bc9-a706-b4281839e1fe}</RefActConfigId>
<PartNumber>[RS1]X21-03257:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dc74cbcb-75e0-4bc9-a706-b4281839e1fe}</RefActConfigId>
<PartNumber>[RS1]X21-03260:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>500000</Start>
<End>3499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dc74cbcb-75e0-4bc9-a706-b4281839e1fe}</RefActConfigId>
<PartNumber>[RS1]X21-03261:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>3500000</Start>
<End>6499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dc74cbcb-75e0-4bc9-a706-b4281839e1fe}</RefActConfigId>
<PartNumber>[RS1]X21-03262:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>6500000</Start>
<End>9499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dc74cbcb-75e0-4bc9-a706-b4281839e1fe}</RefActConfigId>
<PartNumber>[RS1]X21-03263:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>9500000</Start>
<End>12499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{64e9f058-1cea-4c7b-8f81-6583d6af71dc}</RefActConfigId>
<PartNumber>[RS1]res-v3748</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>14000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{47ab5c9d-fd76-470d-8b59-c6cd09ae0324}</RefActConfigId>
<PartNumber>[RS1]res-v3749:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>6000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{32546532-818a-4b0e-91d2-41aa58b25e40}</RefActConfigId>
<PartNumber>[RS1]res-v3750:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>9500000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3b324c32-ca8f-432b-bc1f-36258140c556}</RefActConfigId>
<PartNumber>[RS1]res-v3751</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>11000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{886ed35a-3eac-4503-9d31-bcac0ad881be}</RefActConfigId>
<PartNumber>[RS1]res-v3752:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dc74cbcb-75e0-4bc9-a706-b4281839e1fe}</RefActConfigId>
<PartNumber>[RS1]res-v3753:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>12500000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bf85655c-0b5b-4c9e-b9cf-5a64e0c053b0}</RefActConfigId>
<PartNumber>[RS1]X21-03271:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bf85655c-0b5b-4c9e-b9cf-5a64e0c053b0}</RefActConfigId>
<PartNumber>[RS1]X21-03273:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>1004999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{36147ad0-32d4-49da-93cd-99cc9c03522b}</RefActConfigId>
<PartNumber>[RS1]X21-03267</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{36147ad0-32d4-49da-93cd-99cc9c03522b}</RefActConfigId>
<PartNumber>[RS1]X21-03268</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000</Start>
<End>1999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{13649426-c2a8-4211-9b5c-b5c012a37a80}</RefActConfigId>
<PartNumber>[RS1]X21-03269:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{13649426-c2a8-4211-9b5c-b5c012a37a80}</RefActConfigId>
<PartNumber>[RS1]X21-03270:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>1004999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7b4433f4-b1e7-4788-895a-c45378d38253}</RefActConfigId>
<PartNumber>[RS1]X21-03272</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>29</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bf85655c-0b5b-4c9e-b9cf-5a64e0c053b0}</RefActConfigId>
<PartNumber>[RS1]res-v3744:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1005000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{36147ad0-32d4-49da-93cd-99cc9c03522b}</RefActConfigId>
<PartNumber>[RS1]res-v3745</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>2000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{13649426-c2a8-4211-9b5c-b5c012a37a80}</RefActConfigId>
<PartNumber>[RS1]res-v3746:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1005000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7b4433f4-b1e7-4788-895a-c45378d38253}</RefActConfigId>
<PartNumber>[RS1]res-v3747</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>30</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99523</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99524</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>504999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99528</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>505000000</Start>
<End>509999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99526</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>510000000</Start>
<End>514999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99529</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>515000000</Start>
<End>524999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99527</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>525000000</Start>
<End>525999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99531</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>526000000</Start>
<End>526999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99533</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>527000000</Start>
<End>527999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99530</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>528000000</Start>
<End>607999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99532</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>608000000</Start>
<End>627999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99534</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>628000000</Start>
<End>707999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X19-99536</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>708000000</Start>
<End>727999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99537</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>79999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99535</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>80000000</Start>
<End>99999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99538</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100000000</Start>
<End>179999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99540</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>180000000</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99539</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>219999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99541</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>220000000</Start>
<End>239999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99545</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>240000000</Start>
<End>319999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99544</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>320000000</Start>
<End>339999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99543</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>340000000</Start>
<End>419999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99542</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>420000000</Start>
<End>439999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99546</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>440000000</Start>
<End>519999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99548</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>520000000</Start>
<End>539999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99549</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>540000000</Start>
<End>559999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99547</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>560000000</Start>
<End>579999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99550</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>580000000</Start>
<End>679999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X19-99551</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>680000000</Start>
<End>689999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X19-99553</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>21999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X19-99552</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>22000000</Start>
<End>73999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X19-99555</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>74000000</Start>
<End>75999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X19-99556</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>76000000</Start>
<End>76499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X19-99557</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>76500000</Start>
<End>108499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X19-99554</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>108500000</Start>
<End>109999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X19-98868</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X19-98869</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>10009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X19-98871</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>10010000</Start>
<End>17009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X19-98872</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>17010000</Start>
<End>24009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X19-98874</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>24010000</Start>
<End>25009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X19-98873</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>25010000</Start>
<End>45009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X19-98875</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>45010000</Start>
<End>65009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X19-98878</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>65010000</Start>
<End>85009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X19-98879</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>85010000</Start>
<End>105009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e371d89a-73e8-4b24-a7ff-23a3641dd18e}</RefActConfigId>
<PartNumber>[TH]X19-99651</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e371d89a-73e8-4b24-a7ff-23a3641dd18e}</RefActConfigId>
<PartNumber>[TH]X19-99648</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>199</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e371d89a-73e8-4b24-a7ff-23a3641dd18e}</RefActConfigId>
<PartNumber>[TH]X19-99650</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>200</Start>
<End>299</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e371d89a-73e8-4b24-a7ff-23a3641dd18e}</RefActConfigId>
<PartNumber>[TH]X19-99649</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>300</Start>
<End>399</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58e97c99-f377-4ef1-81d5-4ad5522b5fd8}</RefActConfigId>
<PartNumber>[TH]X19-98662</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99559</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>249999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99561</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>250000000</Start>
<End>252999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99558</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>253000000</Start>
<End>257999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99560</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>258000000</Start>
<End>262999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99565</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>263000000</Start>
<End>272999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99562</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>273000000</Start>
<End>273999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99564</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>274000000</Start>
<End>274999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99563</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>275000000</Start>
<End>275999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99566</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>276000000</Start>
<End>355999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99569</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>356000000</Start>
<End>435999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99567</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>436000000</Start>
<End>515999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99568</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>516000000</Start>
<End>535999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99572</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>536000000</Start>
<End>615999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99573</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>616000000</Start>
<End>635999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99570</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>636000000</Start>
<End>715999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99571</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>716000000</Start>
<End>795999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]X19-99575</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>796000000</Start>
<End>815999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X19-99576</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X19-99574</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>46999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X19-99577</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>47000000</Start>
<End>47009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d1bac85-7365-4fea-949a-96978ec91ae0}</RefActConfigId>
<PartNumber>[TH]X19-99652</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d1bac85-7365-4fea-949a-96978ec91ae0}</RefActConfigId>
<PartNumber>[TH]X19-99654</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>199</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d1bac85-7365-4fea-949a-96978ec91ae0}</RefActConfigId>
<PartNumber>[TH]X19-99655</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>200</Start>
<End>299</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d1bac85-7365-4fea-949a-96978ec91ae0}</RefActConfigId>
<PartNumber>[TH]X19-99653</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>300</Start>
<End>399</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d1bac85-7365-4fea-949a-96978ec91ae0}</RefActConfigId>
<PartNumber>[TH]X19-99656</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>400</Start>
<End>499</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d1bac85-7365-4fea-949a-96978ec91ae0}</RefActConfigId>
<PartNumber>[TH]X19-99657</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>500</Start>
<End>599</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d1bac85-7365-4fea-949a-96978ec91ae0}</RefActConfigId>
<PartNumber>[TH]X19-99658</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>600</Start>
<End>699</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a9107544-f4a0-4053-a96a-1479abdef912}</RefActConfigId>
<PartNumber>[TH]X19-98664</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99579</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99578</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>5499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99580</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5500000</Start>
<End>10499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99581</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10500000</Start>
<End>15499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99585</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>15500000</Start>
<End>16499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99582</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>16500000</Start>
<End>17499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99584</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>17500000</Start>
<End>18499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99583</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>18500000</Start>
<End>19499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99587</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>19500000</Start>
<End>21499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99588</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>21500000</Start>
<End>22499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99586</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>22500000</Start>
<End>24499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99589</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>24500000</Start>
<End>25499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99591</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>25500000</Start>
<End>27499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99590</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>27500000</Start>
<End>28499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99592</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>28500000</Start>
<End>30499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99593</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>30500000</Start>
<End>31499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99597</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>31500000</Start>
<End>32499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99594</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>32500000</Start>
<End>33499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99596</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>33500000</Start>
<End>35499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99595</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>35500000</Start>
<End>36499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99600</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>36500000</Start>
<End>38499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99598</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>38500000</Start>
<End>39499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99601</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>39500000</Start>
<End>41499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99599</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>41500000</Start>
<End>42499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99604</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>42500000</Start>
<End>43499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99603</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>43500000</Start>
<End>44499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X19-99605</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>44500000</Start>
<End>46499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X19-99602</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X19-99436</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>4500000</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X19-99431</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>5499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X19-99432</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5500000</Start>
<End>5999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X19-99430</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>6000000</Start>
<End>7999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X19-99437</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>8000000</Start>
<End>8499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X19-98877</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X19-98876</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>1009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X19-98880</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1010000</Start>
<End>4009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X19-98881</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>4010000</Start>
<End>7009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X19-98882</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>7010000</Start>
<End>8009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X19-98883</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>8010000</Start>
<End>12009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X19-98884</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>12010000</Start>
<End>16009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{06e74065-465d-4e14-ab23-c34a28aa54aa}</RefActConfigId>
<PartNumber>[TH]X19-99659</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{06e74065-465d-4e14-ab23-c34a28aa54aa}</RefActConfigId>
<PartNumber>[TH]X19-99660</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>199</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{06e74065-465d-4e14-ab23-c34a28aa54aa}</RefActConfigId>
<PartNumber>[TH]X19-99662</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>200</Start>
<End>299</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{06e74065-465d-4e14-ab23-c34a28aa54aa}</RefActConfigId>
<PartNumber>[TH]X19-99663</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>300</Start>
<End>399</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7b9e1751-a8da-4f75-9560-5fadfe3d8e38}</RefActConfigId>
<PartNumber>[TH]X19-98665</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X19-99435</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X19-99434</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>519999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X19-99438</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>520000000</Start>
<End>522999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X19-99440</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>523000000</Start>
<End>527999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X19-99441</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>528000000</Start>
<End>532999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X19-99439</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>533000000</Start>
<End>557999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X19-99445</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>558000000</Start>
<End>558999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X19-99444</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>559000000</Start>
<End>559999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X19-99442</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>560000000</Start>
<End>560999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99443</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>79999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99448</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>80000000</Start>
<End>99999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99449</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100000000</Start>
<End>179999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99446</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>180000000</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99447</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>279999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99450</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>280000000</Start>
<End>299999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99452</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>300000000</Start>
<End>319999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99451</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>320000000</Start>
<End>399999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99453</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>400000000</Start>
<End>419999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99456</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>420000000</Start>
<End>439999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99457</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>440000000</Start>
<End>519999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99454</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>520000000</Start>
<End>599999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99455</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>600000000</Start>
<End>619999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]X19-99458</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>620000000</Start>
<End>639999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X19-99460</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>41999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X19-99461</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>42000000</Start>
<End>83999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X19-99459</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>84000000</Start>
<End>116999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X19-99463</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>117000000</Start>
<End>117499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X19-99464</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>117500000</Start>
<End>117509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ae2cc14-ab2d-41f4-972f-5e20142771dc}</RefActConfigId>
<PartNumber>[TH]X19-99661</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ae2cc14-ab2d-41f4-972f-5e20142771dc}</RefActConfigId>
<PartNumber>[TH]X19-99664</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>199</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ae2cc14-ab2d-41f4-972f-5e20142771dc}</RefActConfigId>
<PartNumber>[TH]X19-99666</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>200</Start>
<End>299</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ae2cc14-ab2d-41f4-972f-5e20142771dc}</RefActConfigId>
<PartNumber>[TH]X19-99667</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>300</Start>
<End>399</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ae2cc14-ab2d-41f4-972f-5e20142771dc}</RefActConfigId>
<PartNumber>[TH]X19-99665</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>400</Start>
<End>499</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ae2cc14-ab2d-41f4-972f-5e20142771dc}</RefActConfigId>
<PartNumber>[TH]X19-99668</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>500</Start>
<End>599</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ae2cc14-ab2d-41f4-972f-5e20142771dc}</RefActConfigId>
<PartNumber>[TH]X19-99669</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>600</Start>
<End>699</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{cd918a57-a41b-4c82-8dce-1a538e221a83}</RefActConfigId>
<PartNumber>[TH]X19-98663</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X19-99465</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X19-99462</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X19-99469</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>59999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X19-99607</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>63000000</Start>
<End>67999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X19-99466</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60000000</Start>
<End>60999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X19-99467</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>61000000</Start>
<End>61999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X19-99468</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>62000000</Start>
<End>62999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2936d1d2-913a-4542-b54e-ce5a602a2a38}</RefActConfigId>
<PartNumber>[TH]X19-99470</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X19-98886</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X19-98887</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X19-98885</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>10999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X19-98889</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>11000000</Start>
<End>13999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X19-98891</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>14000000</Start>
<End>16999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X19-98890</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>17000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X19-98898</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>22000000</Start>
<End>24999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X19-98888</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>21999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e0c42288-980c-4788-a014-c080d2e1926e}</RefActConfigId>
<PartNumber>[TH]X19-98668</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98669</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>4000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98666</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>1999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98667</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>2000000</Start>
<End>3999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98671</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>14000000</Start>
<End>15999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98672</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>16000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98670</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>13999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98673</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98675</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98676</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>37999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X19-98892</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>2999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98677</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38000000</Start>
<End>42999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98679</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>46000000</Start>
<End>46799999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98681</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>48800000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98680</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>46800000</Start>
<End>48799999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98678</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>43000000</Start>
<End>45999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X19-99472</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X19-99471</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X19-99473</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>10999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X19-99474</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>11000000</Start>
<End>11999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X19-99477</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>12000000</Start>
<End>12999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X19-99475</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>13000000</Start>
<End>13999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c6c0a31e-7003-4dff-b4f9-ddc9f8d20af9}</RefActConfigId>
<PartNumber>[TH]X19-99476</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98843</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>10010000</Start>
<End>15009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X19-98894</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>3000000</Start>
<End>3999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X19-98837</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>4000000</Start>
<End>4599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X19-98836</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>4600000</Start>
<End>5199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X19-98839</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>5200000</Start>
<End>6199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X19-98838</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>6200000</Start>
<End>8199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3c102355-d027-42c6-ad23-2e7ef8a02585}</RefActConfigId>
<PartNumber>[TH]X19-98682</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98684</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>2000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98685</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98683</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>1999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98688</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>19000000</Start>
<End>20999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98689</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>21000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98686</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>13999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98687</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>14000000</Start>
<End>18999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98692</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>37999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98691</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98856</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1010000</Start>
<End>4009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98690</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98697</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>49200000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98694</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>43000000</Start>
<End>44199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98696</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47200000</Start>
<End>49199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98695</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>44200000</Start>
<End>47199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99671</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>243000000</Start>
<End>282999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99670</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>283000000</Start>
<End>322999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99675</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>323000000</Start>
<End>323999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99672</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>324000000</Start>
<End>324999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99674</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>39999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99673</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40000000</Start>
<End>79999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99677</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>80000000</Start>
<End>119999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99676</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>120000000</Start>
<End>159999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99679</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>160000000</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99678</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>239999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99682</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>240000000</Start>
<End>240999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99681</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>241000000</Start>
<End>241999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X19-99680</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>242000000</Start>
<End>242999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99683</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99686</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99687</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99685</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>39999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99684</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40000000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99689</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>59999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99691</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60000000</Start>
<End>69999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99690</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>70000000</Start>
<End>79999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99688</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>80000000</Start>
<End>80009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99695</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>80010000</Start>
<End>90009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99694</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>90010000</Start>
<End>100009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99693</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100010000</Start>
<End>110009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99692</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>110010000</Start>
<End>120009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99696</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>120010000</Start>
<End>130009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99699</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>130010000</Start>
<End>140009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99697</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>140010000</Start>
<End>150009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99698</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>150010000</Start>
<End>160009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99701</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>160010000</Start>
<End>170009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99703</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>170010000</Start>
<End>180009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99702</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>180010000</Start>
<End>190009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99700</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>190010000</Start>
<End>200009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99705</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200010000</Start>
<End>210009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99704</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>210010000</Start>
<End>220009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99706</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>220010000</Start>
<End>230009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99707</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>230010000</Start>
<End>240009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99709</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>240010000</Start>
<End>240019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X19-99710</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>240020000</Start>
<End>240029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{73111121-5638-40f6-bc11-f1d7b0d64300}</RefActConfigId>
<PartNumber>[TH]X19-98698</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98700</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>2000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98699</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>1999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98701</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98703</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>11000000</Start>
<End>12999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98702</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>10999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98705</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98704</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>13000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98709</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38000000</Start>
<End>42999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98708</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>37999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X19-98674</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98706</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98711</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>43800000</Start>
<End>44599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98713</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>45800000</Start>
<End>47299999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98710</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>43000000</Start>
<End>43799999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98712</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>44600000</Start>
<End>45799999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98716</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47410000</Start>
<End>49409999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98717</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>49410000</Start>
<End>52409999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98714</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47300000</Start>
<End>47399999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98715</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47400000</Start>
<End>47409999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98719</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>52410000</Start>
<End>54409999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98721</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>54420000</Start>
<End>54429999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98720</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>54410000</Start>
<End>54419999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3f4c0546-36c6-46a8-a37f-be13cdd0cf25}</RefActConfigId>
<PartNumber>[TH]X19-98718</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99708</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>243000000</Start>
<End>282999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99711</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>283000000</Start>
<End>322999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99712</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>323000000</Start>
<End>323999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99713</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>324000000</Start>
<End>324999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99609</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>39999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99611</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40000000</Start>
<End>79999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99610</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>80000000</Start>
<End>119999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99608</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>120000000</Start>
<End>159999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99612</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>160000000</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99615</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>239999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99613</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>240000000</Start>
<End>240999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99614</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>241000000</Start>
<End>241999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X19-99616</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>242000000</Start>
<End>242999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X19-98693</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38000000</Start>
<End>42999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e272e3e2-732f-4c65-a8f0-484747d0d947}</RefActConfigId>
<PartNumber>[TH]X19-98747</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98746</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98749</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98753</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>16000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98751</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>12000000</Start>
<End>13999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98752</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>14000000</Start>
<End>15999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98750</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>11999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98755</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98757</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>37999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98756</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X19-98707</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98760</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>39600000</Start>
<End>44599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98759</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38800000</Start>
<End>39599999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98761</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>44600000</Start>
<End>45349999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98758</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38000000</Start>
<End>38799999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98762</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>45350000</Start>
<End>46549999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98763</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>46550000</Start>
<End>48549999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98764</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>48550000</Start>
<End>51549999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98765</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>51550000</Start>
<End>51649999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98766</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>51650000</Start>
<End>51659999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98767</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>51660000</Start>
<End>53659999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98768</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>53660000</Start>
<End>53669999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98769</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>53670000</Start>
<End>53679999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1f8dbfe8-defa-4676-b5a6-f76949a01540}</RefActConfigId>
<PartNumber>[TH]X19-98772</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2a6137f3-75c0-4f26-8e3e-d83d802865a4}</RefActConfigId>
<PartNumber>[TH]X19-99606</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X19-99481</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X19-99478</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>549999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X19-99479</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>550000000</Start>
<End>574999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X19-99480</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>575000000</Start>
<End>578999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X19-99483</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>579000000</Start>
<End>583999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99484</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>55000000</Start>
<End>55999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99489</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>56000000</Start>
<End>56999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99488</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>57000000</Start>
<End>57999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99486</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>58000000</Start>
<End>137999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99487</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>138000000</Start>
<End>145999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99492</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>146000000</Start>
<End>165999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99491</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>166000000</Start>
<End>245999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99493</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>246000000</Start>
<End>253999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99490</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>254000000</Start>
<End>273999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99496</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>274000000</Start>
<End>281999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99497</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>282000000</Start>
<End>311999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99494</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>312000000</Start>
<End>341999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X19-99647</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X19-99495</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X19-99501</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>18999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X19-99500</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>123000000</Start>
<End>127999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X19-99505</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>128000000</Start>
<End>128999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X19-99504</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>129000000</Start>
<End>178999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X19-99502</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>179000000</Start>
<End>181499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98841</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98840</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>10009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X19-98754</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98842</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>15010000</Start>
<End>17009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98847</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>17010000</Start>
<End>17809999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98845</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>17810000</Start>
<End>21809999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98846</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>21810000</Start>
<End>24809999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98844</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>24810000</Start>
<End>25809999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98849</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>25810000</Start>
<End>25859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98850</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>25860000</Start>
<End>35859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98851</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>35860000</Start>
<End>45859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98848</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>45860000</Start>
<End>48859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98855</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>48860000</Start>
<End>51859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98893</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>91860000</Start>
<End>94859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98852</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>51860000</Start>
<End>71859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98854</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>71860000</Start>
<End>81859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98853</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>81860000</Start>
<End>91859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{377333b1-8b5d-48d6-9679-1225c872d37c}</RefActConfigId>
<PartNumber>[TH]X19-98858</PartNumber>
<EulaType>Retail:WAU:101;99;100;</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>1000099</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{377333b1-8b5d-48d6-9679-1225c872d37c}</RefActConfigId>
<PartNumber>[TH]X19-98895</PartNumber>
<EulaType>Retail:WAU:101;99;100;</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0773a15-df3a-4312-9ad2-83d69648e356}</RefActConfigId>
<PartNumber>[TH]X19-99646</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>400</Start>
<End>499</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0773a15-df3a-4312-9ad2-83d69648e356}</RefActConfigId>
<PartNumber>[TH]X19-99645</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>500</Start>
<End>599</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0773a15-df3a-4312-9ad2-83d69648e356}</RefActConfigId>
<PartNumber>[TH]X19-99644</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>600</Start>
<End>699</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0773a15-df3a-4312-9ad2-83d69648e356}</RefActConfigId>
<PartNumber>[TH]X19-99714</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0773a15-df3a-4312-9ad2-83d69648e356}</RefActConfigId>
<PartNumber>[TH]X19-99715</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>199</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0773a15-df3a-4312-9ad2-83d69648e356}</RefActConfigId>
<PartNumber>[TH]X19-99719</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>200</Start>
<End>299</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0773a15-df3a-4312-9ad2-83d69648e356}</RefActConfigId>
<PartNumber>[TH]X19-99716</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>300</Start>
<End>399</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2de67392-b7a7-462a-b1ca-108dd189f588}</RefActConfigId>
<PartNumber>[TH]X19-98795</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98796</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>2000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98797</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98794</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>1999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98799</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>14000000</Start>
<End>15999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98801</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>21000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98798</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>13999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98800</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>16000000</Start>
<End>20999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98803</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>25000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98805</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>35000000</Start>
<End>39999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98802</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>24999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98809</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>46200000</Start>
<End>46999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98807</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>43000000</Start>
<End>44199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98808</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>44200000</Start>
<End>46199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98806</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>40000000</Start>
<End>42999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98812</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47020000</Start>
<End>47119999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98810</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47000000</Start>
<End>47009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98813</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47120000</Start>
<End>49119999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98811</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47010000</Start>
<End>47019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98814</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>49120000</Start>
<End>49129999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ef51e000-2659-4f25-8345-3de70a9cf4c4}</RefActConfigId>
<PartNumber>[TH]X19-99718</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ef51e000-2659-4f25-8345-3de70a9cf4c4}</RefActConfigId>
<PartNumber>[TH]X19-99717</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>199</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ef51e000-2659-4f25-8345-3de70a9cf4c4}</RefActConfigId>
<PartNumber>[TH]X19-99721</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>200</Start>
<End>299</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99503</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99507</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>5499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99509</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5500000</Start>
<End>5749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99506</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5750000</Start>
<End>10749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99511</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>11750000</Start>
<End>12749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99510</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>12750000</Start>
<End>13749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99512</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>13750000</Start>
<End>14749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99513</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>14750000</Start>
<End>19749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99515</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>19750000</Start>
<End>21749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99514</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>21750000</Start>
<End>26749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99517</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>26750000</Start>
<End>28749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99516</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>28750000</Start>
<End>30749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]X19-99521</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]X19-99518</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>5499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]X19-99519</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5500000</Start>
<End>6499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]X19-99525</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>6500000</Start>
<End>8499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]X19-99522</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>8500000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98859</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98857</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>1009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X19-98804</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>34999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98863</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>4010000</Start>
<End>5009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98860</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>5010000</Start>
<End>5809999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98862</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>5810000</Start>
<End>6409999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98861</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>6410000</Start>
<End>7009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98864</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>7010000</Start>
<End>8009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98867</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>8010000</Start>
<End>9009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98866</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>9010000</Start>
<End>13009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98865</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>13010000</Start>
<End>17009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98870</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>17010000</Start>
<End>21009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9c4a7917-c857-4bd5-b109-d21866014b5c}</RefActConfigId>
<PartNumber>[TH]X19-98897</PartNumber>
<EulaType>Retail:WAU:98;</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9c4a7917-c857-4bd5-b109-d21866014b5c}</RefActConfigId>
<PartNumber>[TH]X19-98896</PartNumber>
<EulaType>Retail:WAU:98;</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>1000099</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a9e86e9-057b-40ca-b11b-307d8f167ae8}</RefActConfigId>
<PartNumber>[TH]X19-99720</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a9e86e9-057b-40ca-b11b-307d8f167ae8}</RefActConfigId>
<PartNumber>[TH]X19-99722</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>199</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a9e86e9-057b-40ca-b11b-307d8f167ae8}</RefActConfigId>
<PartNumber>[TH]X19-99723</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>200</Start>
<End>299</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a9e86e9-057b-40ca-b11b-307d8f167ae8}</RefActConfigId>
<PartNumber>[TH]X19-99725</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>300</Start>
<End>399</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a80b5abf-76ad-428b-b05d-a47d2dffeebf}</RefActConfigId>
<PartNumber>[TH]X19-98817</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98816</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>2000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98815</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>1999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98818</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98820</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>14000000</Start>
<End>15999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98821</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>16000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98819</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>13999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98822</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98824</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98823</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98825</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>35999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98826</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>36000000</Start>
<End>36999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98828</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>39000000</Start>
<End>39799999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98829</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>39800000</Start>
<End>40999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98827</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>37000000</Start>
<End>38999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98832</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>41110000</Start>
<End>44109999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98830</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>41000000</Start>
<End>41099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98831</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>41100000</Start>
<End>41109999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98833</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>44110000</Start>
<End>46109999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98835</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>46120000</Start>
<End>46129999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X19-98834</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>46110000</Start>
<End>46119999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5694ba59-213b-468a-b2c9-82a4dd09877d}</RefActConfigId>
<PartNumber>[TH]X19-99726</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5694ba59-213b-468a-b2c9-82a4dd09877d}</RefActConfigId>
<PartNumber>[TH]X19-99724</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>199</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5694ba59-213b-468a-b2c9-82a4dd09877d}</RefActConfigId>
<PartNumber>[TH]X19-99727</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>200</Start>
<End>299</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-00898</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>129999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-00901</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>130000000</Start>
<End>149999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-00900</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>46500000</Start>
<End>48499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-00899</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>48500000</Start>
<End>49499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-00902</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>99999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-00905</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100000000</Start>
<End>119999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a292df8-d653-4057-8133-a0701792f912}</RefActConfigId>
<PartNumber>[TH]X20-00903</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>89999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a292df8-d653-4057-8133-a0701792f912}</RefActConfigId>
<PartNumber>[TH]X20-00904</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>90000000</Start>
<End>109999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-00906</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-00908</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>49500000</Start>
<End>50499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-00907</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a292df8-d653-4057-8133-a0701792f912}</RefActConfigId>
<PartNumber>[TH]X20-00909</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>110000000</Start>
<End>129999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-00912</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-00911</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50500000</Start>
<End>51499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-00914</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>150000000</Start>
<End>169999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-00913</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-00910</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>51500000</Start>
<End>52499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-00916</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>120000000</Start>
<End>129999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a292df8-d653-4057-8133-a0701792f912}</RefActConfigId>
<PartNumber>[TH]X20-00915</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-15865</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>170000000</Start>
<End>249999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-15864</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>250000000</Start>
<End>269999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-15863</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>130000000</Start>
<End>209999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-15862</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>210000000</Start>
<End>229999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-15867</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>54500000</Start>
<End>55499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-15866</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>55500000</Start>
<End>56499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a292df8-d653-4057-8133-a0701792f912}</RefActConfigId>
<PartNumber>[TH]X20-15869</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>130000000</Start>
<End>209999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a292df8-d653-4057-8133-a0701792f912}</RefActConfigId>
<PartNumber>[TH]X20-15868</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>210000000</Start>
<End>229999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-15871</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>230000000</Start>
<End>254999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-15870</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>255000000</Start>
<End>279999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-15873</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>280000000</Start>
<End>304999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-15872</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>270000000</Start>
<End>289999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-15875</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>290000000</Start>
<End>309999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-15874</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>52500000</Start>
<End>53499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-15876</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>53500000</Start>
<End>54499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{411b3d4f-be6d-4a06-baaa-9cabfc256cae}</RefActConfigId>
<PartNumber>[TH]X20-17624</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{74436dbb-cc17-46de-867f-14906ba4a938}</RefActConfigId>
<PartNumber>[TH]X20-17627</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c86d5194-4840-4dae-9c1c-0301003a5ab0}</RefActConfigId>
<PartNumber>[TH]X20-17625</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6eadb3b-5ca8-4a6b-986e-35b550756111}</RefActConfigId>
<PartNumber>[TH]X20-17626</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X20-17628</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>181500000</Start>
<End>199499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X19-99493</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>342000000</Start>
<End>353999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X19-99647</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-20961</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>310000000</Start>
<End>329999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-20962</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>330000000</Start>
<End>349999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-20964</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>350000000</Start>
<End>369999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-20963</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>56500000</Start>
<End>58499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-20965</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>58500000</Start>
<End>60499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-20966</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60500000</Start>
<End>62499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X20-21794</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>25000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X20-21793</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>8200000</Start>
<End>10199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fe74f55b-0338-41d6-b267-4a201abe7285}</RefActConfigId>
<PartNumber>[TH]X20-21795</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{040fa323-92b1-4baf-97a2-5b67feaefddb}</RefActConfigId>
<PartNumber>[TH]X20-21798</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4053f6e4-20bb-49f2-b808-8385c48b5cd5}</RefActConfigId>
<PartNumber>[TH]X20-21796</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ccd24e5-8cc4-49ae-8996-dcfdcb4e1dc2}</RefActConfigId>
<PartNumber>[TH]X20-21797</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X20-23533</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>47010000</Start>
<End>52009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-23530</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>305000000</Start>
<End>329999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-23529</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>330000000</Start>
<End>354999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-23528</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>355000000</Start>
<End>379999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-23527</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>380000000</Start>
<End>404999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-23532</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>405000000</Start>
<End>429999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-23647</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>30750000</Start>
<End>35749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X20-23646</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>534000000</Start>
<End>583999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X20-23648</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>584000000</Start>
<End>598999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X20-23649</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>599000000</Start>
<End>613999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X20-23596</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>354000000</Start>
<End>403999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X20-23595</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>404000000</Start>
<End>418999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X20-23598</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>419000000</Start>
<End>433999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X20-23597</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>434000000</Start>
<End>483999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X20-23600</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>484000000</Start>
<End>533999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X20-23601</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>519999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-23599</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>370000000</Start>
<End>419999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-23650</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>420000000</Start>
<End>469999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-24576</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>480000000</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-24577</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>519999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-24578</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>520000000</Start>
<End>539999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-24575</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>540000000</Start>
<End>559999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-24580</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>62500000</Start>
<End>64499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-24579</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>64500000</Start>
<End>66499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-24582</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>66500000</Start>
<End>67499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-24581</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>67500000</Start>
<End>68499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-24585</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>470000000</Start>
<End>474999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-24586</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>475000000</Start>
<End>479999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-24584</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>68500000</Start>
<End>73499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-24583</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>73500000</Start>
<End>78499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X20-24587</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>584000000</Start>
<End>588999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-24588</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>35750000</Start>
<End>40749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e371d89a-73e8-4b24-a7ff-23a3641dd18e}</RefActConfigId>
<PartNumber>[TH]X20-25154</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>400</Start>
<End>499</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{06e74065-465d-4e14-ab23-c34a28aa54aa}</RefActConfigId>
<PartNumber>[TH]X20-25151</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>400</Start>
<End>499</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d1bac85-7365-4fea-949a-96978ec91ae0}</RefActConfigId>
<PartNumber>[TH]X20-25153</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>700</Start>
<End>799</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ae2cc14-ab2d-41f4-972f-5e20142771dc}</RefActConfigId>
<PartNumber>[TH]X20-25152</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>700</Start>
<End>799</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0773a15-df3a-4312-9ad2-83d69648e356}</RefActConfigId>
<PartNumber>[TH]X20-25155</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>700</Start>
<End>799</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a9e86e9-057b-40ca-b11b-307d8f167ae8}</RefActConfigId>
<PartNumber>[TH]X20-25156</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>400</Start>
<End>499</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X20-29630</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>105010000</Start>
<End>115009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X20-29629</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>115010000</Start>
<End>125009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X20-29633</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>125010000</Start>
<End>135009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X20-29631</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>135010000</Start>
<End>145009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X20-29632</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>145010000</Start>
<End>155009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X20-29634</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>16010000</Start>
<End>26009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X20-29637</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>26010000</Start>
<End>36009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X20-29635</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>36010000</Start>
<End>46009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X20-29638</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>46010000</Start>
<End>56009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X20-29636</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>56010000</Start>
<End>66009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X20-29640</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>60000000</Start>
<End>69999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X20-29639</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>70000000</Start>
<End>79999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X20-29551</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>39999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X20-29552</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>40000000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]X20-29553</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>59999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X20-29554</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>10200000</Start>
<End>20199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X20-29557</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>20200000</Start>
<End>30199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X20-29558</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>30200000</Start>
<End>40199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X20-29555</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>40200000</Start>
<End>50199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X20-29556</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>50200000</Start>
<End>60199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X20-29562</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>94860000</Start>
<End>104859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X20-29560</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>104860000</Start>
<End>114859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X20-29561</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>114860000</Start>
<End>124859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X20-29559</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>124860000</Start>
<End>134859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X20-29566</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>134860000</Start>
<End>144859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X20-29564</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>21010000</Start>
<End>31009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X20-29563</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>31010000</Start>
<End>41009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X20-29565</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>41010000</Start>
<End>51009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X20-29568</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>51010000</Start>
<End>61009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X20-29569</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>61010000</Start>
<End>71009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29567</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>78500000</Start>
<End>83499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29570</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>83500000</Start>
<End>88499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29573</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>88500000</Start>
<End>93499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29571</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>93500000</Start>
<End>98499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29574</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>98500000</Start>
<End>103499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29572</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>103500000</Start>
<End>108499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29575</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>108500000</Start>
<End>113499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29578</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>113500000</Start>
<End>118499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29576</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>118500000</Start>
<End>123499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29577</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>123500000</Start>
<End>128499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29582</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>128500000</Start>
<End>133499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29581</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>133500000</Start>
<End>138499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29580</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>138500000</Start>
<End>143499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29579</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>143500000</Start>
<End>148499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29584</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>148500000</Start>
<End>153499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29585</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>153500000</Start>
<End>158499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29583</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>158500000</Start>
<End>163499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29586</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>163500000</Start>
<End>168499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29588</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>168500000</Start>
<End>173499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-29590</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>173500000</Start>
<End>178499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29587</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40750000</Start>
<End>45749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29589</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>45750000</Start>
<End>50749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29591</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50750000</Start>
<End>55749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29593</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>55750000</Start>
<End>60749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29594</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>65750000</Start>
<End>70749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29597</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>70750000</Start>
<End>75749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29598</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>75750000</Start>
<End>80749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29596</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>80750000</Start>
<End>85749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29595</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>85750000</Start>
<End>90749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29600</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>90750000</Start>
<End>95749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29599</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>95750000</Start>
<End>100749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29602</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100750000</Start>
<End>105749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29601</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>105750000</Start>
<End>110749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29603</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>110750000</Start>
<End>115749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29604</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>115750000</Start>
<End>120749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29605</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>120750000</Start>
<End>125749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29606</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>125750000</Start>
<End>130749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29607</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>130750000</Start>
<End>135749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X20-29608</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>135750000</Start>
<End>140749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X20-29610</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>68000000</Start>
<End>117999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X20-29609</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>118000000</Start>
<End>167999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X20-29614</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>168000000</Start>
<End>217999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X20-29613</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>218000000</Start>
<End>267999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]X20-29612</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>268000000</Start>
<End>317999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X20-29611</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>14000000</Start>
<End>18999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X20-29616</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>19000000</Start>
<End>23999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X20-29617</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>24000000</Start>
<End>28999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X20-29618</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>29000000</Start>
<End>33999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]X20-29615</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>34000000</Start>
<End>38999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X20-29620</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>325000000</Start>
<End>374999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X20-29622</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>375000000</Start>
<End>424999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X20-29619</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>425000000</Start>
<End>474999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X20-29621</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>475000000</Start>
<End>524999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]X20-29626</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>525000000</Start>
<End>574999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X20-29623</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>325000000</Start>
<End>374999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X20-29624</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>375000000</Start>
<End>424999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X20-29625</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>425000000</Start>
<End>474999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X20-29628</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>475000000</Start>
<End>524999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]X20-29627</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>525000000</Start>
<End>574999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29669</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29675</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>99999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29673</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100000000</Start>
<End>149999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29676</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>150000000</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29674</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>249999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29680</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>250000000</Start>
<End>299999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29677</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>300000000</Start>
<End>349999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29679</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>350000000</Start>
<End>399999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29678</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>400000000</Start>
<End>449999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29683</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>450000000</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29684</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>524999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29682</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>525000000</Start>
<End>549999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29681</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>550000000</Start>
<End>574999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29686</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>575000000</Start>
<End>599999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29685</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>600000000</Start>
<End>624999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29687</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>625000000</Start>
<End>649999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29688</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>650000000</Start>
<End>674999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29692</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>675000000</Start>
<End>699999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29691</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>700000000</Start>
<End>724999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1b750385-9fe2-49a8-ab55-149d0546395b}</RefActConfigId>
<PartNumber>[TH]X20-29718</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>725000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29689</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29690</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>99999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29693</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100000000</Start>
<End>149999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29695</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>150000000</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29696</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>249999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29694</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>250000000</Start>
<End>299999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29697</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>300000000</Start>
<End>349999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29700</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>350000000</Start>
<End>399999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29699</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>400000000</Start>
<End>449999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29698</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>450000000</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29702</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>524999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29704</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>525000000</Start>
<End>549999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29701</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>550000000</Start>
<End>574999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29703</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>575000000</Start>
<End>599999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29707</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>600000000</Start>
<End>624999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29705</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>625000000</Start>
<End>649999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29708</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>650000000</Start>
<End>674999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29706</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>675000000</Start>
<End>699999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29710</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>700000000</Start>
<End>724999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d7fb0c28-1eea-4f68-98a1-f988aa838ab5}</RefActConfigId>
<PartNumber>[TH]X20-29721</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>725000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29711</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29709</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>99999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29712</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100000000</Start>
<End>149999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29715</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>150000000</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29716</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>249999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29714</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>250000000</Start>
<End>299999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29713</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>300000000</Start>
<End>349999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29642</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>350000000</Start>
<End>399999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29644</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>400000000</Start>
<End>449999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29643</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>450000000</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29641</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>524999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29647</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>525000000</Start>
<End>549999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29646</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>550000000</Start>
<End>574999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29648</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>575000000</Start>
<End>599999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29645</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>600000000</Start>
<End>624999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29649</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>625000000</Start>
<End>649999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29652</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>650000000</Start>
<End>674999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29651</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>675000000</Start>
<End>699999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29650</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>700000000</Start>
<End>724999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{da9621af-f086-4244-b563-18611e51aa1a}</RefActConfigId>
<PartNumber>[TH]X20-29720</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>725000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29654</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29655</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>99999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29653</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100000000</Start>
<End>149999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29656</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>150000000</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29658</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>249999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29660</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>250000000</Start>
<End>299999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29657</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>300000000</Start>
<End>349999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29659</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>350000000</Start>
<End>399999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29661</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>400000000</Start>
<End>449999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29663</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>450000000</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29662</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>524999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29664</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>525000000</Start>
<End>549999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29668</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>550000000</Start>
<End>574999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29666</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>575000000</Start>
<End>599999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29665</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>600000000</Start>
<End>624999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29667</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>625000000</Start>
<End>649999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29670</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>650000000</Start>
<End>674999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29671</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>675000000</Start>
<End>699999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29672</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>700000000</Start>
<End>724999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3df374ef-d444-4494-a5a1-4b0d9fd0e203}</RefActConfigId>
<PartNumber>[TH]X20-29719</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>725000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X20-30042</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>690000000</Start>
<End>709999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]X20-30041</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>710000000</Start>
<End>789999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-30046</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>178500000</Start>
<End>180499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-30043</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>180500000</Start>
<End>182499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X20-30044</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>561000000</Start>
<End>580999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X20-30045</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>581000000</Start>
<End>600999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]X20-30048</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>601000000</Start>
<End>620999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X20-32143</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>589000000</Start>
<End>663999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X20-32144</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>714000000</Start>
<End>738999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X20-32146</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>739000000</Start>
<End>763999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X20-32148</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>590000000</Start>
<End>664999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X20-32150</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>665000000</Start>
<End>714999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X20-32149</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>715000000</Start>
<End>764999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X20-32147</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>765000000</Start>
<End>784999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X20-32151</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>785000000</Start>
<End>804999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X20-32153</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>764000000</Start>
<End>788999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X20-32152</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>789000000</Start>
<End>808999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]X20-32154</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>809000000</Start>
<End>828999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X20-32158</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>550000000</Start>
<End>574999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X20-32157</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>575000000</Start>
<End>589999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]X20-32155</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>689000000</Start>
<End>788999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X20-32156</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>520000000</Start>
<End>534999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]X20-32159</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>535000000</Start>
<End>549999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]X20-30283</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>728000000</Start>
<End>737999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X20-30284</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>110000000</Start>
<End>159999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-36694</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>560000000</Start>
<End>569999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]X20-36698</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>570000000</Start>
<End>589999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]X20-36697</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>182500000</Start>
<End>184499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X20-36703</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>160000000</Start>
<End>184999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X20-36691</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>185000000</Start>
<End>209999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X20-36695</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>52010000</Start>
<End>57009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X20-36689</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>8500000</Start>
<End>10499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X20-36692</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>117510000</Start>
<End>159509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]X20-37357</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>430000000</Start>
<End>459999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X20-37914</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>57010000</Start>
<End>58509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X20-39246</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>210000000</Start>
<End>259999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X20-39247</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>260000000</Start>
<End>284999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X20-39244</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>285000000</Start>
<End>309999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X20-39245</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>310000000</Start>
<End>329999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]X20-39250</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>330000000</Start>
<End>349999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X20-39248</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>58510000</Start>
<End>83509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X20-39251</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>83510000</Start>
<End>108509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X20-39249</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>108510000</Start>
<End>128509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X20-39254</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>128510000</Start>
<End>148509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]X20-39252</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>148510000</Start>
<End>168509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X20-39253</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10500000</Start>
<End>20499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X20-39255</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20500000</Start>
<End>30499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X20-39258</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>30500000</Start>
<End>40499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X20-39257</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40500000</Start>
<End>50499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]X20-39256</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50500000</Start>
<End>60499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X20-39259</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>159510000</Start>
<End>209509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X20-39260</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>209510000</Start>
<End>259509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X20-39261</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>259510000</Start>
<End>279509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X20-39262</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>279510000</Start>
<End>299509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]X20-39263</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>299510000</Start>
<End>319509999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X20-39264</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>274500000</Start>
<End>324499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X20-39267</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>324500000</Start>
<End>374499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X20-39266</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>374500000</Start>
<End>424499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X20-39265</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>424500000</Start>
<End>449499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]X20-39271</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>449500000</Start>
<End>474499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]X20-39268</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>11000000</Start>
<End>20999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]X20-39270</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>21000000</Start>
<End>30999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]X20-39269</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>31000000</Start>
<End>40999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]X20-39272</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>41000000</Start>
<End>50999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]X20-39273</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>51000000</Start>
<End>60999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8859e3f7-43b0-4a38-87cb-ca00202651c6}</RefActConfigId>
<PartNumber>[TH]X20-43106</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ee7b1257-5c57-42b4-9fe8-4915deb2f679}</RefActConfigId>
<PartNumber>[TH]X20-43107</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X20-44908</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>155010000</Start>
<End>156009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]X20-44905</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>66010000</Start>
<End>67009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X20-44906</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>144860000</Start>
<End>145859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X20-44907</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>71010000</Start>
<End>72009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]X19-98874</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>156010000</Start>
<End>157009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]X19-98844</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>145860000</Start>
<End>146859999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]X20-46572</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>51999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]X20-46570</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>51999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]X20-46571</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>54430000</Start>
<End>56429999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]X20-46577</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>53680000</Start>
<End>55679999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]X20-46576</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>49130000</Start>
<End>51129999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]X20-46575</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>46130000</Start>
<End>48129999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]X19-98837</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>60200000</Start>
<End>61199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]X19-98862</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>72010000</Start>
<End>73009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]X19-99507</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>155750000</Start>
<End>156749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3c0e0ac0-ae70-462e-9c38-5d48e1cd220f}</RefActConfigId>
<PartNumber>[TH]X20-57725</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{86a309b8-45f0-4c6c-a637-da4f8fa9a5d7}</RefActConfigId>
<PartNumber>[TH]X20-57726</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2936d1d2-913a-4542-b54e-ce5a602a2a38}</RefActConfigId>
<PartNumber>[TH]X21-04945</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000</Start>
<End>10009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c6c0a31e-7003-4dff-b4f9-ddc9f8d20af9}</RefActConfigId>
<PartNumber>[TH]X21-04949</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000</Start>
<End>1009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04953</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04957</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04960</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04958</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>10999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04959</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>11000000</Start>
<End>12999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04961</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>13000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04962</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04963</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04964</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04965</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>37999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04966</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38000000</Start>
<End>38799999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04911</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38800000</Start>
<End>40299999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04909</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>40300000</Start>
<End>41099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04910</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>41100000</Start>
<End>46099999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04912</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>46100000</Start>
<End>46199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04915</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>46200000</Start>
<End>46209999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04914</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>46210000</Start>
<End>48209999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04916</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>48210000</Start>
<End>48219999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04913</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>48220000</Start>
<End>48229999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04917</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>48230000</Start>
<End>53229999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04920</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>53230000</Start>
<End>55229999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04919</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>55230000</Start>
<End>60229999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]X21-04918</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>60230000</Start>
<End>65229999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04921</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04924</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04922</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04923</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>10999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04928</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>11000000</Start>
<End>12999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04925</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>13000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04926</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04927</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04929</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04932</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>37999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04930</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38000000</Start>
<End>38799999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04931</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>38800000</Start>
<End>39549999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04933</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>39550000</Start>
<End>40349999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04936</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>40350000</Start>
<End>45349999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04934</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>45350000</Start>
<End>45449999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04935</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>45450000</Start>
<End>45459999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04940</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>45460000</Start>
<End>47459999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04937</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47460000</Start>
<End>47469999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04938</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47470000</Start>
<End>47479999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04939</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>47480000</Start>
<End>52479999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04944</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>52480000</Start>
<End>54479999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04941</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>54480000</Start>
<End>59479999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]X21-04943</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>59480000</Start>
<End>64479999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b47dd250-fd6a-44c8-9217-03aca6e4812e}</RefActConfigId>
<PartNumber>[RS1]X21-04942</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6162e8c2-3c30-46e1-b964-0de603498e2d}</RefActConfigId>
<PartNumber>[RS1]X21-04948</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05055</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05058</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05056</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05033</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>140000000</Start>
<End>179999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05059</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>89999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05030</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>180000000</Start>
<End>229999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05060</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>90000000</Start>
<End>139999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05031</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>230000000</Start>
<End>279999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05032</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>280000000</Start>
<End>280999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05034</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>281000000</Start>
<End>281999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]X21-05036</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>282000000</Start>
<End>282999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05035</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05037</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05038</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05042</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>39999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05039</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40000000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05041</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>59999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05040</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60000000</Start>
<End>60009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05044</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60010000</Start>
<End>70009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05043</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>70010000</Start>
<End>80009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05045</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>80010000</Start>
<End>90009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05046</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>90010000</Start>
<End>100009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05047</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100010000</Start>
<End>110009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05050</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>110010000</Start>
<End>120009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05048</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>120010000</Start>
<End>130009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05049</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>130010000</Start>
<End>140009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05051</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>140010000</Start>
<End>150009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05053</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>150010000</Start>
<End>160009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05054</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>160010000</Start>
<End>170009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05052</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>170010000</Start>
<End>180009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05057</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>180010000</Start>
<End>180019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05137</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>230020000</Start>
<End>240019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05140</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>240020000</Start>
<End>250019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05138</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>250020000</Start>
<End>260019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05139</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>260020000</Start>
<End>270019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05144</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>270020000</Start>
<End>280019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05141</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>280020000</Start>
<End>290019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05142</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>290020000</Start>
<End>300019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05143</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>300020000</Start>
<End>310019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05145</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>310020000</Start>
<End>320019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05122</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>180020000</Start>
<End>190019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05119</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>190020000</Start>
<End>200019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05121</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200020000</Start>
<End>210019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05126</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>210020000</Start>
<End>220019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]X21-05125</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>220020000</Start>
<End>230019999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05123</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>240030000</Start>
<End>250029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05124</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>250030000</Start>
<End>260029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05128</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>260030000</Start>
<End>270029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05127</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>270030000</Start>
<End>280029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05129</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>280030000</Start>
<End>290029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05130</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>290030000</Start>
<End>300029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05134</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>300030000</Start>
<End>310029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05132</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>310030000</Start>
<End>320029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05133</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>320030000</Start>
<End>330029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05131</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>330030000</Start>
<End>340029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05135</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>340030000</Start>
<End>350029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]X21-05136</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>350030000</Start>
<End>360029999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2d5a5a60-3040-48bf-beb0-fcd770c20ce0}</RefActConfigId>
<PartNumber>[RS1]X21-05334</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9f776d83-7156-45b2-8a5c-359b9c9f22a3}</RefActConfigId>
<PartNumber>[RS1]X21-05335</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{62f0c100-9c53-4e02-b886-a3528ddfe7f6}</RefActConfigId>
<PartNumber>[RS1]X21-04955</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{13a38698-4a49-4b9e-8e83-98fe51110953}</RefActConfigId>
<PartNumber>[RS1]X21-04956</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e7a950a2-e548-4f10-bf16-02ec848e0643}</RefActConfigId>
<PartNumber>[RS1]X21-06152</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e7a950a2-e548-4f10-bf16-02ec848e0643}</RefActConfigId>
<PartNumber>[RS1]X21-06155</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>504999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e7a950a2-e548-4f10-bf16-02ec848e0643}</RefActConfigId>
<PartNumber>[RS1]X21-06154</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>505000000</Start>
<End>509999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e7a950a2-e548-4f10-bf16-02ec848e0643}</RefActConfigId>
<PartNumber>[RS1]X21-06153</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>510000000</Start>
<End>559999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e7a950a2-e548-4f10-bf16-02ec848e0643}</RefActConfigId>
<PartNumber>[RS1]X21-06157</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>560000000</Start>
<End>609999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e7a950a2-e548-4f10-bf16-02ec848e0643}</RefActConfigId>
<PartNumber>[RS1]X21-06156</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>610000000</Start>
<End>659999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e7a950a2-e548-4f10-bf16-02ec848e0643}</RefActConfigId>
<PartNumber>[RS1]X21-06158</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>660000000</Start>
<End>709999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e7a950a2-e548-4f10-bf16-02ec848e0643}</RefActConfigId>
<PartNumber>[RS1]X21-06159</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>710000000</Start>
<End>759999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4f3da0d2-271d-4508-ae81-626b60809a38}</RefActConfigId>
<PartNumber>[RS1]X21-06162</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4f3da0d2-271d-4508-ae81-626b60809a38}</RefActConfigId>
<PartNumber>[RS1]X21-06163</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>99999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4f3da0d2-271d-4508-ae81-626b60809a38}</RefActConfigId>
<PartNumber>[RS1]X21-06161</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>100000000</Start>
<End>149999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4f3da0d2-271d-4508-ae81-626b60809a38}</RefActConfigId>
<PartNumber>[RS1]X21-06160</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>150000000</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4f3da0d2-271d-4508-ae81-626b60809a38}</RefActConfigId>
<PartNumber>[RS1]X21-06164</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>249999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4f3da0d2-271d-4508-ae81-626b60809a38}</RefActConfigId>
<PartNumber>[RS1]X21-06167</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>250000000</Start>
<End>299999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d559863d-8e3d-4854-b5ea-8e43ffa8079b}</RefActConfigId>
<PartNumber>[RS1]X21-06165</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d559863d-8e3d-4854-b5ea-8e43ffa8079b}</RefActConfigId>
<PartNumber>[RS1]X21-06166</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>14999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d559863d-8e3d-4854-b5ea-8e43ffa8079b}</RefActConfigId>
<PartNumber>[RS1]X21-06171</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>15000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d559863d-8e3d-4854-b5ea-8e43ffa8079b}</RefActConfigId>
<PartNumber>[RS1]X21-06169</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d559863d-8e3d-4854-b5ea-8e43ffa8079b}</RefActConfigId>
<PartNumber>[RS1]X21-06170</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>39999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d559863d-8e3d-4854-b5ea-8e43ffa8079b}</RefActConfigId>
<PartNumber>[RS1]X21-06168</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40000000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d559863d-8e3d-4854-b5ea-8e43ffa8079b}</RefActConfigId>
<PartNumber>[RS1]X21-06175</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>59999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d559863d-8e3d-4854-b5ea-8e43ffa8079b}</RefActConfigId>
<PartNumber>[RS1]X21-06172</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60000000</Start>
<End>69999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58a01bdf-695f-441b-b7c5-bba7b495b894}</RefActConfigId>
<PartNumber>[RS1]X21-06174</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58a01bdf-695f-441b-b7c5-bba7b495b894}</RefActConfigId>
<PartNumber>[RS1]X21-06173</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58a01bdf-695f-441b-b7c5-bba7b495b894}</RefActConfigId>
<PartNumber>[RS1]X21-06176</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58a01bdf-695f-441b-b7c5-bba7b495b894}</RefActConfigId>
<PartNumber>[RS1]X21-06177</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>39999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58a01bdf-695f-441b-b7c5-bba7b495b894}</RefActConfigId>
<PartNumber>[RS1]X21-06178</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>40000000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58a01bdf-695f-441b-b7c5-bba7b495b894}</RefActConfigId>
<PartNumber>[RS1]X21-06179</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>59999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3f1afc82-f8ac-4f6c-8005-1d233e606eee}</RefActConfigId>
<PartNumber>[RS1]X21-11809</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5300b18c-2e33-4dc2-8291-47ffcec746dd}</RefActConfigId>
<PartNumber>[RS1]X21-11810</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{345a5db0-d94f-4e3b-a0c0-7c42f7bc3ebf}</RefActConfigId>
<PartNumber>[RS1]X21-11811</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{550a7080-123a-4c1c-ad73-adebffe64cb0}</RefActConfigId>
<PartNumber>[RS1]X21-11812</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{be42a013-f6cd-4a01-9e02-7da242d5dab7}</RefActConfigId>
<PartNumber>[RS2]X21-24722</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{be42a013-f6cd-4a01-9e02-7da242d5dab7}</RefActConfigId>
<PartNumber>[RS2]X21-24724</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>54999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{be42a013-f6cd-4a01-9e02-7da242d5dab7}</RefActConfigId>
<PartNumber>[RS2]X21-24725</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>55000000</Start>
<End>59999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1ca0bfa8-d96b-4815-a732-7756f30c29e2}</RefActConfigId>
<PartNumber>[RS2]X21-24727</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1ca0bfa8-d96b-4815-a732-7756f30c29e2}</RefActConfigId>
<PartNumber>[RS2]X21-24742</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1ca0bfa8-d96b-4815-a732-7756f30c29e2}</RefActConfigId>
<PartNumber>[RS2]X21-24741</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e0b2d383-d112-413f-8a80-97f373a5820c}</RefActConfigId>
<PartNumber>[RS2]X21-24728</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]X21-24731</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]X21-24730</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]X21-24732</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>14999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]X21-24733</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>15000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]X21-24734</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>24999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]X21-24735</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>25000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]X21-24737</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>34999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]X21-24736</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>35000000</Start>
<End>39999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]X21-24739</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>40000000</Start>
<End>44999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]X21-24738</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>45000000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c03ad91f-6809-42f1-95d9-f59ac06e64b7}</RefActConfigId>
<PartNumber>[RS2]X21-24707</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c03ad91f-6809-42f1-95d9-f59ac06e64b7}</RefActConfigId>
<PartNumber>[RS2]X21-24706</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>54999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c03ad91f-6809-42f1-95d9-f59ac06e64b7}</RefActConfigId>
<PartNumber>[RS2]X21-24708</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>55000000</Start>
<End>59999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8d6f6ffe-0c30-40ec-9db2-aad7b23bb6e3}</RefActConfigId>
<PartNumber>[RS2]X21-24709</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8d6f6ffe-0c30-40ec-9db2-aad7b23bb6e3}</RefActConfigId>
<PartNumber>[RS2]X21-24744</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8d6f6ffe-0c30-40ec-9db2-aad7b23bb6e3}</RefActConfigId>
<PartNumber>[RS2]X21-24743</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e38454fb-41a4-4f59-a5dc-25080e354730}</RefActConfigId>
<PartNumber>[RS2]X21-24712</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]X21-24713</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]X21-24714</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]X21-24715</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>14999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]X21-24716</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>15000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]X21-24717</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>24999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]X21-24718</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>25000000</Start>
<End>29999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]X21-24719</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>34999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]X21-24720</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>35000000</Start>
<End>39999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]X21-24721</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>40000000</Start>
<End>44999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]X21-24723</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>45000000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcc5f846-873c-4a0b-acfc-e6c54257be79}</RefActConfigId>
<PartNumber>[RS2]X21-32980</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d4ef7282-3d2c-4cf0-9976-8854e64a8d1e}</RefActConfigId>
<PartNumber>[RS2]X21-32983</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d4ef7282-3d2c-4cf0-9976-8854e64a8d1e}</RefActConfigId>
<PartNumber>[RS2]X21-32982</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>5000099</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0c8be5d6-5b9d-4c6c-8065-eec218df39ed}</RefActConfigId>
<PartNumber>[RS2]X21-32988</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{af5c9381-9240-417d-8d35-eb40cd03e484}</RefActConfigId>
<PartNumber>[RS2]X21-32987</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{af5c9381-9240-417d-8d35-eb40cd03e484}</RefActConfigId>
<PartNumber>[RS2]X21-32989</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>5000099</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-32978</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>299999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36311</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>300000000</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-32979</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>504999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-32981</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>505000000</Start>
<End>509999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36313</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>510000000</Start>
<End>514999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36312</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>515000000</Start>
<End>519999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36315</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>520000000</Start>
<End>569999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36314</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>570000000</Start>
<End>619999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36317</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>620000000</Start>
<End>669999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36316</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>670000000</Start>
<End>719999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36318</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>720000000</Start>
<End>769999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36319</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>770000000</Start>
<End>799999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36321</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>800000000</Start>
<End>824999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36320</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>825000000</Start>
<End>849999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36322</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>850000000</Start>
<End>874999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36323</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>875000000</Start>
<End>899999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{24a0166c-ef8a-436f-bf77-e0ecdf55a41e}</RefActConfigId>
<PartNumber>[RS2]X21-36324</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>900000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-32984</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>249999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36325</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>250000000</Start>
<End>499999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-32986</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>500000000</Start>
<End>504999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-32985</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>505000000</Start>
<End>509999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36327</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>510000000</Start>
<End>514999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36326</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>515000000</Start>
<End>519999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36328</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>520000000</Start>
<End>569999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36329</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>570000000</Start>
<End>619999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36331</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>620000000</Start>
<End>669999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36330</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>670000000</Start>
<End>719999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36332</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>720000000</Start>
<End>769999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36333</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>770000000</Start>
<End>799999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36334</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>800000000</Start>
<End>824999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36335</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>825000000</Start>
<End>849999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36337</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>850000000</Start>
<End>874999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36336</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>875000000</Start>
<End>899999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f29fabb6-f9f4-4f08-ba72-0d9fdaa561fb}</RefActConfigId>
<PartNumber>[RS2]X21-36338</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>900000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{62f0c100-9c53-4e02-b886-a3528ddfe7f6}</RefActConfigId>
<PartNumber>[RS1]X21-22361</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>4000099</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{13a38698-4a49-4b9e-8e83-98fe51110953}</RefActConfigId>
<PartNumber>[RS1]X21-22363</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>1000099</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{62f0c100-9c53-4e02-b886-a3528ddfe7f6}</RefActConfigId>
<PartNumber>[RS1]X21-39883</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>4000100</Start>
<End>4000199</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{13a38698-4a49-4b9e-8e83-98fe51110953}</RefActConfigId>
<PartNumber>[RS1]X21-39884</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1000100</Start>
<End>1000199</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</RefActConfigId>
<PartNumber>[RS3]X21-43603</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</RefActConfigId>
<PartNumber>[RS3]X21-43604</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</RefActConfigId>
<PartNumber>[RS3]X21-43606</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</RefActConfigId>
<PartNumber>[RS3]X21-43605</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>10999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</RefActConfigId>
<PartNumber>[RS3]X21-43608</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>11000000</Start>
<End>12999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</RefActConfigId>
<PartNumber>[RS3]X21-43607</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>13000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</RefActConfigId>
<PartNumber>[RS3]X21-43609</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</RefActConfigId>
<PartNumber>[RS3]X21-43610</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</RefActConfigId>
<PartNumber>[RS3]X21-43611</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</RefActConfigId>
<PartNumber>[RS3]X21-43612</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</RefActConfigId>
<PartNumber>[RS3]X21-43613</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</RefActConfigId>
<PartNumber>[RS3]X21-43614</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</RefActConfigId>
<PartNumber>[RS3]X21-43615</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>10999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</RefActConfigId>
<PartNumber>[RS3]X21-43616</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>11000000</Start>
<End>12999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</RefActConfigId>
<PartNumber>[RS3]X21-43618</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>13000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</RefActConfigId>
<PartNumber>[RS3]X21-43617</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</RefActConfigId>
<PartNumber>[RS3]X21-43619</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</RefActConfigId>
<PartNumber>[RS3]X21-43620</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3502365a-f88a-4ba4-822a-5769d3073b65}</RefActConfigId>
<PartNumber>[RS3]X21-43621</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>199999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3502365a-f88a-4ba4-822a-5769d3073b65}</RefActConfigId>
<PartNumber>[RS3]X21-43623</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>200000000</Start>
<End>204999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3502365a-f88a-4ba4-822a-5769d3073b65}</RefActConfigId>
<PartNumber>[RS3]X21-43622</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>205000000</Start>
<End>209999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{95dca82f-385d-4d39-b85b-5c73fa285d6f}</RefActConfigId>
<PartNumber>[RS3]X21-43625</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>24999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{95dca82f-385d-4d39-b85b-5c73fa285d6f}</RefActConfigId>
<PartNumber>[RS3]X21-43624</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>25000000</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{eb6d346f-1c60-4643-b960-40ec31596c45}</RefActConfigId>
<PartNumber>[RS3]X21-43626</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{eb6d346f-1c60-4643-b960-40ec31596c45}</RefActConfigId>
<PartNumber>[RS3]X21-43627</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>10009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{82bbc092-bc50-4e16-8e18-b74fc486aec3}</RefActConfigId>
<PartNumber>[RS3]X21-43628</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]X21-43629</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]X21-43631</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]X21-43630</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]X21-43632</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>10999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]X21-43633</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>11000000</Start>
<End>12999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]X21-43635</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>13000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]X21-43634</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]X21-43636</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]X21-43637</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]X21-43638</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>34999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{608e9c8c-895c-47ad-a336-4abd5ae221a4}</RefActConfigId>
<PartNumber>[RS3]X21-43639</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>49999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{608e9c8c-895c-47ad-a336-4abd5ae221a4}</RefActConfigId>
<PartNumber>[RS3]X21-43641</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>54999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{608e9c8c-895c-47ad-a336-4abd5ae221a4}</RefActConfigId>
<PartNumber>[RS3]X21-43640</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>55000000</Start>
<End>59999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9252fc78-051d-4eef-b4e1-ae263a885708}</RefActConfigId>
<PartNumber>[RS3]X21-43643</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9252fc78-051d-4eef-b4e1-ae263a885708}</RefActConfigId>
<PartNumber>[RS3]X21-43642</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>19999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{89e87510-ba92-45f6-8329-3afa905e3e83}</RefActConfigId>
<PartNumber>[RS3]X21-43644</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{89e87510-ba92-45f6-8329-3afa905e3e83}</RefActConfigId>
<PartNumber>[RS3]X21-43645</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>10000000</Start>
<End>10009999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4b1571d3-bafb-4b40-8087-a961be2caf65}</RefActConfigId>
<PartNumber>[RS3]X21-43646</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]X21-43647</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>4999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]X21-43648</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>6999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]X21-43649</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>7000000</Start>
<End>8999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]X21-43650</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>9000000</Start>
<End>10999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]X21-43651</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>11000000</Start>
<End>12999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]X21-43652</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>13000000</Start>
<End>17999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]X21-43653</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>18000000</Start>
<End>22999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]X21-43655</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>23000000</Start>
<End>27999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]X21-43654</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>28000000</Start>
<End>32999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]X21-43656</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>34999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6365275e-368d-46ca-a0ef-fc0404119333}</RefActConfigId>
<PartNumber>[RS3]X21-04951</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e9a93439-eac5-4d1b-9123-f29bd20cc8fc}</RefActConfigId>
<PartNumber>[RS3]X21-04954</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2b1f36bb-c1cd-4306-bf5c-a0367c2d97d8}</RefActConfigId>
<PartNumber>[TH]res-v3261</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>157010000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e371d89a-73e8-4b24-a7ff-23a3641dd18e}</RefActConfigId>
<PartNumber>[TH]res-v3262</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>500</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{411b3d4f-be6d-4a06-baaa-9cabfc256cae}</RefActConfigId>
<PartNumber>[TH]res-v3504</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{74436dbb-cc17-46de-867f-14906ba4a938}</RefActConfigId>
<PartNumber>[TH]res-v3505</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d1bac85-7365-4fea-949a-96978ec91ae0}</RefActConfigId>
<PartNumber>[TH]res-v3266</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>800</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f742e4ff-909d-4fe9-aacb-3231d24a0c58}</RefActConfigId>
<PartNumber>[TH]res-v3270</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>67010000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{06e74065-465d-4e14-ab23-c34a28aa54aa}</RefActConfigId>
<PartNumber>[TH]res-v3271</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>500</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3ae2cc14-ab2d-41f4-972f-5e20142771dc}</RefActConfigId>
<PartNumber>[TH]res-v3276</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>800</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e558417a-5123-4f6f-91e7-385c1c7ca9d4}</RefActConfigId>
<PartNumber>[TH]res-v3280</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>80000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c5198a66-e435-4432-89cf-ec777c9d0352}</RefActConfigId>
<PartNumber>[TH]res-v3285</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>61200000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4de7cb65-cdf1-4de9-8ae8-e3cce27b9f2c}</RefActConfigId>
<PartNumber>[TH]res-v3308</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>146860000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{377333b1-8b5d-48d6-9679-1225c872d37c}</RefActConfigId>
<PartNumber>[TH]res-v3309</PartNumber>
<EulaType>Retail:WAU:101;99;100;</EulaType>
<IsValid>true</IsValid>
<Start>1000100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0773a15-df3a-4312-9ad2-83d69648e356}</RefActConfigId>
<PartNumber>[TH]res-v3310</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>800</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c86d5194-4840-4dae-9c1c-0301003a5ab0}</RefActConfigId>
<PartNumber>[TH]res-v3506</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6eadb3b-5ca8-4a6b-986e-35b550756111}</RefActConfigId>
<PartNumber>[TH]res-v3507</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9fbaf5d6-4d83-4422-870d-fdda6e5858aa}</RefActConfigId>
<PartNumber>[TH]res-v3316</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>73010000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9c4a7917-c857-4bd5-b109-d21866014b5c}</RefActConfigId>
<PartNumber>[TH]res-v3317</PartNumber>
<EulaType>Retail:WAU:98;</EulaType>
<IsValid>true</IsValid>
<Start>1000100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a9e86e9-057b-40ca-b11b-307d8f167ae8}</RefActConfigId>
<PartNumber>[TH]res-v3318</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>500</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b4bfe195-541e-4e64-ad23-6177f19e395e}</RefActConfigId>
<PartNumber>[TH]res-v3282</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>52000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ef518fa-b31e-4c71-851a-d10f61eccd54}</RefActConfigId>
<PartNumber>[TH]res-v3287</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>52000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ffd8952-423e-4903-b993-72a1aa44cf82}</RefActConfigId>
<PartNumber>[TH]res-v3291</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>56430000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c83cef07-6b72-4bbc-a28f-a00386872839}</RefActConfigId>
<PartNumber>[TH]res-v3300</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>55680000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{49cd895b-53b2-4dc4-a5f7-b18aa019ad37}</RefActConfigId>
<PartNumber>[TH]res-v3312</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>51130000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ef51e000-2659-4f25-8345-3de70a9cf4c4}</RefActConfigId>
<PartNumber>[TH]res-v3313</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>300</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2ea9cf38-0d06-4ed0-a4be-66fc7c919a42}</RefActConfigId>
<PartNumber>[TH]res-v3320</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>48130000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5694ba59-213b-468a-b2c9-82a4dd09877d}</RefActConfigId>
<PartNumber>[TH]res-v3321</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>300</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{30d469c6-a78f-4476-b5c8-af78d5b6a5fb}</RefActConfigId>
<PartNumber>[TH]res-v3260</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>350000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f4fcb21e-34ca-4383-865a-ab4d36363e03}</RefActConfigId>
<PartNumber>[TH]res-v3265</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>168510000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2479ad7a-fe16-43f2-aec8-b30a210fe303}</RefActConfigId>
<PartNumber>[TH]res-v3269</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60500000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4002e33a-524c-4100-8108-131a0d42c0ea}</RefActConfigId>
<PartNumber>[TH]res-v3275</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>319510000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2936d1d2-913a-4542-b54e-ce5a602a2a38}</RefActConfigId>
<PartNumber>[TH]res-v3279</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10010000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c6c0a31e-7003-4dff-b4f9-ddc9f8d20af9}</RefActConfigId>
<PartNumber>[TH]res-v3284</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1010000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8b351c9c-f398-4515-9900-09df49427262}</RefActConfigId>
<PartNumber>[TH]res-v3289</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>360030000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2a6137f3-75c0-4f26-8e3e-d83d802865a4}</RefActConfigId>
<PartNumber>[TH]res-v3304</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{221a02da-e2a1-4b75-864c-0a4410a33fdf}</RefActConfigId>
<PartNumber>[TH]res-v3307</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>474500000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1419d934-3a3f-46d4-8a5e-8594a56b9e6f}</RefActConfigId>
<PartNumber>[TH]res-v3315</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>61000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0567073a-7d74-403b-b2d5-6b35da372d8d}</RefActConfigId>
<PartNumber>[TH]res-v3258</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>738000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8db63db6-4f8f-46d6-a448-66444faaaa72}</RefActConfigId>
<PartNumber>[TH]res-v3259</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>790000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1d873132-f09f-4eb2-bf5a-2e4fb48935e8}</RefActConfigId>
<PartNumber>[TH]res-v3422</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>590000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b27bf099-cf06-499e-af17-de73ba94b316}</RefActConfigId>
<PartNumber>[TH]res-v3264</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>816000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{847bb612-a888-441f-a947-a684ddd9099f}</RefActConfigId>
<PartNumber>[TH]res-v3423</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>460000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8e518ff0-bab0-4ea1-a233-61338721bf0b}</RefActConfigId>
<PartNumber>[TH]res-v3268</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>184500000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed799377-74b8-4989-a244-14d082e65972}</RefActConfigId>
<PartNumber>[TH]res-v3273</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>621000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{653098ee-780d-4863-8cf2-d18399ce413b}</RefActConfigId>
<PartNumber>[TH]res-v3274</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>640000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8a292df8-d653-4057-8133-a0701792f912}</RefActConfigId>
<PartNumber>[TH]res-v3424</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>230000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1a9a717a-cf13-4ba5-83c3-0fe25fa868d5}</RefActConfigId>
<PartNumber>[TH]res-v3278</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>318000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcca5ad8-d7aa-432b-8bf3-1829dfe7d0f2}</RefActConfigId>
<PartNumber>[TH]res-v3283</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>39000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{7cb546c0-c7d5-44d8-9a5c-69ecdd782b69}</RefActConfigId>
<PartNumber>[TH]res-v3288</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>575000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d6323d79-620e-4b82-bd5f-765e820d69e6}</RefActConfigId>
<PartNumber>[TH]res-v3293</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>575000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{bd3762d7-270d-4760-8fb3-d829ca45278a}</RefActConfigId>
<PartNumber>[TH]res-v3305</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>829000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{613d217f-7f13-4268-9907-1662339531cd}</RefActConfigId>
<PartNumber>[TH]res-v3306</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>819000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2c293c26-a45a-4a2a-a350-c69a67097529}</RefActConfigId>
<PartNumber>[TH]res-v3425</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>805000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fe74f55b-0338-41d6-b267-4a201abe7285}</RefActConfigId>
<PartNumber>[TH]res-v3556</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{040fa323-92b1-4baf-97a2-5b67feaefddb}</RefActConfigId>
<PartNumber>[TH]res-v3557</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b6f26b97-8a82-4781-beef-1123952988f2}</RefActConfigId>
<PartNumber>[TH]res-v3314</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>156750000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4053f6e4-20bb-49f2-b808-8385c48b5cd5}</RefActConfigId>
<PartNumber>[TH]res-v3558</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6ccd24e5-8cc4-49ae-8996-dcfdcb4e1dc2}</RefActConfigId>
<PartNumber>[TH]res-v3559</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2782d615-3249-495b-8260-15a4c2295448}</RefActConfigId>
<PartNumber>[RS1]res-v3802</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>65230000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3d1022d8-969f-4222-b54b-327f5a5af4c9}</RefActConfigId>
<PartNumber>[RS1]res-v3803</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>64480000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f9ee36aa-c068-43f9-8a22-8fb71d07566a}</RefActConfigId>
<PartNumber>[RS1]res-v3806</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>283000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{706e0cfd-23f4-43bb-a9af-1a492b9f1302}</RefActConfigId>
<PartNumber>[RS1]res-v3807</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>320020000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e7a950a2-e548-4f10-bf16-02ec848e0643}</RefActConfigId>
<PartNumber>[RS1]res-v3792</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>760000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{4f3da0d2-271d-4508-ae81-626b60809a38}</RefActConfigId>
<PartNumber>[RS1]res-v3793</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>300000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d559863d-8e3d-4854-b5ea-8e43ffa8079b}</RefActConfigId>
<PartNumber>[RS1]res-v3794</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>70000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{58a01bdf-695f-441b-b7c5-bba7b495b894}</RefActConfigId>
<PartNumber>[RS1]res-v3795</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{62f0c100-9c53-4e02-b886-a3528ddfe7f6}</RefActConfigId>
<PartNumber>[RS1]res-v3800</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>4000200</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{13a38698-4a49-4b9e-8e83-98fe51110953}</RefActConfigId>
<PartNumber>[RS1]res-v3801</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1000200</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{345a5db0-d94f-4e3b-a0c0-7c42f7bc3ebf}</RefActConfigId>
<PartNumber>[RS1]res-v3786</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{550a7080-123a-4c1c-ad73-adebffe64cb0}</RefActConfigId>
<PartNumber>[RS1]res-v3787</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>5000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{be42a013-f6cd-4a01-9e02-7da242d5dab7}</RefActConfigId>
<PartNumber>[RS2]res-v3854</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1ca0bfa8-d96b-4815-a732-7756f30c29e2}</RefActConfigId>
<PartNumber>[RS2]res-v3855</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5f87a508-7e1c-4fab-9d45-2356c6002081}</RefActConfigId>
<PartNumber>[RS2]res-v3857</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{c03ad91f-6809-42f1-95d9-f59ac06e64b7}</RefActConfigId>
<PartNumber>[RS2]res-v3859</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{8d6f6ffe-0c30-40ec-9db2-aad7b23bb6e3}</RefActConfigId>
<PartNumber>[RS2]res-v3860</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>30000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1681ae34-3080-4bfa-a1b5-6d792342e692}</RefActConfigId>
<PartNumber>[RS2]res-v3862</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{dcc5f846-873c-4a0b-acfc-e6c54257be79}</RefActConfigId>
<PartNumber>[RS2]res-v3864</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d4ef7282-3d2c-4cf0-9976-8854e64a8d1e}</RefActConfigId>
<PartNumber>[RS2]res-v3865</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>5000100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0c8be5d6-5b9d-4c6c-8065-eec218df39ed}</RefActConfigId>
<PartNumber>[RS2]res-v3867</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>10000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{af5c9381-9240-417d-8d35-eb40cd03e484}</RefActConfigId>
<PartNumber>[RS2]res-v3868</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>5000100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6365275e-368d-46ca-a0ef-fc0404119333}</RefActConfigId>
<PartNumber>[RS3]res-v3798</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e9a93439-eac5-4d1b-9123-f29bd20cc8fc}</RefActConfigId>
<PartNumber>[RS3]res-v3799</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{5da22a1c-03e3-44b9-9baa-6cf813821ed3}</RefActConfigId>
<PartNumber>[RS3]res-v3913</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{88dd2204-e92d-40e3-9c35-5c4cc53e6a0a}</RefActConfigId>
<PartNumber>[RS3]res-v3914</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>33000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{3502365a-f88a-4ba4-822a-5769d3073b65}</RefActConfigId>
<PartNumber>[RS3]res-v3915</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>210000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{95dca82f-385d-4d39-b85b-5c73fa285d6f}</RefActConfigId>
<PartNumber>[RS3]res-v3916</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>50000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{eb6d346f-1c60-4643-b960-40ec31596c45}</RefActConfigId>
<PartNumber>[RS3]res-v3917</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>10010000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{721f9237-9341-4453-a661-09e8baa6cca5}</RefActConfigId>
<PartNumber>[RS3]res-v3919</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>35000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{608e9c8c-895c-47ad-a336-4abd5ae221a4}</RefActConfigId>
<PartNumber>[RS3]res-v3920</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>60000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9252fc78-051d-4eef-b4e1-ae263a885708}</RefActConfigId>
<PartNumber>[RS3]res-v3921</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>20000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{89e87510-ba92-45f6-8329-3afa905e3e83}</RefActConfigId>
<PartNumber>[RS3]res-v3922</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>10010000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0e0a4643-943f-4a28-b82f-db752d0d7ec7}</RefActConfigId>
<PartNumber>[RS3]res-v3924</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>35000000</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{46fc26ea-6671-4d0f-955b-7d984f0bcdad}</RefActConfigId>
<PartNumber>[TH]X20-35550</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ba782239-2781-43bd-b6ce-9fbeb5cec154}</RefActConfigId>
<PartNumber>[TH]X20-35551</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{81f9b6d3-8aa5-43d3-abbb-8f8e226e2c63}</RefActConfigId>
<PartNumber>[TH]X20-15833</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{71153417-69a6-4767-84e3-dd75ad09b44c}</RefActConfigId>
<PartNumber>[TH]X20-15834</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{81f9b6d3-8aa5-43d3-abbb-8f8e226e2c63}</RefActConfigId>
<PartNumber>[TH]res-v3495</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{71153417-69a6-4767-84e3-dd75ad09b44c}</RefActConfigId>
<PartNumber>[TH]res-v3496</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>100</Start>
<End>999999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ee8464ba-bcf0-4af1-b1b1-b1850b91bfa9}</RefActConfigId>
<PartNumber>[Blue]X20-19835:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{35cc0c20-01a2-4ec5-8f0e-664e5025008f}</RefActConfigId>
<PartNumber>[TH]X20-87484:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2bf74405-283d-46ff-a37e-6828c5a5c7c0}</RefActConfigId>
<PartNumber>[TH]X20-91396:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6301fd75-0488-4b9e-b8c2-ae095b1c86bf}</RefActConfigId>
<PartNumber>[TH]X20-91395:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{df96023b-dcd9-4be2-afa0-c6c871159ebe}</RefActConfigId>
<PartNumber>[RS3]X21-41295:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fa755fe6-6739-40b9-8d84-6d0ea3b6d1ab}</RefActConfigId>
<PartNumber>[RS3]X21-41296:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0ad2ac98-7bb9-4201-8d92-312299201369}</RefActConfigId>
<PartNumber>[RS3]X21-41297</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e4db50ea-bda1-4566-b047-0ca50abc6f07}</RefActConfigId>
<PartNumber>[RS3]X21-41298</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{291ece0e-9c38-40ca-a9e1-32cc7ec19507}</RefActConfigId>
<PartNumber>[RS3]X21-41300:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b13d53d4-1a21-4d49-9eb1-20c7eafc77d4}</RefActConfigId>
<PartNumber>[Blue]X18-15541</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>6000000</Start>
<End>6499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{73416275-0240-425f-90d9-d92590083699}</RefActConfigId>
<PartNumber>[Blue]X18-15572</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>5500000</Start>
<End>5999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed36b7fc-be9b-4889-b89d-0243f716df2b}</RefActConfigId>
<PartNumber>[Blue]X18-28456</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>317000000</Start>
<End>343999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0f8a518-2c58-4eb8-9319-084f0eb4ddc4}</RefActConfigId>
<PartNumber>[Blue]X18-28457</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>90999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{71f411ae-7b4b-41bd-b68c-c519c499f950}</RefActConfigId>
<PartNumber>[Blue]X18-52140</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>955000000</Start>
<End>955299999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed36b7fc-be9b-4889-b89d-0243f716df2b}</RefActConfigId>
<PartNumber>[Blue]X18-52141</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>355000000</Start>
<End>355299999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b13d53d4-1a21-4d49-9eb1-20c7eafc77d4}</RefActConfigId>
<PartNumber>[Blue]X18-15541</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>26000000</Start>
<End>26499999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed36b7fc-be9b-4889-b89d-0243f716df2b}</RefActConfigId>
<PartNumber>[Blue]X18-28456</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>854950000</Start>
<End>881949999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ed36b7fc-be9b-4889-b89d-0243f716df2b}</RefActConfigId>
<PartNumber>[Blue]X18-52141</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>881950000</Start>
<End>882249999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{71f411ae-7b4b-41bd-b68c-c519c499f950}</RefActConfigId>
<PartNumber>[Blue]X18-52140</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>955450000</Start>
<End>955749999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{73416275-0240-425f-90d9-d92590083699}</RefActConfigId>
<PartNumber>[Blue]X18-15572</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>21750000</Start>
<End>22249999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b0f8a518-2c58-4eb8-9319-084f0eb4ddc4}</RefActConfigId>
<PartNumber>[Blue]X18-28457</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>649000000</Start>
<End>663999999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{23505d51-32d6-41f0-8ca7-e78ad0f16e71}</RefActConfigId>
<PartNumber>[TH]X17-37458</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{211b80cc-7f64-482c-89e9-4ba21ff827ad}</RefActConfigId>
<PartNumber>[TH]X17-48253</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0aa31bde-a50d-4544-9434-a8154e1f4ebe}</RefActConfigId>
<PartNumber>[Blue]X18-15617</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>199999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{98f1827a-79be-4945-8957-304d283c95e5}</RefActConfigId>
<PartNumber>[Blue]X18-15615</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>9999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e1ef459b-eb4c-4609-baee-9b8b3d9aa222}</RefActConfigId>
<PartNumber>[Blue]X18-15626</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>19</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{215f2ffd-4c88-416f-966c-0315549c5a26}</RefActConfigId>
<PartNumber>[Blue]X18-15627</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>0</Start>
<End>99999</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0d17ff59-c618-4007-ab49-d48c941a8bcc}</RefActConfigId>
<PartNumber>[Blue]X17-36803:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{cb20a646-4bcb-4615-820a-e832a5e79942}</RefActConfigId>
<PartNumber>[Blue]X17-36804</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{89dda8f4-eefe-498d-9f25-201a763c0824}</RefActConfigId>
<PartNumber>[Blue]X17-36805:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{793fbec3-7313-469e-bfd3-938123de3e85}</RefActConfigId>
<PartNumber>[Blue]X17-36806:Virtual</PartNumber>
<EulaType>OEM</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{1be52dfa-347b-4ea9-a5a0-903fe990a797}</RefActConfigId>
<PartNumber>[Blue]X17-66962:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{53cfae25-4180-4d86-bfcf-ff4d1adb9caa}</RefActConfigId>
<PartNumber>[Blue]X17-66963:Virtual</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{972ba9b4-65c4-47c2-9b12-febfdd2604b3}</RefActConfigId>
<PartNumber>[Blue]X17-66964:Virtual</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e5676f13-9b66-4a1f-8b0c-43490e236202}</RefActConfigId>
<PartNumber>[Blue]X17-66965</PartNumber>
<EulaType>Volume</EulaType>
<IsValid>true</IsValid>
<Start>1000000</Start>
<End>999999998</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{80ed1ba0-2fe4-432e-9430-150359e7679b}</RefActConfigId>
<PartNumber>[Blue]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000060</Start>
<End>2000060</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a1564da7-3cb5-4ac3-b70c-7e6c0c4a8bf1}</RefActConfigId>
<PartNumber>[Blue]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000061</Start>
<End>2000061</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{0cc8648c-345c-4576-a335-69f12dcbc9e3}</RefActConfigId>
<PartNumber>[Blue]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000062</Start>
<End>2000062</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a72a7c81-fe67-46b5-a69c-7624a1bfe5e9}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>2000063</Start>
<End>2000063</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{fb91c3ec-ea4d-42f4-a765-2dcd66bb1ece}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>EVAL</EulaType>
<IsValid>true</IsValid>
<Start>2000064</Start>
<End>2000064</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{f7af7d09-40e4-419c-a49b-eae366689ebd}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000066</Start>
<End>2000066</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{a48938aa-62fa-4966-9d44-9f04da3f72f2}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000067</Start>
<End>2000067</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{9c4d84ee-befc-4c86-9dde-af7d36267a8a}</RefActConfigId>
<PartNumber>[8]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000068</Start>
<End>2000068</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{237f6a98-d028-474d-93ed-226c70a90e68}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000069</Start>
<End>2000069</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b71515d9-89a2-4c60-88c8-656fbcca7f3a}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000070</Start>
<End>2000070</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{884e5c0c-c968-4182-a7c3-a37d2f716531}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000071</Start>
<End>2000071</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{55da3f53-5faa-4d2b-9a0f-e49094d7e942}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000072</Start>
<End>2000072</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{583f15fe-fbc2-44de-9cb3-bc196b9a8f0d}</RefActConfigId>
<PartNumber>[Blue]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000073</Start>
<End>2000073</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{735dc33a-d41d-442b-9b70-61f680da0917}</RefActConfigId>
<PartNumber>[Blue]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000074</Start>
<End>2000074</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{65d62b33-ca15-4d93-b446-e3473ebc341c}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000075</Start>
<End>2000075</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{6fb525d4-9952-4b70-ac7b-ff0aa7e20e41}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000076</Start>
<End>2000076</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{ce7dd669-1230-444f-a107-2c5bd1ba8117}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000077</Start>
<End>2000077</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{e35a5d2a-7de6-4266-893e-b9e5bf950dcd}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000078</Start>
<End>2000078</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{47305a46-dd4b-469e-bf7d-fd5ceef69c41}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000079</Start>
<End>2000079</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{442fc1f5-021c-48f7-945b-563e762c95fe}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000080</Start>
<End>2000080</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{326eb516-f215-49c4-9fe2-41065a739d6a}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000081</Start>
<End>2000081</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{b1c1e105-597d-4aac-9e1d-c7e264c4c91f}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000082</Start>
<End>2000082</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{050d1eb7-2345-4eb7-a0b2-0a2c147db37b}</RefActConfigId>
<PartNumber>[TH]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000083</Start>
<End>2000083</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{d09822a3-9040-4510-8242-9fc1cfd558d3}</RefActConfigId>
<PartNumber>[Blue]X99-99999</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>2000084</Start>
<End>2000084</End>
</KeyRange>
<KeyRange>
<RefActConfigId>{2cf1c8d6-ebe1-4ce9-83c6-c4877fae1355}</RefActConfigId>
<PartNumber>[Blue]X14-19709:Virtual</PartNumber>
<EulaType>Retail</EulaType>
<IsValid>true</IsValid>
<Start>29000004</Start>
<End>29000004</End>
</KeyRange>
</KeyRanges>
<PublicKeys>
<PublicKey>
<GroupId>152</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2005</AlgorithmId>
<PublicKeyValue>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</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1058</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1059</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1060</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1061</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1345</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1346</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1347</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1348</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1790</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1792</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1794</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1798</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1873</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1875</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1884</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1885</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>1913</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3258</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3259</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3260</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3261</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3262</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3263</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3264</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3265</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3266</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3267</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3268</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3269</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3270</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3271</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3272</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3273</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3274</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3275</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3276</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3277</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3278</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3279</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3280</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3281</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3282</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3283</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3284</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3285</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3286</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3287</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3288</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3289</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3290</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3291</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3292</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3293</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3299</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3300</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3301</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3304</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3305</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3306</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3307</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3308</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3309</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3310</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3311</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3312</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3313</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3314</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3315</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3316</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3317</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3318</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3319</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3320</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3321</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3422</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3423</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3424</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3425</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3495</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3496</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3504</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3505</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3506</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3507</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3510</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3556</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3557</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3558</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3559</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3560</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3561</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3562</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3563</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3631</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3632</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3678</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3679</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3720</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3721</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3728</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3732</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3733</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3744</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3745</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3746</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3747</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3748</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3749</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3750</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3751</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3752</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3753</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3754</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3755</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3756</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3757</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3758</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3759</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3760</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3761</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3762</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3763</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3764</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3765</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3766</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3767</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3768</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3769</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3770</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3771</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3772</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3773</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3774</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3775</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3776</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3777</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3778</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3779</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3780</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3782</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3783</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3784</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3785</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3786</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3787</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3788</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3789</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3792</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3793</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3794</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3795</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3798</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3799</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3800</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3801</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3802</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3803</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3804</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3805</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3806</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3807</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3839</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3840</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3841</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3842</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3843</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3844</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3854</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3855</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3856</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3857</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3859</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3860</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3861</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3862</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3863</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3864</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3865</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3866</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3867</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3868</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3892</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3893</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3894</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3895</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3896</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3909</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3910</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3913</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3914</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3915</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3916</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3917</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3918</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3919</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3920</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3921</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3922</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3923</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3924</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3955</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3956</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3958</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3959</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3960</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>3961</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>100054</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>100055</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
<PublicKey>
<GroupId>999999</GroupId>
<AlgorithmId>msft:rm/algorithm/pkey/2009</AlgorithmId>
<PublicKeyValue>bXNmdDpwa2V5LzIwMDkvY3J5cHRvcHJvZmlsZS9obWFjL3NoYTI1Ng==</PublicKeyValue>
</PublicKey>
</PublicKeys>
</ProductKeyConfiguration>
</tm:infoBin></tm:infoList></tm:infoTables></r:otherInfo></r:license></rg:licenseGroup>
\ No newline at end of file
diff --git a/WinKeyRecover/WinKeyRecover.csproj b/WinKeyRecover/WinKeyRecover.csproj
index e8b9eeb..1bd65fa 100644
--- a/WinKeyRecover/WinKeyRecover.csproj
+++ b/WinKeyRecover/WinKeyRecover.csproj
@@ -67,6 +67,8 @@
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Memory, Version=4.0.1.2, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL" />
+    <Reference Include="System.Text.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
@@ -75,8 +77,20 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="KeyChecker\CheckKey.cs" />
+    <Compile Include="KeyChecker\GetProductDescription.cs" />
+    <Compile Include="KeyChecker\GetString.cs" />
+    <Compile Include="NativeMethods\NativeMethods.cs" />
+    <Compile Include="KeyManager\GeneratePattern.cs" />
+    <Compile Include="KeyManager\GetMissingPositons.cs" />
+    <Compile Include="KeyManager\CheckIsValid.cs" />
+    <Compile Include="KeyManager\CountMissingChars.cs" />
+    <Compile Include="KeyManager\ReplaceMissings.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Saver\ISaver.cs" />
+    <Compile Include="Saver\SaveAsTxt.cs" />
+    <Compile Include="Saver\SaveAsJson.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
@@ -97,5 +111,6 @@
   <ItemGroup>
     <Content Include="key.ico" />
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>
\ No newline at end of file
diff --git a/WinKeyRecover/keyManager/CheckIsValid.cs b/WinKeyRecover/keyManager/CheckIsValid.cs
new file mode 100644
index 0000000..5b6775b
--- /dev/null
+++ b/WinKeyRecover/keyManager/CheckIsValid.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WinKeyRecover
+{
+    internal class CheckIsValid
+    {
+        private string key;
+
+        public bool CheckKey(char[] validChars, string key)
+        {
+            this.key = key.ToUpper();
+
+            if (this.key != string.Empty 
+                && this.key.Length == 29 
+                && this.key.Contains('*')
+                )
+            {
+                for (int i = 0; i < key.Length; i++)
+                {
+                    if (this.key[i] != '-'
+                        && this.key[i] != '*'
+                        && !validChars.Contains(this.key[i]) 
+                        )
+                    {
+                        return false;
+                    }
+                }
+            }
+            else
+            {
+            return false;
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/WinKeyRecover/keyManager/CountMissingChars.cs b/WinKeyRecover/keyManager/CountMissingChars.cs
new file mode 100644
index 0000000..b92b357
--- /dev/null
+++ b/WinKeyRecover/keyManager/CountMissingChars.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WinKeyRecover
+{
+    internal class CountMissingChars
+    {
+        private int missing = 0;
+
+        public int Count(string key)
+        {
+            for (int i = 0; i < key.Length; i++)
+            {
+                if (key[i] == '*')
+                {
+                    missing++;
+                }
+            }
+
+            return missing;
+        }
+    }
+}
diff --git a/WinKeyRecover/keyManager/GeneratePattern.cs b/WinKeyRecover/keyManager/GeneratePattern.cs
new file mode 100644
index 0000000..dbd0809
--- /dev/null
+++ b/WinKeyRecover/keyManager/GeneratePattern.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WinKeyRecover
+{
+    internal class GeneratePattern
+    {
+        private readonly List<string> generatedPatterns = new List<string>();
+
+        public List<string> Generate(char[] patternChars, int patternLength, string patternBase = "")
+        {
+            if (patternLength == 1)
+            {
+                for (int i = 0; i < patternChars.Length; i++)
+                {
+                    generatedPatterns.Add(patternBase + patternChars[i]);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < patternChars.Length; i++)
+                {
+                    string patternNew = patternBase + patternChars[i];
+                    _ = Generate(patternChars, patternLength - 1, patternNew);
+                }
+            }
+            
+            return generatedPatterns;
+        }
+    }
+}
+
+
diff --git a/WinKeyRecover/keyManager/GetMissingPositons.cs b/WinKeyRecover/keyManager/GetMissingPositons.cs
new file mode 100644
index 0000000..14bf8e8
--- /dev/null
+++ b/WinKeyRecover/keyManager/GetMissingPositons.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WinKeyRecover
+{
+    internal class GetMissingPositions
+    {
+        private readonly List<int> missingPosition = new List<int>();
+
+        public List<int> GetPositions(string key)
+        {
+            for (int i = 0; i < key.Length; i++)
+            {
+                if (key[i] == '*')
+                {
+                    missingPosition.Add(i);
+                }
+            }
+            
+            return missingPosition;
+        }
+    }
+}
diff --git a/WinKeyRecover/keyManager/ReplaceMissings.cs b/WinKeyRecover/keyManager/ReplaceMissings.cs
new file mode 100644
index 0000000..6e5e1ae
--- /dev/null
+++ b/WinKeyRecover/keyManager/ReplaceMissings.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WinKeyRecover
+{
+    internal class ReplaceMissings
+    {
+        private readonly string key;
+        private readonly List<int> missingPosition;
+
+        public ReplaceMissings(string key, List<int> missingPosition)
+        {
+            this.key = key;
+            this.missingPosition = missingPosition;
+        }
+
+        public string Replace(string pattern)
+        {
+            char[] finalKey = new List<char>(key).ToArray();
+
+            for (int i = 0; i < pattern.Length; i++)
+            {
+                finalKey[missingPosition[i]] = pattern[i];
+            }
+
+            return new string(finalKey);
+        }
+    }
+}
diff --git a/WinKeyRecover/pidgenx2.dll b/WinKeyRecover/pidgenx2.dll
new file mode 100644
index 0000000..1fcb7f9
--- /dev/null
+++ b/WinKeyRecover/pidgenx2.dll