From e185f43bf363bee4dc1d390b50f16e06a26773d2 Mon Sep 17 00:00:00 2001
From: Frank Rojas <45807133+frankroj@users.noreply.github.com>
Date: Fri, 29 Dec 2023 18:11:04 -0500
Subject: [PATCH] USMT Refresh 10

---
 .../usmt/usmt-xml-elements-library.md         | 512 +++++++++---------
 1 file changed, 256 insertions(+), 256 deletions(-)

diff --git a/windows/deployment/usmt/usmt-xml-elements-library.md b/windows/deployment/usmt/usmt-xml-elements-library.md
index 2ed6433654..0db8752f52 100644
--- a/windows/deployment/usmt/usmt-xml-elements-library.md
+++ b/windows/deployment/usmt/usmt-xml-elements-library.md
@@ -26,19 +26,19 @@ The following table describes the XML elements and helper functions you can use
 
 | Elements A-K | Elements L-Z | Helper functions |
 |-----|----|-----|
-| [&lt;addObjects&gt;](#addobjects) <br/>[&lt;attributes&gt;](#attributes) <br/>[&lt;bytes&gt;](#bytes) <br/>[&lt;commandLine&gt;](#commandline) <br/>[&lt;component&gt;](#component) <br/>[&lt;condition&gt;](#condition) <br/>[&lt;conditions&gt;](#conditions) <br/>[&lt;content&gt;](#content) <br/>[&lt;contentModify&gt;](#contentmodify) <br/>[&lt;description&gt;](#description) <br/>[&lt;destinationCleanup&gt;](#destinationcleanup) <br/>[&lt;detect&gt;](#detect) <br/>[&lt;detects&gt;](#detects) <br/>[&lt;detection&gt;](#detection) <br/>[&lt;displayName&gt;](#displayname) <br/>[&lt;environment&gt;](#environment) <br/>[&lt;exclude&gt;](#exclude) <br/>[&lt;excludeAttributes&gt;](#excludeattributes) <br/>[&lt;extensions&gt;](#extensions) <br/>[&lt;extension&gt;](#extension) <br/>[&lt;externalProcess&gt;](#externalprocess) <br/>[&lt;icon&gt;](#icon) <br/>[&lt;include&gt;](#include) <br/>[&lt;includeAttribute&gt;](#includeattributes) | [&lt;library&gt;](#library) <br/>[&lt;location&gt;](#location) <br/>[&lt;locationModify&gt;](#locationmodify) <br/>[&lt;_locDefinition&gt;](#_locdefinition) <br/>[&lt;manufacturer&gt;](#manufacturer) <br/>[&lt;merge&gt;](#merge) <br/>[&lt;migration&gt;](#migration) <br/>[&lt;namedElements&gt;](#namedelements) <br/>[&lt;object&gt;](#object) <br/>[&lt;objectSet&gt;](#objectset) <br/>[&lt;path&gt;](#path) <br/>[&lt;paths&gt;](#paths) <br/>[&lt;pattern&gt;](#pattern) <br/>[&lt;processing&gt;](#processing) <br/>[&lt;plugin&gt;](#plugin) <br/>[&lt;role&gt;](#role) <br/>[&lt;rules&gt;](#rules) <br/>[&lt;script&gt;](#script) <br/>[&lt;text&gt;](#text) <br/>[&lt;unconditionalExclude&gt;](#unconditionalexclude) <br/>[&lt;variable&gt;](#variable) <br/>[&lt;version&gt;](#version) <br/>[&lt;windowsObjects&gt;](#windowsobjects) | [&lt;condition&gt; functions](#condition-functions) <br/>[&lt;content&gt; functions](#content-functions) <br/>[&lt;contentModify&gt; functions](#contentmodify-functions) <br/>[&lt;include&gt; and &lt;exclude&gt; filter functions](#include-and-exclude-filter-functions) <br/>[&lt;locationModify&gt; functions](#locationmodify-functions) <br/>[&lt;merge&gt; functions](#merge-functions) <br/>[&lt;script&gt; functions](#script-functions) <br/>[Internal USMT functions](#internal-usmt-functions) |
+| [\<addObjects\>](#addobjects) <br/>[\<attributes\>](#attributes) <br/>[\<bytes\>](#bytes) <br/>[\<commandLine\>](#commandline) <br/>[\<component\>](#component) <br/>[\<condition\>](#condition) <br/>[\<conditions\>](#conditions) <br/>[\<content\>](#content) <br/>[\<contentModify\>](#contentmodify) <br/>[\<description\>](#description) <br/>[\<destinationCleanup\>](#destinationcleanup) <br/>[\<detect\>](#detect) <br/>[\<detects\>](#detects) <br/>[\<detection\>](#detection) <br/>[\<displayName\>](#displayname) <br/>[\<environment\>](#environment) <br/>[\<exclude\>](#exclude) <br/>[\<excludeAttributes\>](#excludeattributes) <br/>[\<extensions\>](#extensions) <br/>[\<extension\>](#extension) <br/>[\<externalProcess\>](#externalprocess) <br/>[\<icon\>](#icon) <br/>[\<include\>](#include) <br/>[\<includeAttribute\>](#includeattributes) | [\<library\>](#library) <br/>[\<location\>](#location) <br/>[\<locationModify\>](#locationmodify) <br/>[\<_locDefinition\>](#_locdefinition) <br/>[\<manufacturer\>](#manufacturer) <br/>[\<merge\>](#merge) <br/>[\<migration\>](#migration) <br/>[\<namedElements\>](#namedelements) <br/>[\<object\>](#object) <br/>[\<objectSet\>](#objectset) <br/>[\<path\>](#path) <br/>[\<paths\>](#paths) <br/>[\<pattern\>](#pattern) <br/>[\<processing\>](#processing) <br/>[\<plugin\>](#plugin) <br/>[\<role\>](#role) <br/>[\<rules\>](#rules) <br/>[\<script\>](#script) <br/>[\<text\>](#text) <br/>[\<unconditionalExclude\>](#unconditionalexclude) <br/>[\<variable\>](#variable) <br/>[\<version\>](#version) <br/>[\<windowsObjects\>](#windowsobjects) | [\<condition\> functions](#condition-functions) <br/>[\<content\> functions](#content-functions) <br/>[\<contentModify\> functions](#contentmodify-functions) <br/>[\<include\> and \<exclude\> filter functions](#include-and-exclude-filter-functions) <br/>[\<locationModify\> functions](#locationmodify-functions) <br/>[\<merge\> functions](#merge-functions) <br/>[\<script\> functions](#script-functions) <br/>[Internal USMT functions](#internal-usmt-functions) |
 
 ## \<addObjects\>
 
-The **&lt;addObjects&gt;** element emulates the existence of one or more objects on the source computer. The child **&lt;object&gt;** elements provide the details of the emulated objects. If the content is a **&lt;script&gt;** element, the result of the invocation is an array of objects.
+The **\<addObjects\>** element emulates the existence of one or more objects on the source computer. The child **\<object\>** elements provide the details of the emulated objects. If the content is a **\<script\>** element, the result of the invocation is an array of objects.
 
 - **Number of occurrences:** unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Required child elements:** [&lt;object&gt;](#object) In addition, you must specify [&lt;location&gt;](#location) and [&lt;attribute&gt;](#attributes) as child elements of this **&lt;object&gt;** element.
+- **Required child elements:** [\<object\>](#object) In addition, you must specify [\<location\>](#location) and [\<attribute\>](#attributes) as child elements of this **\<object\>** element.
 
-- **Optional child elements:** [&lt;conditions&gt;](#conditions), [&lt;condition&gt;](#condition), [&lt;script&gt;](#script)
+- **Optional child elements:** [\<conditions\>](#conditions), [\<condition\>](#condition), [\<script\>](#script)
 
 Syntax:
 
@@ -52,25 +52,25 @@ The following example is from the `MigApp.xml` file:
 ```xml
 <addObjects>
    <object>
-      <location type="Registry">%HklmWowSoftware%\Microsoft\Office\12.0\Common\Migration\Office [UpgradeVersion]</location>
+      <location type="Registry">%HklmWowSoftware%\Microsoft\Office\16.0\Common\Migration\Office [UpgradeVersion]</location>
       <attributes>DWORD</attributes>
       <bytes>0B000000</bytes>
    </object>
    <object>
-      <location type="Registry">%HklmWowSoftware%\Microsoft\Office\12.0\Common\Migration\Office [Lang]</location>
+      <location type="Registry">%HklmWowSoftware%\Microsoft\Office\16.0\Common\Migration\Office [Lang]</location>
       <attributes>DWORD</attributes>
       <bytes>00000000</bytes>
    </object>
 </addObjects>
 ```
 
-## &lt;attributes&gt;
+## \<attributes\>
 
-The **&lt;attributes&gt;** element defines the attributes for a registry key or file.
+The **\<attributes\>** element defines the attributes for a registry key or file.
 
-- **Number of occurrences:** once for each [&lt;object&gt;](#object)
+- **Number of occurrences:** once for each [\<object\>](#object)
 
-- **Parent elements:** [&lt;object&gt;](#object)
+- **Parent elements:** [\<object\>](#object)
 
 - **Child elements:** none
 
@@ -94,13 +94,13 @@ The following example is from the `MigApp.xml` file:
 </object> 
 ```
 
-## &lt;bytes&gt;
+## \<bytes\>
 
-You must specify the **&lt;bytes&gt;** element only for files because, if **&lt;location&gt;** corresponds to a registry key or a directory, then **&lt;bytes&gt;** is ignored.
+You must specify the **\<bytes\>** element only for files because, if **\<location\>** corresponds to a registry key or a directory, then **\<bytes\>** is ignored.
 
 - **Number of occurrences:** zero or one
 
-- **Parent elements:** [&lt;object&gt;](#object)
+- **Parent elements:** [\<object\>](#object)
 
 - **Child elements:** none
 
@@ -113,8 +113,8 @@ Syntax:
 |Setting|Required?|Value|
 |--- |--- |--- |
 |string|No, default is No|Determines whether *Content* should be interpreted as a string or as bytes.|
-|expand|No (default = Yes|When the expand parameter is **Yes**, the content of the **&lt;bytes&gt;** element is first expanded in the context of the source computer and then interpreted.|
-|*Content*|Yes|Depends on the value of the string.<ul><li>When the string is **Yes**: the content of the **&lt;bytes&gt;** element is interpreted as a string.</li><li>When the string is **No**: the content of the **&lt;bytes&gt;** element is interpreted as bytes. Every two characters represent the hexadecimal value of a byte. For example, `616263` is the representation for the `abc` ANSI string. A complete representation of the UNICODE string `abc` including the string terminator would be: `6100620063000000`.</li></ul>|
+|expand|No (default = Yes|When the expand parameter is **Yes**, the content of the **\<bytes\>** element is first expanded in the context of the source computer and then interpreted.|
+|*Content*|Yes|Depends on the value of the string.<ul><li>When the string is **Yes**: the content of the **\<bytes\>** element is interpreted as a string.</li><li>When the string is **No**: the content of the **\<bytes\>** element is interpreted as bytes. Every two characters represent the hexadecimal value of a byte. For example, `616263` is the representation for the `abc` ANSI string. A complete representation of the UNICODE string `abc` including the string terminator would be: `6100620063000000`.</li></ul>|
 
 The following example is from the `MigApp.xml` file:
 
@@ -126,13 +126,13 @@ The following example is from the `MigApp.xml` file:
 </object> 
 ```
 
-## &lt;commandLine&gt;
+## \<commandLine\>
 
-You might want to use the **&lt;commandLine&gt;** element if you want to start or stop a service or application before or after you run the **ScanState** and **LoadState** tools.
+You might want to use the **\<commandLine\>** element if you want to start or stop a service or application before or after you run the **ScanState** and **LoadState** tools.
 
 - **Number of occurrences:** unlimited
 
-- **Parent elements:** [&lt;externalProcess&gt;](#externalprocess)
+- **Parent elements:** [\<externalProcess\>](#externalprocess)
 
 - **Child elements:** none
 
@@ -146,22 +146,22 @@ Syntax:
 |--- |--- |--- |
 |*CommandLineString*|Yes|A valid command line.|
 
-## &lt;component&gt;
+## \<component\>
 
-The **&lt;component&gt;** element is required in a custom .xml file. This element defines the most basic construct of a migration .xml file. For example, in the `MigApp.xml` file, **Microsoft Office 2016** is a component that contains another component, **Microsoft Office Access 2016**. You can use the child elements to define the component.
+The **\<component\>** element is required in a custom .xml file. This element defines the most basic construct of a migration .xml file. For example, in the `MigApp.xml` file, **Microsoft Office 2016** is a component that contains another component, **Microsoft Office Access 2016**. You can use the child elements to define the component.
 
-A component can be nested inside another component; that is, the **&lt;component&gt;** element can be a child of the **&lt;role&gt;** element within the **&lt;component&gt;** element in two cases:
+A component can be nested inside another component; that is, the **\<component\>** element can be a child of the **\<role\>** element within the **\<component\>** element in two cases:
 
-1. When the parent **&lt;component&gt;** element is a container
-1. If the child **&lt;component&gt;** element has the same role as the parent **&lt;component&gt;** element.
+1. When the parent **\<component\>** element is a container
+1. If the child **\<component\>** element has the same role as the parent **\<component\>** element.
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;migration&gt;](#migration), [&lt;role&gt;](#role)
+- **Parent elements:** [\<migration\>](#migration), [\<role\>](#role)
 
-- **Required child elements:** [&lt;role&gt;](#role), [&lt;displayName&gt;](#displayname)
+- **Required child elements:** [\<role\>](#role), [\<displayName\>](#displayname)
 
-- **Optional child elements:** [&lt;manufacturer&gt;](#manufacturer), [&lt;version&gt;](#version), [&lt;description&gt;](#description), [&lt;paths&gt;](#paths), [&lt;icon&gt;](#icon), [&lt;environment&gt;](#environment), [&lt;extensions&gt;](#extensions)
+- **Optional child elements:** [\<manufacturer\>](#manufacturer), [\<version\>](#version), [\<description\>](#description), [\<paths\>](#paths), [\<icon\>](#icon), [\<environment\>](#environment), [\<extensions\>](#extensions)
 
 Syntax:
 
@@ -174,25 +174,25 @@ hidden="Yes|No">
 |Setting|Required?|Value|
 |--- |--- |--- |
 | type | Yes | You can use the following to group settings, and define the type of the component.<ul><li>**System:** Operating system settings. All Windows components are defined by this type. <br/>When **type="System"** and **defaultSupported="FALSE"**, the settings don't migrate unless there's an equivalent component in the .xml files that is specified on the `LoadState.exe` command line. For example, the default `MigSys.xml` file contains components with **type="System"** and **defaultSupported="FALSE"**. If you specify this file on the `ScanState.exe` command line, you must also specify the file on the `LoadState.exe` command line for the settings to migrate. The file must be specified because the `LoadState.exe` tool must detect an equivalent component. That is, the component must have the same migration urlid of the .xml file and an identical display name. Otherwise, the **LoadState** tool doesn't migrate those settings from the store. This setting is helpful because a store can be used for destination computers that are the same or different version of Windows as the source computer.</li><li>**Application:** Settings for an application.</li><li>**Device:** Settings for a device.</li><li>**Documents:** Specifies files.</li></ul> |
-| context | No <br/>Default = UserAndSystem | Defines the scope of this parameter; that is, whether to process this component in the context of the specific user, across the entire operating system, or both. <br/>The largest possible scope is set by the **&lt;component&gt;** element. For example, if a **&lt;component&gt;** element has a context of **User** and a **&lt;rules&gt;** element had a context of **UserAndSystem**, then the **&lt;rules&gt;** element would act as though it has a context of **User**. If a **&lt;rules&gt;** element has a context of **System**, it would act as though the **&lt;rules&gt;** element isn't there. <ul><li>**User**: Evaluates the component for each user.</li><li>**System**: Evaluates the component only once for the system.</li><li>**UserAndSystem**: Evaluates the component for the entire operating system and each user.</li></ul> |
+| context | No <br/>Default = UserAndSystem | Defines the scope of this parameter; that is, whether to process this component in the context of the specific user, across the entire operating system, or both. <br/>The largest possible scope is set by the **\<component\>** element. For example, if a **\<component\>** element has a context of **User** and a **\<rules\>** element had a context of **UserAndSystem**, then the **\<rules\>** element would act as though it has a context of **User**. If a **\<rules\>** element has a context of **System**, it would act as though the **\<rules\>** element isn't there. <ul><li>**User**: Evaluates the component for each user.</li><li>**System**: Evaluates the component only once for the system.</li><li>**UserAndSystem**: Evaluates the component for the entire operating system and each user.</li></ul> |
 | defaultSupported | No <br/>(default = TRUE) | Can be any of **TRUE**, **FALSE**, **YES**, or **NO**. If this parameter is **FALSE** (or **NO**), the component isn't migrated unless there's an equivalent component on the destination computer. <br/>When **type="System"** and **defaultSupported="FALSE"**, the settings aren't migrated unless there's an equivalent component in the .xml files that are specified on the `LoadState.exe` command line. For example, the default `MigSys.xml` file contains components with **type="System"** and **defaultSupported="FALSE"**. If you specify this file on the `ScanState.exe` command line, you must also specify the file on the `LoadState.exe` command line for the settings to migrate. The file has to be specified in both command lines because the **LoadState** tool must detect an equivalent component. That is, the component must have the same migration urlid of the .xml file and an identical display name or the **LoadState** tool doesn't migrate those settings from the store. This setting is helpful because a store can be used for destination computers that are the same or different version of Windows as the source computer. |
 | hidden |   | This parameter is for internal USMT use only. |
 
 For an example, see any of the default migration .xml files.
 
-## &lt;condition&gt;
+## \<condition\>
 
-Although the **&lt;condition&gt;** element under the **&lt;detect&gt;**, **&lt;objectSet&gt;**, and **&lt;addObjects&gt;** elements is still supported, Microsoft recommends to no longer use the **&lt;condition&gt;** element because it might be deprecated in future versions of USMT. If the **&lt;condition&gt;** element is deprecated, it would require a rewrite of any scripts that use the **&lt;condition&gt;** element. Instead, if you need to use a condition within the **&lt;objectSet&gt;** and **&lt;addObjects&gt;** elements, Microsoft recommends using the more powerful **[&lt;conditions&gt;](#conditions)** element. The **&lt;conditions&gt;** element allows for formulation of complex Boolean statements.
+Although the **\<condition\>** element under the **\<detect\>**, **\<objectSet\>**, and **\<addObjects\>** elements is still supported, Microsoft recommends to no longer use the **\<condition\>** element because it might be deprecated in future versions of USMT. If the **\<condition\>** element is deprecated, it would require a rewrite of any scripts that use the **\<condition\>** element. Instead, if you need to use a condition within the **\<objectSet\>** and **\<addObjects\>** elements, Microsoft recommends using the more powerful **[\<conditions\>](#conditions)** element. The **\<conditions\>** element allows for formulation of complex Boolean statements.
 
-The **&lt;condition&gt;** element has a Boolean result. You can use this element to specify the conditions in which the parent element is evaluated. If any of the present conditions return **FALSE**, the parent element isn't be evaluated.
+The **\<condition\>** element has a Boolean result. You can use this element to specify the conditions in which the parent element is evaluated. If any of the present conditions return **FALSE**, the parent element isn't be evaluated.
 
 - **Number of occurrences:** unlimited.
 
-- **Parent elements:** [&lt;conditions&gt;](#conditions), [&lt;detect&gt;](#detect), [&lt;objectSet&gt;](#objectset), [&lt;addObjects&gt;](#addobjects)
+- **Parent elements:** [\<conditions\>](#conditions), [\<detect\>](#detect), [\<objectSet\>](#objectset), [\<addObjects\>](#addobjects)
 
 - **Child elements:** none
 
-- **Helper functions:** You can use the following [&lt;condition&gt; functions](#condition-functions) with this element: `DoesOSMatch`, `IsNative64Bit()`, `IsOSLaterThan`, `IsOSEarlierThan`, `DoesObjectExist`, `DoesFileVersionMatch`, `IsFileVersionAbove`, `IsFileVersionBelow`, `IsSystemContext`, `DoesStringContentEqual`, `DoesStringContentContain`, `IsSameObject`, `IsSameContent`, and `IsSameStringContent`.
+- **Helper functions:** You can use the following [\<condition\> functions](#condition-functions) with this element: `DoesOSMatch`, `IsNative64Bit()`, `IsOSLaterThan`, `IsOSEarlierThan`, `DoesObjectExist`, `DoesFileVersionMatch`, `IsFileVersionAbove`, `IsFileVersionBelow`, `IsSystemContext`, `DoesStringContentEqual`, `DoesStringContentContain`, `IsSameObject`, `IsSameContent`, and `IsSameStringContent`.
 
 Syntax:
 
@@ -205,7 +205,7 @@ Syntax:
 |negation|No <br/>Default = No|**"Yes"** reverses the True/False value of the condition.|
 |*ScriptName*|Yes|A script that is defined within this migration section.|
 
-For example, in the following code sample, the **&lt;condition&gt;** elements, **A** and **B**, are joined together by the **AND** operator because they are in separate **&lt;conditions&gt;** sections:
+For example, in the following code sample, the **\<condition\>** elements, **A** and **B**, are joined together by the **AND** operator because they are in separate **\<conditions\>** sections:
 
 ```xml
 <detection>
@@ -218,7 +218,7 @@ For example, in the following code sample, the **&lt;condition&gt;** elements, *
 </detection>
 ```
 
-However, in the following code sample, the **&lt;condition&gt;** elements, **A** and **B**, are joined together by the **OR** operator because they are in the same **&lt;conditions&gt;** section.
+However, in the following code sample, the **\<condition\>** elements, **A** and **B**, are joined together by the **OR** operator because they are in the same **\<conditions\>** section.
 
 ```xml
 <detection>
@@ -229,9 +229,9 @@ However, in the following code sample, the **&lt;condition&gt;** elements, **A**
 </detection>
 ```
 
-### &lt;condition&gt; functions
+### \<condition\> functions
 
-The **&lt;condition&gt;** functions return a Boolean value. You can use these elements in **&lt;addObjects&gt;** conditions.
+The **\<condition\>** functions return a Boolean value. You can use these elements in **\<addObjects\>** conditions.
 
 - [Operating system version functions](#operating-system-version-functions)
 
@@ -247,7 +247,7 @@ The **&lt;condition&gt;** functions return a Boolean value. You can use these el
 
     |Setting|Required?|Value|
     |--- |--- |--- |
-    |*OSType*|Yes|The only valid value for this setting is **NT**. Note, however, that you must set this setting for the **&lt;condition&gt;** functions to work correctly.|
+    |*OSType*|Yes|The only valid value for this setting is **NT**. Note, however, that you must set this setting for the **\<condition\>** functions to work correctly.|
     |*OSVersion*|Yes|The major version, minor version, build number and corrected service diskette version separated by periods. For example, `5.0.2600.Service Pack 1`. You can also specify partial specification of the version with a pattern such as `5.0.*`.|
 
   For example:
@@ -426,15 +426,15 @@ The **&lt;condition&gt;** functions return a Boolean value. You can use these el
     |*ObjectType2*|Yes|Defines the type of the second object. Can be File or Registry.|
     |*EncodedLocation2*|Yes|The **[encoded location](#specifying-locations)** for the second object. You can specify environment variables.|
 
-## &lt;conditions&gt;
+## \<conditions\>
 
-The **&lt;conditions&gt;** element returns a Boolean result that is used to specify the conditions in which the parent element is evaluated. USMT evaluates the child elements, and then joins their results using the operators **AND** or **OR** according to the operation parameter.
+The **\<conditions\>** element returns a Boolean result that is used to specify the conditions in which the parent element is evaluated. USMT evaluates the child elements, and then joins their results using the operators **AND** or **OR** according to the operation parameter.
 
-- **Number of occurrences:** Unlimited inside another **&lt;conditions&gt;** element. Limited to one occurrence in [&lt;detection&gt;](#detection), [&lt;rules&gt;](#rules), [&lt;addObjects&gt;](#addobjects), and [&lt;objectSet&gt;](#objectset)
+- **Number of occurrences:** Unlimited inside another **\<conditions\>** element. Limited to one occurrence in [\<detection\>](#detection), [\<rules\>](#rules), [\<addObjects\>](#addobjects), and [\<objectSet\>](#objectset)
 
-- **Parent elements:** [&lt;conditions&gt;](#conditions), [&lt;detection&gt;](#detection), [&lt;environment&gt;](#environment), [&lt;rules&gt;](#rules), [&lt;addObjects&gt;](#addobjects), and [&lt;objectSet&gt;](#objectset)
+- **Parent elements:** [\<conditions\>](#conditions), [\<detection\>](#detection), [\<environment\>](#environment), [\<rules\>](#rules), [\<addObjects\>](#addobjects), and [\<objectSet\>](#objectset)
 
-- **Child elements:** [&lt;conditions&gt;](#conditions), [&lt;condition&gt;](#condition)
+- **Child elements:** [\<conditions\>](#conditions), [\<condition\>](#condition)
 
 Syntax:
 
@@ -460,17 +460,17 @@ The following example is from the `MigApp.xml` file:
 </environment>
 ```
 
-## &lt;content&gt;
+## \<content\>
 
-You can use the **&lt;content&gt;** element to specify a list of object patterns to obtain an object set from the source computer. Each **&lt;objectSet&gt;** within a **&lt;content&gt;** element is evaluated. For each resulting object pattern list, the objects that match it are enumerated and their content is filtered by the filter parameter. The resulting string array is the output for the **&lt;content&gt;** element. The filter script returns an array of locations. The parent **&lt;objectSet&gt;** element can contain multiple child **&lt;content&gt;** elements.
+You can use the **\<content\>** element to specify a list of object patterns to obtain an object set from the source computer. Each **\<objectSet\>** within a **\<content\>** element is evaluated. For each resulting object pattern list, the objects that match it are enumerated and their content is filtered by the filter parameter. The resulting string array is the output for the **\<content\>** element. The filter script returns an array of locations. The parent **\<objectSet\>** element can contain multiple child **\<content\>** elements.
 
 - **Number of occurrences:** unlimited
 
-- **Parent elements:** [&lt;objectSet&gt;](#objectset)
+- **Parent elements:** [\<objectSet\>](#objectset)
 
-- **Child elements:** [&lt;objectSet&gt;](#objectset)
+- **Child elements:** [\<objectSet\>](#objectset)
 
-- **Helper functions:** You can use the following [&lt;content&gt; functions](#content-functions) with this element: `ExtractSingleFile`, `ExtractMultipleFiles`, and `ExtractDirectory`.
+- **Helper functions:** You can use the following [\<content\> functions](#content-functions) with this element: `ExtractSingleFile`, `ExtractMultipleFiles`, and `ExtractDirectory`.
 
 Syntax:
 
@@ -481,11 +481,11 @@ Syntax:
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-|filter|Yes|A script followed by any number of string arguments that are separated by a comma and enclosed in parenthesis. For example, `MyScripts.AScript ("Arg1","Arg2")`. <br/>The script is called for each object that is enumerated by the object sets in the **&lt;include&gt;** rule. The filter script returns a Boolean value. If the return value is **TRUE**, the object is migrated. If it's **FALSE**, it isn't migrated.|
+|filter|Yes|A script followed by any number of string arguments that are separated by a comma and enclosed in parenthesis. For example, `MyScripts.AScript ("Arg1","Arg2")`. <br/>The script is called for each object that is enumerated by the object sets in the **\<include\>** rule. The filter script returns a Boolean value. If the return value is **TRUE**, the object is migrated. If it's **FALSE**, it isn't migrated.|
 
-### &lt;content&gt; functions
+### \<content\> functions
 
-The following functions generate patterns out of the content of an object. These functions are called for every object that the parent **&lt;ObjectSet&gt;** element is enumerating.
+The following functions generate patterns out of the content of an object. These functions are called for every object that the parent **\<ObjectSet\>** element is enumerating.
 
 - **ExtractSingleFile**
 
@@ -512,7 +512,7 @@ The following functions generate patterns out of the content of an object. These
 
 - **ExtractMultipleFiles**
 
-    The **ExtractMultipleFiles** function returns multiple patterns, one for each file that is found in the content of the given registry value. If the registry value is a **MULTI-SZ**, the **MULTI-SZ** separator is considered a separator by default. therefore, for **MULTI-SZ**, the **&lt;Separators&gt;** argument must be **NULL**.
+    The **ExtractMultipleFiles** function returns multiple patterns, one for each file that is found in the content of the given registry value. If the registry value is a **MULTI-SZ**, the **MULTI-SZ** separator is considered a separator by default. therefore, for **MULTI-SZ**, the **\<Separators\>** argument must be **NULL**.
 
     The returned patterns are the encoded locations for files that must exist on the source computer. If the specification is correct in the registry value but the file doesn't exist, it isn't included in the resulting list.
 
@@ -547,17 +547,17 @@ The following functions generate patterns out of the content of an object. These
   </objectSet>
   ```
 
-## &lt;contentModify&gt;
+## \<contentModify\>
 
-The **&lt;contentModify&gt;** element modifies the content of an object before the object is written to the destination computer. For each **&lt;contentModify&gt;** element, there can be multiple **&lt;objectSet&gt;** elements. This element returns the new content of the object that is being processed.
+The **\<contentModify\>** element modifies the content of an object before the object is written to the destination computer. For each **\<contentModify\>** element, there can be multiple **\<objectSet\>** elements. This element returns the new content of the object that is being processed.
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Required child elements:** [&lt;objectSet&gt;](#objectset)
+- **Required child elements:** [\<objectSet\>](#objectset)
 
-- **Helper functions**: You can use the following [&lt;contentModify&gt; functions](#contentmodify-functions) with this element: **ConvertToDWORD**, **ConvertToString**, **ConvertToBinary**, **KeepExisting**, **OffsetValue**, **SetValueByTable**, **MergeMultiSzContent**, and **MergeDelimitedContent**.
+- **Helper functions**: You can use the following [\<contentModify\> functions](#contentmodify-functions) with this element: **ConvertToDWORD**, **ConvertToString**, **ConvertToBinary**, **KeepExisting**, **OffsetValue**, **SetValueByTable**, **MergeMultiSzContent**, and **MergeDelimitedContent**.
 
 Syntax:
 
@@ -570,13 +570,13 @@ Syntax:
 |--- |--- |--- |
 |script|Yes|A script followed by any number of string arguments that are separated by a comma and enclosed in parenthesis. For example, `MyScripts.AScript ("Arg1","Arg2").` <br/><br/>The script is called for each object that is enumerated by the object sets in the include rule. The filter script returns a Boolean value. If the return value is **TRUE**, the object is migrated. If it's **FALSE**, it isn't migrated.|
 
-### &lt;contentModify&gt; functions
+### \<contentModify\> functions
 
-The following functions change the content of objects as they're migrated. These functions are called for every object that the parent **&lt;ObjectSet&gt;** element is enumerating.
+The following functions change the content of objects as they're migrated. These functions are called for every object that the parent **\<ObjectSet\>** element is enumerating.
 
 - **ConvertToDWORD**
 
-    The **ConvertToDWORD** function converts the content of registry values that are enumerated by the parent **&lt;ObjectSet&gt;** element to a DWORD. For example, **ConvertToDWORD** converts the string `"1"` to the DWORD `0x00000001`. If the conversion fails, then the value of **DefaultValueOnError** is applied.
+    The **ConvertToDWORD** function converts the content of registry values that are enumerated by the parent **\<ObjectSet\>** element to a DWORD. For example, **ConvertToDWORD** converts the string `"1"` to the DWORD `0x00000001`. If the conversion fails, then the value of **DefaultValueOnError** is applied.
 
     Syntax: `ConvertToDWORD(DefaultValueOnError)`
 
@@ -586,7 +586,7 @@ The following functions change the content of objects as they're migrated. These
 
 - **ConvertToString**
 
-    The **ConvertToString** function converts the content of registry values that match the parent **&lt;ObjectSet&gt;** element to a string. For example, it converts the DWORD `0x00000001` to the string **"1"**. If the conversion fails, then the value of **DefaultValueOnError** is applied.
+    The **ConvertToString** function converts the content of registry values that match the parent **\<ObjectSet\>** element to a string. For example, it converts the DWORD `0x00000001` to the string **"1"**. If the conversion fails, then the value of **DefaultValueOnError** is applied.
 
     Syntax: `ConvertToString(DefaultValueOnError)`
 
@@ -606,7 +606,7 @@ The following functions change the content of objects as they're migrated. These
 
 - **ConvertToBinary**
 
-    The **ConvertToBinary** function converts the content of registry values that match the parent **&lt;ObjectSet&gt;** element to a binary type.
+    The **ConvertToBinary** function converts the content of registry values that match the parent **\<ObjectSet\>** element to a binary type.
 
     Syntax: `ConvertToBinary ()`
 
@@ -640,11 +640,11 @@ The following functions change the content of objects as they're migrated. These
 
     |Setting|Required?|Value|
     |--- |--- |--- |
-    | *OptionString* | Yes | *OptionString* can be **Security**, **TimeFields**, or **FileAttrib**:*Letter*. You can specify one of each type of *OptionStrings*. Don't specify multiple *OptionStrings* with the same value. If you do, the right-most option of that type is kept. For example, don't specify **("FileAttrib:H", "FileAttrib:R")** because only Read-only is evaluated. Instead specify **("FileAttrib:HR")** and both Hidden and Read-only attributes are kept on the destination computer. <ul><li>**Security**: Keeps the destination object's security descriptor if it exists.</li><li>**TimeFields**: Keeps the destination object's time stamps. This parameter is for files only.</li><li>**FileAttrib:&lt;Letter&gt;**: Keeps the destination object's attribute value, either **ON** or **OFF**, for the specified set of file attributes. This parameter is for files only. The following are case-insensitive, but USMT will ignore any values that are invalid, repeated, or if there's a space after **FileAttrib:**. You can specify any combination of the following attributes: <ul><li>**A** = Archive</li><li>**C** = Compressed</li><li>**E** = Encrypted</li><li>**H** = Hidden</li><li>**I** = Not Content Indexed</li><li>**O** = Offline</li><li>**R** = Read-Only</li><li>**S** = System</li><li>**T** = Temporary</li></ul></li></ul> |
+    | *OptionString* | Yes | *OptionString* can be **Security**, **TimeFields**, or **FileAttrib**:*Letter*. You can specify one of each type of *OptionStrings*. Don't specify multiple *OptionStrings* with the same value. If you do, the right-most option of that type is kept. For example, don't specify **("FileAttrib:H", "FileAttrib:R")** because only Read-only is evaluated. Instead specify **("FileAttrib:HR")** and both Hidden and Read-only attributes are kept on the destination computer. <ul><li>**Security**: Keeps the destination object's security descriptor if it exists.</li><li>**TimeFields**: Keeps the destination object's time stamps. This parameter is for files only.</li><li>**FileAttrib:\<Letter\>**: Keeps the destination object's attribute value, either **ON** or **OFF**, for the specified set of file attributes. This parameter is for files only. The following are case-insensitive, but USMT will ignore any values that are invalid, repeated, or if there's a space after **FileAttrib:**. You can specify any combination of the following attributes: <ul><li>**A** = Archive</li><li>**C** = Compressed</li><li>**E** = Encrypted</li><li>**H** = Hidden</li><li>**I** = Not Content Indexed</li><li>**O** = Offline</li><li>**R** = Read-Only</li><li>**S** = System</li><li>**T** = Temporary</li></ul></li></ul> |
 
 - **MergeMultiSzContent**
 
-    The **MergeMultiSzContent** function merges the **MULTI-SZ** content of the registry values that are enumerated by the parent **&lt;ObjectSet&gt;** element with the content of the equivalent registry values that already exist on the destination computer. `Instruction` and `String` either remove or add content to the resulting **MULTI-SZ**. Duplicate elements are removed.
+    The **MergeMultiSzContent** function merges the **MULTI-SZ** content of the registry values that are enumerated by the parent **\<ObjectSet\>** element with the content of the equivalent registry values that already exist on the destination computer. `Instruction` and `String` either remove or add content to the resulting **MULTI-SZ**. Duplicate elements are removed.
 
     Syntax: `MergeMultiSzContent (Instruction,String,Instruction,String,…)`
 
@@ -655,7 +655,7 @@ The following functions change the content of objects as they're migrated. These
 
 - **MergeDelimitedContent**
 
-    The **MergeDelimitedContent** function merges the content of the registry values that are enumerated by the parent **&lt;ObjectSet&gt;** element with the content of the equivalent registry values that already exist on the destination computer. The content is considered a list of elements separated by one of the characters in the Delimiters parameter. Duplicate elements are removed.
+    The **MergeDelimitedContent** function merges the content of the registry values that are enumerated by the parent **\<ObjectSet\>** element with the content of the equivalent registry values that already exist on the destination computer. The content is considered a list of elements separated by one of the characters in the Delimiters parameter. Duplicate elements are removed.
 
     Syntax: `MergeDelimitedContent(Delimiters,Instruction,String,…)`
 
@@ -665,13 +665,13 @@ The following functions change the content of objects as they're migrated. These
     | *Instruction* | Yes | Can be one of the following values: <ul><li>**Add**: Adds *String* to the resulting MULTI-SZ if it isn't already there.</li><li>**Remove**: Removes *String* from the resulting MULTI-SZ.</li></ul> |
     | *String* | Yes | The string to be added or removed. |
 
-## &lt;description&gt;
+## \<description\>
 
-The **&lt;description&gt;** element defines a description for the component but doesn't affect the migration.
+The **\<description\>** element defines a description for the component but doesn't affect the migration.
 
 - **Number of occurrences:** zero or one
 
-- **Parent elements:** [&lt;component&gt;](#component)
+- **Parent elements:** [\<component\>](#component)
 
 - **Child elements:** none
 
@@ -685,26 +685,26 @@ Syntax:
 |--- |--- |--- |
 |*ComponentDescription*|Yes|The description of the component.|
 
-The following code sample shows how the &lt;description&gt; element defines the "My custom component" description:
+The following code sample shows how the \<description\> element defines the "My custom component" description:
 
 ```xml
 <description>My custom component<description>
 ```
 
-## &lt;destinationCleanup&gt;
+## \<destinationCleanup\>
 
-The **&lt;destinationCleanup&gt;** element deletes objects, such as files and registry keys, from the destination computer before applying the objects from the source computer. This element is evaluated only when the **LoadState** tool is run on the destination computer. That is, this element is ignored by the **ScanState** tool.
+The **\<destinationCleanup\>** element deletes objects, such as files and registry keys, from the destination computer before applying the objects from the source computer. This element is evaluated only when the **LoadState** tool is run on the destination computer. That is, this element is ignored by the **ScanState** tool.
 
 > [!IMPORTANT]
 > Use this option with extreme caution because it will delete objects from the destination computer.
 
-For each **&lt;destinationCleanup&gt;** element, there can be multiple **&lt;objectSet&gt;** elements. A common use for this element is if there's a missing registry key on the source computer and you want to ensure that a component is migrated. In this case, you can delete all of the component's registry keys before migrating the source registry keys. Deleting all of the component's registry keys ensures that if there's a missing key on the source computer, it will also be missing on the destination computer.
+For each **\<destinationCleanup\>** element, there can be multiple **\<objectSet\>** elements. A common use for this element is if there's a missing registry key on the source computer and you want to ensure that a component is migrated. In this case, you can delete all of the component's registry keys before migrating the source registry keys. Deleting all of the component's registry keys ensures that if there's a missing key on the source computer, it will also be missing on the destination computer.
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Child elements:** [&lt;objectSet&gt;](#objectset) (The destination computer deletes all child elements.)
+- **Child elements:** [\<objectSet\>](#objectset) (The destination computer deletes all child elements.)
 
 Syntax:
 
@@ -728,21 +728,21 @@ For example:
 </destinationCleanup>
 ```
 
-## &lt;detect&gt;
+## \<detect\>
 
-Although the **&lt;detect&gt;** element is still supported, Microsoft recommends no longer using the **&lt;detect&gt;** element because it might be deprecated in future versions of USMT. If the **&lt;detect&gt;** element is deprecated, it would require a rewrite of any scripts that use the **&lt;detect&gt;** element. Instead, Microsoft recommends using the **[&lt;detection&gt;](#detection)** element. The **&lt;detection&gt;** element allows for more clearly formulated complex Boolean statements
+Although the **\<detect\>** element is still supported, Microsoft recommends no longer using the **\<detect\>** element because it might be deprecated in future versions of USMT. If the **\<detect\>** element is deprecated, it would require a rewrite of any scripts that use the **\<detect\>** element. Instead, Microsoft recommends using the **[\<detection\>](#detection)** element. The **\<detection\>** element allows for more clearly formulated complex Boolean statements
 
-The **&lt;detect&gt;** element can be used to determine if the component is present on a system. If all child **&lt;detect&gt;** elements within a **&lt;detect&gt;** element resolve to **TRUE**, then the **&lt;detect&gt;** element resolves to **TRUE**. If any child **&lt;detect&gt;** elements resolve to **FALSE**, then their parent **&lt;detect&gt;** element resolves to **FALSE**. If there's no **&lt;detect&gt;** element section, then USMT assumes that the component is present.
+The **\<detect\>** element can be used to determine if the component is present on a system. If all child **\<detect\>** elements within a **\<detect\>** element resolve to **TRUE**, then the **\<detect\>** element resolves to **TRUE**. If any child **\<detect\>** elements resolve to **FALSE**, then their parent **\<detect\>** element resolves to **FALSE**. If there's no **\<detect\>** element section, then USMT assumes that the component is present.
 
-For each **&lt;detect&gt;** element there can be multiple child **&lt;condition&gt;** or **&lt;objectSet&gt;** elements, which are logically joined by an **OR** operator. If at least one **&lt;condition&gt;** or **&lt;objectSet&gt;** element evaluates to **TRUE**, then the **&lt;detect&gt;** element evaluates to **TRUE**.
+For each **\<detect\>** element there can be multiple child **\<condition\>** or **\<objectSet\>** elements, which are logically joined by an **OR** operator. If at least one **\<condition\>** or **\<objectSet\>** element evaluates to **TRUE**, then the **\<detect\>** element evaluates to **TRUE**.
 
 - **Number of occurrences:** unlimited
 
-- **Parent elements:** [&lt;detects&gt;](#detects), [&lt;namedElements&gt;](#namedelements)
+- **Parent elements:** [\<detects\>](#detects), [\<namedElements\>](#namedelements)
 
-- **Required child elements:** [&lt;condition&gt;](#condition)
+- **Required child elements:** [\<condition\>](#condition)
 
-- **Optional child elements:** [&lt;objectSet&gt;](#objectset)
+- **Optional child elements:** [\<objectSet\>](#objectset)
 
 Syntax:
 
@@ -753,16 +753,16 @@ Syntax:
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-| name | Yes, when **&lt;detect&gt;** is a child to **&lt;namedElements&gt;** <br/>No, when **&lt;detect&gt;** is a child to &lt;detects&gt; | When *ID* is specified, any child elements aren't processed. Instead, any other **&lt;detect&gt;** elements with the same name that are declared within the **&lt;namedElements&gt;** element are processed. |
-| context | No <br/>(default = UserAndSystem) | Defines the scope of this parameter, which is whether to process this component in the context of the specific user, across the entire operating system, or both. <br/>The largest possible scope is set by the component element. For example, if a **&lt;component&gt;** element has a context of **User**, and a **&lt;rules&gt;** element had a context of **UserAndSystem**, then the **&lt;rules&gt;** element would act as though it had a context of **User**. If the **&lt;rules&gt;** element had a context of **System**, it would act as though the **&lt;rules&gt;** element weren't there. <ul><li>**User**: Evaluates the variables for each user.</li><li>**System**: Evaluates the variables only once for the system.</li><li>**UserAndSystem**: Evaluates the variables for the entire operating system and each user.</li></ul> |
+| name | Yes, when **\<detect\>** is a child to **\<namedElements\>** <br/>No, when **\<detect\>** is a child to \<detects\> | When *ID* is specified, any child elements aren't processed. Instead, any other **\<detect\>** elements with the same name that are declared within the **\<namedElements\>** element are processed. |
+| context | No <br/>(default = UserAndSystem) | Defines the scope of this parameter, which is whether to process this component in the context of the specific user, across the entire operating system, or both. <br/>The largest possible scope is set by the component element. For example, if a **\<component\>** element has a context of **User**, and a **\<rules\>** element had a context of **UserAndSystem**, then the **\<rules\>** element would act as though it had a context of **User**. If the **\<rules\>** element had a context of **System**, it would act as though the **\<rules\>** element weren't there. <ul><li>**User**: Evaluates the variables for each user.</li><li>**System**: Evaluates the variables only once for the system.</li><li>**UserAndSystem**: Evaluates the variables for the entire operating system and each user.</li></ul> |
 
-For examples, see the examples for [&lt;detection&gt;](#detection).
+For examples, see the examples for [\<detection\>](#detection).
 
-## &lt;detects&gt;
+## \<detects\>
 
-Although the **&lt;detects&gt;** element is still supported, Microsoft recommends no longer using the **&lt;detects&gt;** element because it might be deprecated in future versions of USMT. If the **&lt;detects&gt;** element is deprecated, it would require a rewrite of any scripts that use the **&lt;detects&gt;** element. Instead, Microsoft recommends using the **[&lt;detection&gt;](#detection)** element if the parent element is **&lt;role&gt;** or **&lt;namedElements&gt;**, or use the **[&lt;conditions&gt;](#conditions)** element if the parent element is **&lt;rules&gt;**. The **&lt;detection&gt;** element allows for more clearly formulated complex Boolean statements and the **&lt;conditions&gt;** element allows for formulation of complex Boolean statements.
+Although the **\<detects\>** element is still supported, Microsoft recommends no longer using the **\<detects\>** element because it might be deprecated in future versions of USMT. If the **\<detects\>** element is deprecated, it would require a rewrite of any scripts that use the **\<detects\>** element. Instead, Microsoft recommends using the **[\<detection\>](#detection)** element if the parent element is **\<role\>** or **\<namedElements\>**, or use the **[\<conditions\>](#conditions)** element if the parent element is **\<rules\>**. The **\<detection\>** element allows for more clearly formulated complex Boolean statements and the **\<conditions\>** element allows for formulation of complex Boolean statements.
 
-The **&lt;detects&gt;** element is a container for one or more **&lt;detect&gt;** elements. If all of the child **&lt;detect&gt;** elements within a **&lt;detects&gt;** element resolve to **TRUE**, then **&lt;detects&gt;** resolves to **TRUE**. If any of the child **&lt;detect&gt;** elements resolve to **FALSE**, then **&lt;detects&gt;** resolves to **FALSE**. If you don't want to write the **&lt;detects&gt;** elements within a component, then you can create the **&lt;detects&gt;** element under the **&lt;namedElements&gt;** element, and then refer to it. If there's no **&lt;detects&gt;** element section, then USMT assumes that the component is present. The results from each **&lt;detects&gt;** element are joined together by the **OR** operator to form the rule used to detect the parent element.
+The **\<detects\>** element is a container for one or more **\<detect\>** elements. If all of the child **\<detect\>** elements within a **\<detects\>** element resolve to **TRUE**, then **\<detects\>** resolves to **TRUE**. If any of the child **\<detect\>** elements resolve to **FALSE**, then **\<detects\>** resolves to **FALSE**. If you don't want to write the **\<detects\>** elements within a component, then you can create the **\<detects\>** element under the **\<namedElements\>** element, and then refer to it. If there's no **\<detects\>** element section, then USMT assumes that the component is present. The results from each **\<detects\>** element are joined together by the **OR** operator to form the rule used to detect the parent element.
 
 Syntax:
 
@@ -773,14 +773,14 @@ Syntax:
 
 - **Number of occurrences:** Unlimited.
 
-- **Parent elements:** [&lt;role&gt;](#role), [&lt;rules&gt;](#rules), [&lt;namedElements&gt;](#namedelements)
+- **Parent elements:** [\<role\>](#role), [\<rules\>](#rules), [\<namedElements\>](#namedelements)
 
-- **Required child elements:** [&lt;detect&gt;](#detect)
+- **Required child elements:** [\<detect\>](#detect)
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-| name | Yes, when &lt;detects&gt; is a child to **&lt;namedElements&gt;** <br/>No, when &lt;detects&gt; is a child to **&lt;role&gt;** or **&lt;rules&gt;** | When *ID* is specified, no child **&lt;detect&gt;** elements are processed. Instead, any other **&lt;detects&gt;** elements with the same name that are declared within the **&lt;namedElements&gt;** element are processed. |
-| context | No <br/>(default = UserAndSystem) | Defines the scope of this parameter: whether to process this component in the context of the specific user, across the entire operating system, or both. <br/>The largest possible scope is set by the **&lt;component element&gt;**. For example, if a **&lt;component&gt;** element has a context of **User** and a **&lt;rules&gt;** element had a context of **UserAndSystem**, then the **&lt;rules&gt;** element would act as though it had a context of **User**. If the **&lt;rules&gt;** element had a context of **System**, it would act as though the **&lt;rules&gt;** element weren't there. <ul><li>**User**: Evaluates the variables for each user.</li><li>**System**: Evaluates the variables only once for the system.</li><li>**UserAndSystem**: Evaluates the variables for the entire operating system and each user.</li></ul> <br/>The context parameter is ignored for **&lt;detects&gt;** elements that are inside **&lt;rules&gt;** elements. |
+| name | Yes, when \<detects\> is a child to **\<namedElements\>** <br/>No, when \<detects\> is a child to **\<role\>** or **\<rules\>** | When *ID* is specified, no child **\<detect\>** elements are processed. Instead, any other **\<detects\>** elements with the same name that are declared within the **\<namedElements\>** element are processed. |
+| context | No <br/>(default = UserAndSystem) | Defines the scope of this parameter: whether to process this component in the context of the specific user, across the entire operating system, or both. <br/>The largest possible scope is set by the **\<component element\>**. For example, if a **\<component\>** element has a context of **User** and a **\<rules\>** element had a context of **UserAndSystem**, then the **\<rules\>** element would act as though it had a context of **User**. If the **\<rules\>** element had a context of **System**, it would act as though the **\<rules\>** element weren't there. <ul><li>**User**: Evaluates the variables for each user.</li><li>**System**: Evaluates the variables only once for the system.</li><li>**UserAndSystem**: Evaluates the variables for the entire operating system and each user.</li></ul> <br/>The context parameter is ignored for **\<detects\>** elements that are inside **\<rules\>** elements. |
 
 The following example is from the `MigApp.xml` file.
 
@@ -795,19 +795,19 @@ The following example is from the `MigApp.xml` file.
 </detects>
 ```
 
-## &lt;detection&gt;
+## \<detection\>
 
-The  **&lt;detection&gt;** element is a container for one **&lt;conditions&gt;** element. The result of the child **&lt;condition&gt;** elements, located underneath the **&lt;conditions&gt;** element, determines the result of this element. For example, if all of the child **&lt;conditions&gt;** elements within the  **&lt;detection&gt;** element resolve to **TRUE**, then the  **&lt;detection&gt;** element resolves to **TRUE**. If any of the child **&lt;conditions&gt;** elements resolve to **FALSE**, then the  **&lt;detection&gt;** element resolves to **FALSE**.
+The  **\<detection\>** element is a container for one **\<conditions\>** element. The result of the child **\<condition\>** elements, located underneath the **\<conditions\>** element, determines the result of this element. For example, if all of the child **\<conditions\>** elements within the  **\<detection\>** element resolve to **TRUE**, then the  **\<detection\>** element resolves to **TRUE**. If any of the child **\<conditions\>** elements resolve to **FALSE**, then the  **\<detection\>** element resolves to **FALSE**.
 
-In addition, the results from each  **&lt;detection&gt;** section within the **&lt;role&gt;** element are joined together by the **OR** operator to form the detection rule of the parent element. That is, if one of the  **&lt;detection&gt;** sections resolves to **TRUE**, then the **&lt;role&gt;** element is processed. Otherwise, the **&lt;role&gt;** element isn't processed.
+In addition, the results from each  **\<detection\>** section within the **\<role\>** element are joined together by the **OR** operator to form the detection rule of the parent element. That is, if one of the  **\<detection\>** sections resolves to **TRUE**, then the **\<role\>** element is processed. Otherwise, the **\<role\>** element isn't processed.
 
-Use the  **&lt;detection&gt;** element under the **&lt;namedElements&gt;** element if you don't want to write it within a component. Then include a matching  **&lt;detection&gt;** section under the **&lt;role&gt;** element to control whether the component is migrated. If there isn't a  **&lt;detection&gt;** section for a component, then USMT assumes that the component is present.
+Use the  **\<detection\>** element under the **\<namedElements\>** element if you don't want to write it within a component. Then include a matching  **\<detection\>** section under the **\<role\>** element to control whether the component is migrated. If there isn't a  **\<detection\>** section for a component, then USMT assumes that the component is present.
 
 - **Number of occurrences:** Unlimited.
 
-- **Parent elements:** [&lt;role&gt;](#role), [&lt;namedElements&gt;](#namedelements)
+- **Parent elements:** [\<role\>](#role), [\<namedElements\>](#namedelements)
 
-- **Child elements:** [&lt;conditions&gt;](#conditions)
+- **Child elements:** [\<conditions\>](#conditions)
 
 Syntax:
 
@@ -818,7 +818,7 @@ Syntax:
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-| name | <ul><li>Yes, when **&lt;detection&gt;** is declared under **&lt;namedElements&gt;**</li><li>Optional, when declared under **&lt;role&gt;**</li></ul> | If declared, the content of the  **&lt;detection&gt;** element is ignored and the content of the  **&lt;detection&gt;** element with the same name that is declared in the **&lt;namedElements&gt;** element is evaluated. |
+| name | <ul><li>Yes, when **\<detection\>** is declared under **\<namedElements\>**</li><li>Optional, when declared under **\<role\>**</li></ul> | If declared, the content of the  **\<detection\>** element is ignored and the content of the  **\<detection\>** element with the same name that is declared in the **\<namedElements\>** element is evaluated. |
 | context | No, default = UserAndSystem | Defines the scope of this parameter: whether to process this component in the context of the specific user, across the entire operating system, or both. <ul><li>**User**: Evaluates the component for each user.</li><li>**System**: Evaluates the component only once for the system.</li><li>**UserAndSystem**: Evaluates the component for the entire operating system and each user.</li></ul> |
 
 For example:
@@ -844,13 +844,13 @@ and
    </detection>
 ```
 
-## &lt;displayName&gt;
+## \<displayName\>
 
-The **&lt;displayName&gt;** element is a required field within each **&lt;component&gt;** element.
+The **\<displayName\>** element is a required field within each **\<component\>** element.
 
 - **Number of occurrences:** once for each component
 
-- **Parent elements:** [&lt;component&gt;](#component)
+- **Parent elements:** [\<component\>](#component)
 
 - **Child elements:** none
 
@@ -871,17 +871,17 @@ For example:
 <displayName>Command Prompt settings</displayName>
 ```
 
-## &lt;environment&gt;
+## \<environment\>
 
-The **&lt;environment&gt;** element is a container for **&lt;variable&gt;** elements in which you can define variables to use in your .xml file. All environment variables defined this way are private. That is, they're available only for their child components and the component in which they were defined. For two example scenarios, see [Examples](#examples).
+The **\<environment\>** element is a container for **\<variable\>** elements in which you can define variables to use in your .xml file. All environment variables defined this way are private. That is, they're available only for their child components and the component in which they were defined. For two example scenarios, see [Examples](#examples).
 
 - **Number of occurrences:** unlimited
 
-- **Parent elements:** [&lt;role&gt;](#role), [&lt;component&gt;](#component), [&lt;namedElements&gt;](#namedelements)
+- **Parent elements:** [\<role\>](#role), [\<component\>](#component), [\<namedElements\>](#namedelements)
 
-- **Required child elements:** [&lt;variable&gt;](#variable)
+- **Required child elements:** [\<variable\>](#variable)
 
-- **Optional child elements:** [&lt;conditions&gt;](#conditions)
+- **Optional child elements:** [\<conditions\>](#conditions)
 
 Syntax:
 
@@ -892,8 +892,8 @@ Syntax:
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-| name | Yes, when **&lt;environment&gt;** is a child of **&lt;namedElements&gt;** <br/>No, when **&lt;environment&gt;** is a child of **&lt;role&gt;** or **&lt;component&gt;** | When declared as a child of the **&lt;role&gt;** or **&lt;component&gt;** elements, if *ID* is declared, USMT ignores the content of the **&lt;environment&gt;** element and the content of the **&lt;environment&gt;** element with the same name declared in the **&lt;namedElements&gt;** element is processed. |
-| context | No <br/>(default = UserAndSystem) | Defines the scope of this parameter: whether to process this component in the context of the specific user, across the entire operating system, or both. <br/>The largest possible scope is set by the **&lt;component&gt;** element. For example, if a **&lt;component&gt;** element has a context of **User** and a **&lt;rules&gt;** element had a context of **UserAndSystem**, then the **&lt;rules&gt;** element would act as though it had a context of **User**. If the **&lt;rules&gt;** element had a context of **System**, it would act as though **&lt;rules&gt;** weren't there. <ul><li>**User**: Evaluates the variables for each user.</li><li>**System**: Evaluates the variables only once for the system.</li><li>**UserAndSystem**: Evaluates the variables for the entire operating system and each user.</li></ul> |
+| name | Yes, when **\<environment\>** is a child of **\<namedElements\>** <br/>No, when **\<environment\>** is a child of **\<role\>** or **\<component\>** | When declared as a child of the **\<role\>** or **\<component\>** elements, if *ID* is declared, USMT ignores the content of the **\<environment\>** element and the content of the **\<environment\>** element with the same name declared in the **\<namedElements\>** element is processed. |
+| context | No <br/>(default = UserAndSystem) | Defines the scope of this parameter: whether to process this component in the context of the specific user, across the entire operating system, or both. <br/>The largest possible scope is set by the **\<component\>** element. For example, if a **\<component\>** element has a context of **User** and a **\<rules\>** element had a context of **UserAndSystem**, then the **\<rules\>** element would act as though it had a context of **User**. If the **\<rules\>** element had a context of **System**, it would act as though **\<rules\>** weren't there. <ul><li>**User**: Evaluates the variables for each user.</li><li>**System**: Evaluates the variables only once for the system.</li><li>**UserAndSystem**: Evaluates the variables for the entire operating system and each user.</li></ul> |
 
 ## Examples
 
@@ -909,7 +909,7 @@ In this scenario, you want to generate the location of objects at run time depen
 </environment>
 ```
 
-Then you can use an include rule as follows. You can use any of the [&lt;script&gt; functions](#script-functions) to perform similar tasks.
+Then you can use an include rule as follows. You can use any of the [\<script\> functions](#script-functions) to perform similar tasks.
 
 ```xml
 <include>
@@ -937,7 +937,7 @@ Second, you can also filter registry values that contain data that you need. The
 
 ### Example scenario 2
 
-In this scenario, you want to migrate five files named `File1.txt`, `File2.txt`, and so on, from `%SYSTEMDRIVE%\data\userdata\dir1\dir2\`. To migrate these files, you must have the following **&lt;include&gt;** rule in an .xml file:
+In this scenario, you want to migrate five files named `File1.txt`, `File2.txt`, and so on, from `%SYSTEMDRIVE%\data\userdata\dir1\dir2\`. To migrate these files, you must have the following **\<include\>** rule in an .xml file:
 
 ```xml
 <include>
@@ -961,7 +961,7 @@ Instead of typing the path five times, you can create a variable for the locatio
 </environment>
 ```
 
-Then, you can specify the variable in an **&lt;include&gt;** rule as follows:
+Then, you can specify the variable in an **\<include\>** rule as follows:
 
 ```xml
 <include>
@@ -975,17 +975,17 @@ Then, you can specify the variable in an **&lt;include&gt;** rule as follows:
 </include>
 ```
 
-## &lt;exclude&gt;
+## \<exclude\>
 
-The **&lt;exclude&gt;** element determines what objects aren't migrated, unless there's a more specific **&lt;include&gt;** element that migrates an object. If there's an **&lt;include&gt;** and **&lt;exclude&gt;** element for the same object, the object is included. For each **&lt;exclude&gt;** element, there can be multiple child **&lt;objectSet&gt;** elements.
+The **\<exclude\>** element determines what objects aren't migrated, unless there's a more specific **\<include\>** element that migrates an object. If there's an **\<include\>** and **\<exclude\>** element for the same object, the object is included. For each **\<exclude\>** element, there can be multiple child **\<objectSet\>** elements.
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Child elements:** [&lt;objectSet&gt;](#objectset)
+- **Child elements:** [\<objectSet\>](#objectset)
 
-- **Helper functions:** You can use the following [&lt;exclude&gt; filter functions](#include-and-exclude-filter-functions) with this element: `CompareStringContent`, `IgnoreIrrelevantLinks`, `AnswerNo`, `NeverRestore`, and `SameRegContent`.
+- **Helper functions:** You can use the following [\<exclude\> filter functions](#include-and-exclude-filter-functions) with this element: `CompareStringContent`, `IgnoreIrrelevantLinks`, `AnswerNo`, `NeverRestore`, and `SameRegContent`.
 
 Syntax:
 
@@ -1010,15 +1010,15 @@ For example, from the `MigUser.xml` file:
 </exclude>
 ```
 
-## &lt;excludeAttributes&gt;
+## \<excludeAttributes\>
 
-You can use the **&lt;excludeAttributes&gt;** element to determine which parameters associated with an object aren't migrated. If there are conflicts between the **&lt;includeAttributes&gt;** and **&lt;excludeAttributes&gt;** elements, the most specific pattern determines the patterns that aren't migrated. If an object doesn't have an **&lt;includeAttributes&gt;** or **&lt;excludeAttributes&gt;** element, then all of its parameters are migrated.
+You can use the **\<excludeAttributes\>** element to determine which parameters associated with an object aren't migrated. If there are conflicts between the **\<includeAttributes\>** and **\<excludeAttributes\>** elements, the most specific pattern determines the patterns that aren't migrated. If an object doesn't have an **\<includeAttributes\>** or **\<excludeAttributes\>** element, then all of its parameters are migrated.
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Child elements:** [&lt;objectSet&gt;](#objectset)
+- **Child elements:** [\<objectSet\>](#objectset)
 
 Syntax:
 
@@ -1082,15 +1082,15 @@ Example:
 </migration>
 ```
 
-## &lt;extensions&gt;
+## \<extensions\>
 
-The &lt;extensions&gt; element is a container for one or more &lt;extension&gt; elements.
+The \<extensions\> element is a container for one or more \<extension\> elements.
 
 - **Number of occurrences:** zero or one
 
-- **Parent elements:** [&lt;component&gt;](#component)
+- **Parent elements:** [\<component\>](#component)
 
-- **Required child elements:** [&lt;extension&gt;](#extension)
+- **Required child elements:** [\<extension\>](#extension)
 
 Syntax:
 
@@ -1099,13 +1099,13 @@ Syntax:
 </extensions>
 ```
 
-## &lt;extension&gt;
+## \<extension\>
 
-You can use the &lt;extension&gt; element to specify documents of a specific extension.
+You can use the \<extension\> element to specify documents of a specific extension.
 
 - **Number of occurrences:** unlimited
 
-- **Parent elements:** [&lt;extensions&gt;](#extensions)
+- **Parent elements:** [\<extensions\>](#extensions)
 
 - **Child elements:** none
 
@@ -1119,7 +1119,7 @@ Syntax:
 |--- |--- |--- |
 |*FilenameExtension*|Yes|A file name extension.|
 
-For example, if you want to migrate all \*.doc files from the source computer, specifying the following code under the **&lt;component&gt;** element:
+For example, if you want to migrate all \*.doc files from the source computer, specifying the following code under the **\<component\>** element:
 
 ```xml
 <extensions> 
@@ -1127,7 +1127,7 @@ For example, if you want to migrate all \*.doc files from the source computer, s
 <extensions> 
 ```
 
-is the same as specifying the following code below the **&lt;rules&gt;** element:
+is the same as specifying the following code below the **\<rules\>** element:
 
 ```xml
 <include> 
@@ -1137,17 +1137,17 @@ is the same as specifying the following code below the **&lt;rules&gt;** element
 </include>
 ```
 
-For another example of how to use the &lt;extension&gt; element, see the example for [&lt;excludeAttributes&gt;](#excludeattributes).
+For another example of how to use the \<extension\> element, see the example for [\<excludeAttributes\>](#excludeattributes).
 
-## &lt;externalProcess&gt;
+## \<externalProcess\>
 
-You can use the &lt;externalProcess&gt; element to run a command line during the migration process. For example, you might want to run a command after the **LoadState** process completes.
+You can use the \<externalProcess\> element to run a command line during the migration process. For example, you might want to run a command after the **LoadState** process completes.
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Required child elements:** [&lt;commandLine&gt;](#commandline)
+- **Required child elements:** [\<commandLine\>](#commandline)
 
 Syntax:
 
@@ -1160,23 +1160,23 @@ Syntax:
 |--- |--- |--- |
 | when | Yes | Indicates when the command line should be run. This value can be one of the following values: <ul><li>**pre-scan** before the scanning process begins.</li><li>**scan-success** after the scanning process finishes successfully.</li><li>**post-scan** after the scanning process finished, whether it was successful or not.</li><li>**pre-apply** before the apply process begins.</li><li>**apply-success** after the apply process finishes successfully.</li><li>**post-apply** after the apply process finished, whether it was successful or not.</li></ul> |
 
-For an example of how to use the &lt;externalProcess&gt; element, see the example for [&lt;excludeAttributes&gt;](#excludeattributes).
+For an example of how to use the \<externalProcess\> element, see the example for [\<excludeAttributes\>](#excludeattributes).
 
-## &lt;icon&gt;
+## \<icon\>
 
 This element is an internal USMT element. Don't use this element.
 
-## &lt;include&gt;
+## \<include\>
 
-The **&lt;include&gt;** element determines what to migrate, unless there's a more specific [&lt;exclude&gt;](#exclude) rule. You can specify a script to be more specific to extend the definition of what you want to collect. For each **&lt;include&gt;** element, there can be multiple **&lt;objectSet&gt;** elements.
+The **\<include\>** element determines what to migrate, unless there's a more specific [\<exclude\>](#exclude) rule. You can specify a script to be more specific to extend the definition of what you want to collect. For each **\<include\>** element, there can be multiple **\<objectSet\>** elements.
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Required child element:** [&lt;objectSet&gt;](#objectset)
+- **Required child element:** [\<objectSet\>](#objectset)
 
-- **Helper functions:** You can use the following [&lt;include&gt; filter functions](#include-and-exclude-filter-functions) with this element: `CompareStringContent`, `IgnoreIrrelevantLinks`, `AnswerNo`, and `NeverRestore`.
+- **Helper functions:** You can use the following [\<include\> filter functions](#include-and-exclude-filter-functions) with this element: `CompareStringContent`, `IgnoreIrrelevantLinks`, `AnswerNo`, and `NeverRestore`.
 
 Syntax:
 
@@ -1187,7 +1187,7 @@ Syntax:
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-| filter | No. <br/>If this parameter isn't specified, then all patterns that are inside the child **&lt;objectSet&gt;** element are processed. | A script followed by any number of string arguments that are separated by a comma and enclosed in parenthesis. For example, `MyScripts.AScript ("Arg1","Arg2")`. <br/>The script is called for each object that is enumerated by the object sets in the **&lt;include&gt;** rule. The filter script returns a Boolean value. If the return value is **TRUE**, the object is migrated. If it's **FALSE**, it isn't migrated. |
+| filter | No. <br/>If this parameter isn't specified, then all patterns that are inside the child **\<objectSet\>** element are processed. | A script followed by any number of string arguments that are separated by a comma and enclosed in parenthesis. For example, `MyScripts.AScript ("Arg1","Arg2")`. <br/>The script is called for each object that is enumerated by the object sets in the **\<include\>** rule. The filter script returns a Boolean value. If the return value is **TRUE**, the object is migrated. If it's **FALSE**, it isn't migrated. |
 
 The following example is from the MigUser.xml file:
 
@@ -1219,7 +1219,7 @@ The following example is from the MigUser.xml file:
     </component>
 ```
 
-### &lt;include&gt; and **&lt;exclude&gt;** filter functions
+### \<include\> and **\<exclude\>** filter functions
 
 The following functions return a Boolean value. You can use them to migrate certain objects based on when certain conditions are met.
 
@@ -1270,15 +1270,15 @@ The following functions return a Boolean value. You can use them to migrate cert
     </include>
     ```
 
-## &lt;includeAttributes&gt;
+## \<includeAttributes\>
 
-You can use the **&lt;includeAttributes&gt;** element to determine whether certain parameters associated with an object are migrated along with the object itself. If there are conflicts between the **&lt;includeAttributes&gt;** and **&lt;excludeAttributes&gt;** elements, the most specific pattern determines which parameters are migrated. If an object doesn't have an **&lt;includeAttributes&gt;** or **&lt;excludeAttributes&gt;** element, then all of its parameters are migrated.
+You can use the **\<includeAttributes\>** element to determine whether certain parameters associated with an object are migrated along with the object itself. If there are conflicts between the **\<includeAttributes\>** and **\<excludeAttributes\>** elements, the most specific pattern determines which parameters are migrated. If an object doesn't have an **\<includeAttributes\>** or **\<excludeAttributes\>** element, then all of its parameters are migrated.
 
 - **Number of occurrences:** unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Child elements:** [&lt;objectSet&gt;](#objectset)
+- **Child elements:** [\<objectSet\>](#objectset)
 
 Syntax:
 
@@ -1291,21 +1291,21 @@ Syntax:
 |--- |--- |--- |
 | attributes | Yes | Specifies the attributes to be included with a migrated object. You can specify one of the following, or both separated by quotes; for example, `"Security","TimeFields"`: <ul><li>Security can be one of the following values: <ul><li>**Owner**: The owner of the object (SID).</li><li>**Group**: The primary group for the object (SID).</li><li>**DACL** (discretionary access control list): An access control list that is controlled by the owner of an object and that specifies the access particular users or groups can have to the object.</li><li>**SACL** (system access control list): An ACL that controls the generation of audit messages for attempts to access a securable object. The ability to get or set an object&#39;s SACL is controlled by a privilege typically held only by system administrators.</li></ul></li><li>TimeFields can be one of the following values: <ul><li>**CreationTime**: Specifies when the file or directory was created.</li><li>**LastAccessTime**: Specifies when the file is last read from, written to, or for executable files, run.</li><li>**LastWrittenTime**: Specifies when the file is last written to, truncated, or overwritten.</li></ul></li></ul> |
 
-For an example of how to use the **&lt;includeAttributes&gt;** element, see the example for [&lt;excludeAttributes&gt;](#excludeattributes).
+For an example of how to use the **\<includeAttributes\>** element, see the example for [\<excludeAttributes\>](#excludeattributes).
 
-## &lt;library&gt;
+## \<library\>
 
 This element is an internal USMT element. Don't use this element.
 
-## &lt;location&gt;
+## \<location\>
 
-The **&lt;location&gt;** element defines the location of the **&lt;object&gt;** element.
+The **\<location\>** element defines the location of the **\<object\>** element.
 
-- **Number of occurrences:** once for each **&lt;object&gt;**
+- **Number of occurrences:** once for each **\<object\>**
 
-- **Parent elements:** [&lt;object&gt;](#object)
+- **Parent elements:** [\<object\>](#object)
 
-- **Child elements:** [&lt;script&gt;](#script)
+- **Child elements:** [\<script\>](#script)
 
 Syntax:
 
@@ -1335,17 +1335,17 @@ The following example is from the `MigApp.xml` file:
 </addObjects>
 ```
 
-## &lt;locationModify&gt;
+## \<locationModify\>
 
-You can use the **&lt;locationModify&gt;** element to change the location and name of an object before the object is migrated to the destination computer. The **&lt;locationModify&gt;** element is processed only when the **LoadState** tool is run on the destination computer. In other words, this element is ignored by the **ScanState** tool. The **&lt;locationModify&gt;** element creates the appropriate folder on the destination computer if it doesn't already exist.
+You can use the **\<locationModify\>** element to change the location and name of an object before the object is migrated to the destination computer. The **\<locationModify\>** element is processed only when the **LoadState** tool is run on the destination computer. In other words, this element is ignored by the **ScanState** tool. The **\<locationModify\>** element creates the appropriate folder on the destination computer if it doesn't already exist.
 
 **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Required child element:** [&lt;objectSet&gt;](#objectset)
+- **Required child element:** [\<objectSet\>](#objectset)
 
-- **Helper functions:** You can use the following [&lt;locationModify&gt; functions](#locationmodify-functions) with this element: `ExactMove`, `RelativeMove`, and `Move`.
+- **Helper functions:** You can use the following [\<locationModify\> functions](#locationmodify-functions) with this element: `ExactMove`, `RelativeMove`, and `Move`.
 
 Syntax:
 
@@ -1368,13 +1368,13 @@ The following example is from the `MigApp.xml` file:
 </locationModify>
 ```
 
-### &lt;locationModify&gt; functions
+### \<locationModify\> functions
 
-The following functions change the location of objects as they're migrated when using the **&lt;locationModify&gt;** element. These functions are called for every object that the parent **&lt;objectSet&gt;** element is enumerating. The **&lt;locationModify&gt;** element creates the appropriate folder on the destination computer if it doesn't already exist.
+The following functions change the location of objects as they're migrated when using the **\<locationModify\>** element. These functions are called for every object that the parent **\<objectSet\>** element is enumerating. The **\<locationModify\>** element creates the appropriate folder on the destination computer if it doesn't already exist.
 
 - **ExactMove**
 
-  The ExactMove function moves all of the objects that are matched by the parent **&lt;objectSet&gt;** element into the given *ObjectEncodedLocation*. You can use this function when you want to move a single file to a different location on the destination computer. If the destination location is a node, all of the matching source objects are written to the node without any subdirectories. If the destination location is a leaf, the migration engine migrates all of the matching source objects to the same location. If a collision occurs, the normal collision algorithms apply.
+  The ExactMove function moves all of the objects that are matched by the parent **\<objectSet\>** element into the given *ObjectEncodedLocation*. You can use this function when you want to move a single file to a different location on the destination computer. If the destination location is a node, all of the matching source objects are written to the node without any subdirectories. If the destination location is a leaf, the migration engine migrates all of the matching source objects to the same location. If a collision occurs, the normal collision algorithms apply.
 
   Syntax: `ExactMove(ObjectEncodedLocation)`
 
@@ -1410,7 +1410,7 @@ The following functions change the location of objects as they're migrated when
 
     |Setting|Required?|Value|
     |--- |--- |--- |
-    |*SourceRoot*|Yes|The location where the objects are moved from. Any source objects that are enumerated by the parent **&lt;objectSet&gt;** element that aren't in this location aren't moved.|
+    |*SourceRoot*|Yes|The location where the objects are moved from. Any source objects that are enumerated by the parent **\<objectSet\>** element that aren't in this location aren't moved.|
     |*DestinationRoot*|Yes|The location where the source objects are moved to on the destination computer. If needed, this function creates any subdirectories that were above *SourceRoot*.|
 
 For example:
@@ -1428,17 +1428,17 @@ For example:
 </locationModify>
 ```
 
-## &lt;\_locDefinition&gt;
+## \<\_locDefinition\>
 
 This element is an internal USMT element. Don't use this element.
 
-## &lt;manufacturer&gt;
+## \<manufacturer\>
 
-The **&lt;manufacturer&gt;** element defines the manufacturer for the component, but doesn't affect the migration.
+The **\<manufacturer\>** element defines the manufacturer for the component, but doesn't affect the migration.
 
 - **Number of occurrences:** zero or one
 
-- **Parent elements:** [&lt;component&gt;](#component)
+- **Parent elements:** [\<component\>](#component)
 
 - **Child elements:** none
 
@@ -1452,19 +1452,19 @@ Syntax:
 |--- |--- |--- |
 |*Name*|Yes|The name of the manufacturer for the component.|
 
-## &lt;merge&gt;
+## \<merge\>
 
-The **&lt;merge&gt;** element determines what happens when a collision occurs. A collision is when an object that is migrated is already present on the destination computer. If you don't specify this element, the default behavior for the registry is for the source object to overwrite the destination object. The default behavior for files is for the source file to be renamed to `OriginalFileName(1).OriginalExtension`. This element specifies only what should be done when a collision occurs. It doesn't include objects. Therefore, for your objects to migrate, you must specify **&lt;include&gt;** rules along with the **&lt;merge&gt;** element. When an object is processed and a collision is detected, USMT selects the most specific merge rule. It then applies the rule to resolve the conflict. For example, if you have a **&lt;merge&gt;** rule `C:\* [*]` set to **&lt;sourcePriority&gt;** and a **&lt;merge&gt;** rule `C:\subfolder\* [*]` set to **&lt;destinationPriority&gt;**, then USMT would use the **&lt;destinationPriority&gt;** rule because it's the more specific.
+The **\<merge\>** element determines what happens when a collision occurs. A collision is when an object that is migrated is already present on the destination computer. If you don't specify this element, the default behavior for the registry is for the source object to overwrite the destination object. The default behavior for files is for the source file to be renamed to `OriginalFileName(1).OriginalExtension`. This element specifies only what should be done when a collision occurs. It doesn't include objects. Therefore, for your objects to migrate, you must specify **\<include\>** rules along with the **\<merge\>** element. When an object is processed and a collision is detected, USMT selects the most specific merge rule. It then applies the rule to resolve the conflict. For example, if you have a **\<merge\>** rule `C:\* [*]` set to **\<sourcePriority\>** and a **\<merge\>** rule `C:\subfolder\* [*]` set to **\<destinationPriority\>**, then USMT would use the **\<destinationPriority\>** rule because it's the more specific.
 
 For an example of this element, see [Conflicts and precedence](usmt-conflicts-and-precedence.md).
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Required child element:** [&lt;objectSet&gt;](#objectset)
+- **Required child element:** [\<objectSet\>](#objectset)
 
-- **Helper functions:** You can use the following [&lt;merge&gt; functions](#merge-functions) with this element: `SourcePriority`, `DestinationPriority`, `FindFilePlaceByPattern`, `LeafPattern`, `NewestVersion`, `HigherValue()`, and `LowerValue()`.
+- **Helper functions:** You can use the following [\<merge\> functions](#merge-functions) with this element: `SourcePriority`, `DestinationPriority`, `FindFilePlaceByPattern`, `LeafPattern`, `NewestVersion`, `HigherValue()`, and `LowerValue()`.
 
 Syntax:
 
@@ -1475,7 +1475,7 @@ Syntax:
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-|script|Yes|A script followed by any number of string arguments that are separated by a comma and enclosed in parenthesis. For example, `MyScripts.AScript ("Arg1","Arg2")`. <br/><br/>The script is called for each object that is enumerated by the object sets in the **&lt;include&gt;** rule. The filter script returns a Boolean value. If the return value is **TRUE**, the object is migrated. If it's **FALSE**, it isn't migrated.|
+|script|Yes|A script followed by any number of string arguments that are separated by a comma and enclosed in parenthesis. For example, `MyScripts.AScript ("Arg1","Arg2")`. <br/><br/>The script is called for each object that is enumerated by the object sets in the **\<include\>** rule. The filter script returns a Boolean value. If the return value is **TRUE**, the object is migrated. If it's **FALSE**, it isn't migrated.|
 
 The following example is from the MigUser.xml file:
 
@@ -1494,7 +1494,7 @@ The following example is from the MigUser.xml file:
 </rules>
 ```
 
-### &lt;merge&gt; functions
+### \<merge\> functions
 
 These functions control how collisions are resolved.
 
@@ -1516,13 +1516,13 @@ These functions control how collisions are resolved.
 
 - **FindFilePlaceByPattern**
 
-    The FindFilePlaceByPattern function saves files with an incrementing counter when a collision occurs. It's a string that contains one of each construct: **&lt;F&gt;**, **&lt;E&gt;**, **&lt;N&gt;** in any order.
+    The FindFilePlaceByPattern function saves files with an incrementing counter when a collision occurs. It's a string that contains one of each construct: **\<F\>**, **\<E\>**, **\<N\>** in any order.
 
     Syntax: `FindFilePlaceByPattern(FilePattern)`
 
     |Setting|Required?|Value|
     |--- |--- |--- |
-    | *FilePattern* | Yes | <ul><li>**&lt;F&gt;** is replaced by the original file name.</li><li>**&lt;N&gt;** is replaced by an incrementing counter until there's no collision with the objects on the destination computer.</li><li>**&lt;E&gt;** is replaced by the original file name extension.</li></ul> <br/>For example, `<F> (<N>).<E>` changes the source file `MyDocument.doc` into `MyDocument (1).doc` on the destination computer. |
+    | *FilePattern* | Yes | <ul><li>**\<F\>** is replaced by the original file name.</li><li>**\<N\>** is replaced by an incrementing counter until there's no collision with the objects on the destination computer.</li><li>**\<E\>** is replaced by the original file name extension.</li></ul> <br/>For example, `<F> (<N>).<E>` changes the source file `MyDocument.doc` into `MyDocument (1).doc` on the destination computer. |
 
 - **NewestVersion**
 
@@ -1558,17 +1558,17 @@ These functions control how collisions are resolved.
     </merge>
     ```
 
-## &lt;migration&gt;
+## \<migration\>
 
-The **&lt;migration&gt;** element is the single root element of a migration .xml file and is required. Each .xml file must have a unique migration urlid. The urlid of each file that you specify on the command line must be unique. The urlids must be unique because USMT uses the urlid to define the components within the file.
+The **\<migration\>** element is the single root element of a migration .xml file and is required. Each .xml file must have a unique migration urlid. The urlid of each file that you specify on the command line must be unique. The urlids must be unique because USMT uses the urlid to define the components within the file.
 
 - **Number of occurrences:** one
 
 - **Parent elements:** none
 
-- **Required child elements:** [&lt;component&gt;](#component)
+- **Required child elements:** [\<component\>](#component)
 
-- **Optional child elements:** [&lt;library&gt;](#library), [&lt;namedElements&gt;](#namedelements)
+- **Optional child elements:** [\<library\>](#library), [\<namedElements\>](#namedelements)
 
 Syntax:
 
@@ -1615,9 +1615,9 @@ This filter helper function can be used to filter the migration of files based o
 </component>
 ```
 
-## &lt;namedElements&gt;
+## \<namedElements\>
 
-You can use the **&lt;namedElements&gt;** element to define named elements. You can use these elements in any component throughout your .xml file. For an example of how to use this element, see the `MigApp.xml` file.
+You can use the **\<namedElements\>** element to define named elements. You can use these elements in any component throughout your .xml file. For an example of how to use this element, see the `MigApp.xml` file.
 
 Syntax:
 
@@ -1628,23 +1628,23 @@ Syntax:
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;migration&gt;](#migration)
+- **Parent elements:** [\<migration\>](#migration)
 
-- **Child elements:** [&lt;environment&gt;](#environment), [&lt;rules&gt;](#rules), [&lt;conditions&gt;](#conditions), [&lt;detection&gt;](#detection), [&lt;detects&gt;](#detects), [&lt;detect&gt;](#detect)
+- **Child elements:** [\<environment\>](#environment), [\<rules\>](#rules), [\<conditions\>](#conditions), [\<detection\>](#detection), [\<detects\>](#detects), [\<detect\>](#detect)
 
 For an example of this element, see the `MigApp.xml` file.
 
-## &lt;object&gt;
+## \<object\>
 
-The **&lt;object&gt;** element represents a file or registry key.
+The **\<object\>** element represents a file or registry key.
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;addObjects&gt;](#addobjects)
+- **Parent elements:** [\<addObjects\>](#addobjects)
 
-- **Required child elements:** [&lt;location&gt;](#location), [&lt;attributes&gt;](#attributes)
+- **Required child elements:** [\<location\>](#location), [\<attributes\>](#attributes)
 
-- **Optional child elements:** [&lt;bytes&gt;](#bytes)
+- **Optional child elements:** [\<bytes\>](#bytes)
 
 Syntax:
 
@@ -1670,17 +1670,17 @@ The following example is from the `MigApp.xml` file:
 </addObjects>
 ```
 
-## &lt;objectSet&gt;
+## \<objectSet\>
 
-The **&lt;objectSet&gt;** element contains a list of object patterns; for example, file paths, registry locations, and so on. Any child **&lt;conditions&gt;** elements are evaluated first. If all child **&lt;conditions&gt;** elements return **FALSE**, the **&lt;objectSet&gt;** element evaluates to an empty set. For each parent element, there can be only multiple **&lt;objectSet&gt;** elements.
+The **\<objectSet\>** element contains a list of object patterns; for example, file paths, registry locations, and so on. Any child **\<conditions\>** elements are evaluated first. If all child **\<conditions\>** elements return **FALSE**, the **\<objectSet\>** element evaluates to an empty set. For each parent element, there can be only multiple **\<objectSet\>** elements.
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;variable&gt;](#variable), [&lt;content&gt;](#content), [&lt;include&gt;](#include), [&lt;exclude&gt;](#exclude), [&lt;merge&gt;](#merge), [&lt;contentModify&gt;](#contentmodify), [&lt;locationModify&gt;](#locationmodify), [&lt;destinationCleanup&gt;](#destinationcleanup), [&lt;includeAttributes&gt;](#includeattributes), [&lt;excludeAttributes&gt;](#excludeattributes), [&lt;unconditionalExclude&gt;](#unconditionalexclude), [&lt;detect&gt;](#detect)
+- **Parent elements:** [\<variable\>](#variable), [\<content\>](#content), [\<include\>](#include), [\<exclude\>](#exclude), [\<merge\>](#merge), [\<contentModify\>](#contentmodify), [\<locationModify\>](#locationmodify), [\<destinationCleanup\>](#destinationcleanup), [\<includeAttributes\>](#includeattributes), [\<excludeAttributes\>](#excludeattributes), [\<unconditionalExclude\>](#unconditionalexclude), [\<detect\>](#detect)
 
-- **Required child elements:** either [&lt;script&gt;](#script) or [&lt;pattern&gt;](#pattern)
+- **Required child elements:** either [\<script\>](#script) or [\<pattern\>](#pattern)
 
-- **Optional child elements:** [&lt;content&gt;](#content), [&lt;conditions&gt;](#conditions), [&lt;condition&gt;](#condition)
+- **Optional child elements:** [\<content\>](#content), [\<conditions\>](#conditions), [\<condition\>](#condition)
 
 Syntax:
 
@@ -1719,17 +1719,17 @@ The following example is from the MigUser.xml file:
 </component>
 ```
 
-## &lt;path&gt;
+## \<path\>
 
 This element is an internal USMT element. Don't use this element.
 
-## &lt;paths&gt;
+## \<paths\>
 
 This element is an internal USMT element. Don't use this element.
 
-## &lt;pattern&gt;
+## \<pattern\>
 
-You can use this element to specify multiple objects. You can specify multiple **&lt;pattern&gt;** elements for each **&lt;objectSet&gt;** element and they're combined. If you're specifying files, you might want to use `GenerateDrivePatterns` with **&lt;script&gt;** instead. `GenerateDrivePatterns` is basically the same as a **&lt;pattern&gt;** rule, without the drive letter specification. For example, the following two lines of code are similar:
+You can use this element to specify multiple objects. You can specify multiple **\<pattern\>** elements for each **\<objectSet\>** element and they're combined. If you're specifying files, you might want to use `GenerateDrivePatterns` with **\<script\>** instead. `GenerateDrivePatterns` is basically the same as a **\<pattern\>** rule, without the drive letter specification. For example, the following two lines of code are similar:
 
 ```xml
 <pattern type="File">C:\Folder\* [Sample.doc]</pattern>
@@ -1738,7 +1738,7 @@ You can use this element to specify multiple objects. You can specify multiple *
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;objectSet&gt;](#objectset)
+- **Parent elements:** [\<objectSet\>](#objectset)
 
 - **Child elements:** none but *Path* \[*object*\] must be valid.
 
@@ -1750,7 +1750,7 @@ Syntax:
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-| type | Yes | *typeID* can be Registry, File, or Ini. If *typeId* is Ini, then you can't have a space between *Path* and *object*. For example, the following format is correct when type="Ini": <br/>**&lt;pattern type="Ini"&gt;%WinAmp5InstPath%\Winamp.ini&#124;WinAmp[keeponscreen]&lt;/pattern&gt;** |
+| type | Yes | *typeID* can be Registry, File, or Ini. If *typeId* is Ini, then you can't have a space between *Path* and *object*. For example, the following format is correct when type="Ini": <br/>**\<pattern type="Ini"\>%WinAmp5InstPath%\Winamp.ini&#124;WinAmp[keeponscreen]\</pattern\>** |
 | *Path* [*object*] | Yes | A valid registry or file path pattern, followed by at least one space, followed by brackets [] that contain the object to be migrated. <ul><li>*Path* can contain the asterisk (`*`) wildcard character or can be an [Recognized environment variables](usmt-recognized-environment-variables.md). You can't use the question mark as a wildcard character. You can use `HKCU` and `HKLM` to refer to `HKEY_CURRENT_USER` and `HKEY_LOCAL_MACHINE` respectively.</li><li>*Object* can contain the asterisk (`*`) wildcard character. However, you can't use the question mark as a wildcard character. For example: <br/> **`C:\Folder\ [*]`** enumerates all files in `C:\Folder` but no subfolders of `C:\Folder`. <br/> **`C:\Folder* [*]`** enumerates all files and subfolders of `C:\Folder`. <br/> **`C:\Folder\ [*.mp3]`** enumerates all `.mp3` files in `C:\Folder`. <br/> **`C:\Folder\ [Sample.doc]`** enumerates only the `Sample.doc` file located in C:\Folder. <div class="alert">**Note**<br/>If migrating a file that has a square bracket character ([ or ]) in the file name, a carrot (^) character must be inserted directly before the bracket for it to be valid. For example, if there's a file named "file].txt", you must specify `<pattern type="File">c:\documents\mydocs [file^].txt]</pattern>` instead of `<pattern type="File">c:\documents\mydocs [file].txt]</pattern>`.</div></li></ul> |
 
 For example:
@@ -1785,15 +1785,15 @@ For example:
 
 - For more examples of how to use this element, see [Exclude files and settings](usmt-exclude-files-and-settings.md), [Reroute files and settings](usmt-reroute-files-and-settings.md), [Include files and settings](usmt-include-files-and-settings.md), and [Custom XML examples](usmt-custom-xml-examples.md).
 
-## &lt;processing&gt;
+## \<processing\>
 
 You can use this element to run a script during a specific point within the migration process. Return values aren't expected from the scripts that you specify, and if there are return values, they're ignored.
 
 - **Number of occurrences:** unlimited
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Required child element:** [&lt;script&gt;](#script)
+- **Required child element:** [\<script\>](#script)
 
 Syntax:
 
@@ -1806,21 +1806,21 @@ Syntax:
 |--- |--- |--- |
 | when | Yes | Indicates when the script should be run. This value can be one of the following values: <ul><li>**pre-scan** means before the scanning process begins.</li><li>**scan-success** means after the scanning process finishes successfully.</li><li>**post-scan** means after the scanning process finished, whether it was successful or not.</li><li>**pre-apply** means before the apply process begins.</li><li>**apply-success** means after the apply process finishes successfully.</li><li>**post-apply** means after the apply process finished, whether it was successful or not.</li></ul> |
 
-## &lt;plugin&gt;
+## \<plugin\>
 
 This element is an internal USMT element. Don't use this element.
 
-## &lt;role&gt;
+## \<role\>
 
-The **&lt;role&gt;** element is required in a custom .xml file. By specifying the **&lt;role&gt;** element, you can create a concrete component. The component is defined by the parameters specified at the **&lt;component&gt;** level, and with the role that you specify here.
+The **\<role\>** element is required in a custom .xml file. By specifying the **\<role\>** element, you can create a concrete component. The component is defined by the parameters specified at the **\<component\>** level, and with the role that you specify here.
 
-- **Number of occurrences:** Each **&lt;component&gt;** can have one, two or three child **&lt;role&gt;** elements.
+- **Number of occurrences:** Each **\<component\>** can have one, two or three child **\<role\>** elements.
 
-- **Parent elements:** [&lt;component&gt;](#component), [&lt;role&gt;](#role)
+- **Parent elements:** [\<component\>](#component), [\<role\>](#role)
 
-- **Required child elements:** [&lt;rules&gt;](#rules)
+- **Required child elements:** [\<rules\>](#rules)
 
-- **Optional child elements:** [&lt;environment&gt;](#environment), [&lt;detection&gt;](#detection), [&lt;component&gt;](#component), [&lt;role&gt;](#role), [&lt;detects&gt;](#detects), [&lt;plugin&gt;](#plugin)
+- **Optional child elements:** [\<environment\>](#environment), [\<detection\>](#detection), [\<component\>](#component), [\<role\>](#role), [\<detects\>](#detects), [\<plugin\>](#plugin)
 
 Syntax:
 
@@ -1831,7 +1831,7 @@ Syntax:
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-| role | Yes | Defines the role for the component. Role can be one of: <ul><li>**Container**</li><li>**Binaries**</li><li>**Settings**</li><li>**Data**</li></ul> You can either: <ol><li>Specify up to three **&lt;role&gt;** elements within a **&lt;component&gt;** - one "Binaries" role element, one "Settings" role element and one "Data" role element. These parameters don't change the migration behavior - their only purpose is to help you categorize the settings that you're migrating. You can nest these **&lt;role&gt;** elements, but each nested element must be of the same role parameter.</li><li>Specify one "Container" **&lt;role&gt;** element within a **&lt;component&gt;** element. In this case, you can't specify any child **&lt;rules&gt;** elements, only other **&lt;component&gt;** elements. And each child **&lt;component&gt;** element must have the same type as that of parent **&lt;component&gt;** element. For example:</li></ol> <pre class="syntax"><code>&lt;component context="UserAndSystem" type="Application"&gt; <br/>  &lt;displayName _locID="migapp.msoffice2003"&gt;Microsoft Office 2003&lt;/displayName&gt; <br/>  &lt;environment name="GlobalEnv" /&gt; <br/>  &lt;role role="Container"&gt;<br/>    &lt;detection name="AnyOffice2003Version" /&gt; <br/>    &lt;detection name="FrontPage2003" /&gt; <br/>    &lt;!-- <br/> Office 2003 Common Settings <br/>  --&gt; <br/>     &lt;component context="UserAndSystem" type="Application"&gt;</code></pre> |
+| role | Yes | Defines the role for the component. Role can be one of: <ul><li>**Container**</li><li>**Binaries**</li><li>**Settings**</li><li>**Data**</li></ul> You can either: <ol><li>Specify up to three **\<role\>** elements within a **\<component\>** - one "Binaries" role element, one "Settings" role element and one "Data" role element. These parameters don't change the migration behavior - their only purpose is to help you categorize the settings that you're migrating. You can nest these **\<role\>** elements, but each nested element must be of the same role parameter.</li><li>Specify one "Container" **\<role\>** element within a **\<component\>** element. In this case, you can't specify any child **\<rules\>** elements, only other **\<component\>** elements. And each child **\<component\>** element must have the same type as that of parent **\<component\>** element. For example:</li></ol> <pre class="syntax"><code>\<component context="UserAndSystem" type="Application"\> <br/>  \<displayName _locID="migapp.msoffice2003"\>Microsoft Office 2003\</displayName\> <br/>  \<environment name="GlobalEnv" /\> <br/>  \<role role="Container"\><br/>    \<detection name="AnyOffice2003Version" /\> <br/>    \<detection name="FrontPage2003" /\> <br/>    \<!-- <br/> Office 2003 Common Settings <br/>  --\> <br/>     \<component context="UserAndSystem" type="Application"\></code></pre> |
 
 The following example is from the MigUser.xml file. For more examples, see the `MigApp.xml` file:
 
@@ -1864,17 +1864,17 @@ The following example is from the MigUser.xml file. For more examples, see the `
 </component>
 ```
 
-## &lt;rules&gt;
+## \<rules\>
 
-The **&lt;rules&gt;** element is required in a custom .xml file. This element contains rules that run during the migration if the parent **&lt;component&gt;** element is selected, unless the child **&lt;conditions&gt;** element, if present, evaluates to **FALSE**. For each **&lt;rules&gt;** element, there can be multiple child **&lt;rules&gt;** elements.
+The **\<rules\>** element is required in a custom .xml file. This element contains rules that run during the migration if the parent **\<component\>** element is selected, unless the child **\<conditions\>** element, if present, evaluates to **FALSE**. For each **\<rules\>** element, there can be multiple child **\<rules\>** elements.
 
 - **Number of occurrences:** unlimited
 
-- **Parent elements:** [&lt;role&gt;](#role), [&lt;rules&gt;](#rules), [&lt;namedElements&gt;](#namedelements)
+- **Parent elements:** [\<role\>](#role), [\<rules\>](#rules), [\<namedElements\>](#namedelements)
 
-- **Required child elements:** [&lt;include&gt;](#include)
+- **Required child elements:** [\<include\>](#include)
 
-- **Optional child elements:** [&lt;rules&gt;](#rules), [&lt;exclude&gt;](#exclude), [&lt;unconditionalExclude&gt;](#unconditionalexclude),[&lt;merge&gt;](#merge), [&lt;contentModify&gt;](#contentmodify), [&lt;locationModify&gt;](#locationmodify), [&lt;destinationCleanup&gt;](#destinationcleanup), [&lt;addObjects&gt;](#addobjects), [&lt;externalProcess&gt;](#externalprocess), [&lt;processing&gt;](#processing), [&lt;includeAttributes&gt;](#includeattributes), [&lt;excludeAttributes&gt;](#excludeattributes), [conditions](#conditions), [&lt;detects&gt;](#detects)
+- **Optional child elements:** [\<rules\>](#rules), [\<exclude\>](#exclude), [\<unconditionalExclude\>](#unconditionalexclude),[\<merge\>](#merge), [\<contentModify\>](#contentmodify), [\<locationModify\>](#locationmodify), [\<destinationCleanup\>](#destinationcleanup), [\<addObjects\>](#addobjects), [\<externalProcess\>](#externalprocess), [\<processing\>](#processing), [\<includeAttributes\>](#includeattributes), [\<excludeAttributes\>](#excludeattributes), [conditions](#conditions), [\<detects\>](#detects)
 
 Syntax:
 
@@ -1885,8 +1885,8 @@ Syntax:
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-| name | Yes, when **&lt;rules&gt;** is a child to **&lt;namedElements&gt;** <br/>No, when **&lt;rules&gt;** is a child to any other element | When *ID* is specified, any child elements aren't processed. Instead, any other **&lt;rules&gt;** elements with the same name that are declared within **&lt;namedElements&gt;** are processed. |
-| context | No <br/>(default = UserAndSystem) | Defines the scope of this parameter - whether to process this component in the context of the specific user, across the entire operating system, or both. <br/>The largest possible scope is set by the component element. For example, if a **&lt;component&gt;** element has a context of **User** and a **&lt;rules&gt;** element had a context of **UserAndSystem**, then the **&lt;rules&gt;** element would act as though it has a context of **User**. If **&lt;rules&gt;** had a context of **System**, it would act as though **&lt;rules&gt;** wasn't there. <ul><li>**User**: Evaluates the variables for each user.</li><li>**System**: Evaluates the variables only once for the system.</li><li>**UserAndSystem**: Evaluates the variables for the entire operating system and each user.</li></ul> |
+| name | Yes, when **\<rules\>** is a child to **\<namedElements\>** <br/>No, when **\<rules\>** is a child to any other element | When *ID* is specified, any child elements aren't processed. Instead, any other **\<rules\>** elements with the same name that are declared within **\<namedElements\>** are processed. |
+| context | No <br/>(default = UserAndSystem) | Defines the scope of this parameter - whether to process this component in the context of the specific user, across the entire operating system, or both. <br/>The largest possible scope is set by the component element. For example, if a **\<component\>** element has a context of **User** and a **\<rules\>** element had a context of **UserAndSystem**, then the **\<rules\>** element would act as though it has a context of **User**. If **\<rules\>** had a context of **System**, it would act as though **\<rules\>** wasn't there. <ul><li>**User**: Evaluates the variables for each user.</li><li>**System**: Evaluates the variables only once for the system.</li><li>**UserAndSystem**: Evaluates the variables for the entire operating system and each user.</li></ul> |
 
 The following example is from the MigUser.xml file:
 
@@ -1918,13 +1918,13 @@ The following example is from the MigUser.xml file:
 </component>
 ```
 
-## &lt;script&gt;
+## \<script\>
 
-The return value that is required by **&lt;script&gt;** depends on the parent element.
+The return value that is required by **\<script\>** depends on the parent element.
 
-**Number of occurrences:** Once for [&lt;variable&gt;](#variable), unlimited for [&lt;objectSet&gt;](#objectset) and [&lt;processing&gt;](#processing)
+**Number of occurrences:** Once for [\<variable\>](#variable), unlimited for [\<objectSet\>](#objectset) and [\<processing\>](#processing)
 
-**Parent elements:** [&lt;objectSet&gt;](#objectset), [&lt;variable&gt;](#variable), [&lt;processing&gt;](#processing)
+**Parent elements:** [\<objectSet\>](#objectset), [\<variable\>](#variable), [\<processing\>](#processing)
 
 **Child elements:** none
 
@@ -1932,25 +1932,25 @@ The return value that is required by **&lt;script&gt;** depends on the parent el
 
 - General Syntax: `<script>ScriptWithArguments</script>`
 
-- You can use [GetStringContent](#script-functions) when **&lt;script&gt;** is within **&lt;variable&gt;**.
+- You can use [GetStringContent](#script-functions) when **\<script\>** is within **\<variable\>**.
 
     Syntax: `<script>MigXmlHelper.GetStringContent("ObjectType","EncodedLocationPattern", "ExpandContent")</script>`
 
     Example: `<script>MigXMLHelper.GetStringContent("Registry","HKLM\Software\MyApp\Installer [EXEPATH]")</script>`
 
-- You can use [GenerateUserPatterns](#script-functions) when **&lt;script&gt;** is within **&lt;objectSet&gt;**.
+- You can use [GenerateUserPatterns](#script-functions) when **\<script\>** is within **\<objectSet\>**.
 
     Syntax: `<script>MigXmlHelper.GenerateUserPatterns("ObjectType","EncodedLocationPattern","ProcessCurrentUser")</script>`
 
     Example: `<script>MigXmlHelper.GenerateUserPatterns ("File","%USERPROFILE%\* [*.doc]", "FALSE")</script>`
 
-- You can use [GenerateDrivePatterns](#script-functions) when **&lt;script&gt;** is within **&lt;objectSet&gt;**.
+- You can use [GenerateDrivePatterns](#script-functions) when **\<script\>** is within **\<objectSet\>**.
 
     Syntax: `<script>MigXmlHelper.GenerateDrivePatterns("PatternSegment","DriveType")</script>`
 
     Example: `<script>MigXmlHelper.GenerateDrivePatterns("* [sample.doc]", "Fixed")</script>`
 
-- You can use the [Simple executing scripts](#script-functions) with **&lt;script&gt;** elements that are within **&lt;processing&gt;** elements: AskForLogoff, ConvertToShortFileName, KillExplorer, RemoveEmptyDirectories, RestartExplorer, RegisterFonts, StartService, StopService, SyncSCM.
+- You can use the [Simple executing scripts](#script-functions) with **\<script\>** elements that are within **\<processing\>** elements: AskForLogoff, ConvertToShortFileName, KillExplorer, RemoveEmptyDirectories, RestartExplorer, RegisterFonts, StartService, StopService, SyncSCM.
 
     Syntax: `<script>MigXmlHelper.ExecutingScript</script>`
 
@@ -1958,11 +1958,11 @@ The return value that is required by **&lt;script&gt;** depends on the parent el
 
 |Setting|Required?|Value|
 |--- |--- |--- |
-| *ScriptWithArguments* | Yes | A script followed by any number of string arguments that are separated by a comma and enclosed in parenthesis. For example, `MyScripts.AScript ("Arg1","Arg2")`. <br/>The script is called for each object that is enumerated by the object sets in the **&lt;include&gt;** rule. The filter script returns a Boolean value. If the return value is **TRUE**, the object is migrated. If it's **FALSE**, it isn't migrated. <br/>The return value that is required by **&lt;script&gt;** depends on the parent element. <ul><li>When used within **&lt;variable&gt;**, the return value must be a string.</li><li>When used within **&lt;objectSet&gt;**, the return value must be a two-dimensional array of strings.</li><li>When used within **&lt;location&gt;**, the return value must be a valid location that aligns with the type attribute of **&lt;location&gt;**. For example, if &lt;location type="File"&gt;, the child script element, if specified, must be a valid file location. <div class="alert">**Note**<br/>If you're migrating a file that has a bracket character ([ or ]) in the file name, insert the carrot (^) character directly before the bracket for it to be valid. For example, if there's a file named "file].txt", specify `<pattern type="File">c:\documents\mydocs [file^].txt]</pattern>` instead of `<pattern type="File">c:\documents\mydocs [file].txt]</pattern>`.</div></li></ul> |
+| *ScriptWithArguments* | Yes | A script followed by any number of string arguments that are separated by a comma and enclosed in parenthesis. For example, `MyScripts.AScript ("Arg1","Arg2")`. <br/>The script is called for each object that is enumerated by the object sets in the **\<include\>** rule. The filter script returns a Boolean value. If the return value is **TRUE**, the object is migrated. If it's **FALSE**, it isn't migrated. <br/>The return value that is required by **\<script\>** depends on the parent element. <ul><li>When used within **\<variable\>**, the return value must be a string.</li><li>When used within **\<objectSet\>**, the return value must be a two-dimensional array of strings.</li><li>When used within **\<location\>**, the return value must be a valid location that aligns with the type attribute of **\<location\>**. For example, if \<location type="File"\>, the child script element, if specified, must be a valid file location. <div class="alert">**Note**<br/>If you're migrating a file that has a bracket character ([ or ]) in the file name, insert the carrot (^) character directly before the bracket for it to be valid. For example, if there's a file named "file].txt", specify `<pattern type="File">c:\documents\mydocs [file^].txt]</pattern>` instead of `<pattern type="File">c:\documents\mydocs [file].txt]</pattern>`.</div></li></ul> |
 
 Examples:
 
-To migrate the Sample.doc file from any drive on the source computer, use **&lt;script&gt;** as follows. If multiple files exist with the same name, all such files get migrated.
+To migrate the Sample.doc file from any drive on the source computer, use **\<script\>** as follows. If multiple files exist with the same name, all such files get migrated.
 
 ```xml
 <script>MigXmlHelper.GenerateDrivePatterns("* [sample.doc]", "Fixed")</script> 
@@ -1970,9 +1970,9 @@ To migrate the Sample.doc file from any drive on the source computer, use **&lt;
 
 For more examples of how to use this element, see [Exclude Files and Settings](usmt-exclude-files-and-settings.md), [Reroute Files and Settings](usmt-reroute-files-and-settings.md), and [Custom XML Examples](usmt-custom-xml-examples.md).
 
-### &lt;script&gt; functions
+### \<script\> functions
 
-You can use the following functions with the **&lt;script&gt;** element
+You can use the following functions with the **\<script\>** element
 
 - [String and pattern generating functions](#string-and-pattern-generating-functions)
 
@@ -1984,7 +1984,7 @@ These functions return either a string or a pattern.
 
 - **GetStringContent**
 
-    You can use GetStringContent with **&lt;script&gt;** elements that are within **&lt;variable&gt;** elements. If possible, this function returns the string representation of the given object. Otherwise, it returns **NULL**. For file objects this function, always returns **NULL**.
+    You can use GetStringContent with **\<script\>** elements that are within **\<variable\>** elements. If possible, this function returns the string representation of the given object. Otherwise, it returns **NULL**. For file objects this function, always returns **NULL**.
 
     Syntax: `GetStringContent("ObjectType","EncodedLocationPattern", "ExpandContent")`
 
@@ -2004,7 +2004,7 @@ These functions return either a string or a pattern.
 
 - **GenerateDrivePatterns**
 
-  The `GenerateDrivePatterns` function iterates all of the available drives and selects the ones that match the requested drive type. It then concatenates the selected drives with the end part of *PatternSegment* to form a full encoded file pattern. For example, if *PatternSegment* is `Path [file.txt]` and *DriveType* is `Fixed`, then the function generates `C:\Path [file.txt]`, and other patterns if there are fixed drives other than C:. You can't specify environment variables with this function. You can use `GenerateDrivePatterns` with **&lt;script&gt;** elements that are within [&lt;objectSet&gt;](#objectset) that are within **&lt;include&gt;**/**&lt;exclude&gt;**.
+  The `GenerateDrivePatterns` function iterates all of the available drives and selects the ones that match the requested drive type. It then concatenates the selected drives with the end part of *PatternSegment* to form a full encoded file pattern. For example, if *PatternSegment* is `Path [file.txt]` and *DriveType* is `Fixed`, then the function generates `C:\Path [file.txt]`, and other patterns if there are fixed drives other than C:. You can't specify environment variables with this function. You can use `GenerateDrivePatterns` with **\<script\>** elements that are within [\<objectSet\>](#objectset) that are within **\<include\>**/**\<exclude\>**.
 
   Syntax: `GenerateDrivePatterns("PatternSegment","DriveType")`
 
@@ -2017,7 +2017,7 @@ These functions return either a string or a pattern.
 
 - **GenerateUserPatterns**
 
-  The `GenerateUserPatterns` function iterates through all users that are being migrated, excluding the currently processed user if **&lt;ProcessCurrentUser&gt;** is **FALSE**, and expands the specified pattern in the context of each user. For example, if users A, B, and C have profiles in `C:\Documents and Settings`, by calling `GenerateUserPattens('File','%userprofile% [*.doc]','TRUE')`, the helper function generates the following three patterns:
+  The `GenerateUserPatterns` function iterates through all users that are being migrated, excluding the currently processed user if **\<ProcessCurrentUser\>** is **FALSE**, and expands the specified pattern in the context of each user. For example, if users A, B, and C have profiles in `C:\Documents and Settings`, by calling `GenerateUserPattens('File','%userprofile% [*.doc]','TRUE')`, the helper function generates the following three patterns:
 
   - "C:\\Documents and Settings\\A\\\* \[\*.doc\]"
 
@@ -2037,7 +2037,7 @@ These functions return either a string or a pattern.
 
 If `GenerateUserPattens('File','%userprofile% [*.doc]','FALSE')` is called while USMT is processing user A, then this function only generates patterns for users B and C. You can use this helper function to build complex rules. For example, to migrate all `.doc` files from the source computer - but if user X isn't migrated, then don't migrate any of the `.doc` files from user X's profile.
 
-The following example is example code for this scenario. The first **&lt;rules&gt;** element migrates all `.doc` files on the source computer except for those inside `C:\Documents and Settings`. The second **&lt;rules&gt;** elements migrate all `.doc` files from `C:\Documents and Settings` except for the `.doc` files in the profiles of the other users. Because the second **&lt;rules&gt;** element is processed in each migrated user context, the end result is the desired behavior. The end result is the one we expected.
+The following example is example code for this scenario. The first **\<rules\>** element migrates all `.doc` files on the source computer except for those inside `C:\Documents and Settings`. The second **\<rules\>** elements migrate all `.doc` files from `C:\Documents and Settings` except for the `.doc` files in the profiles of the other users. Because the second **\<rules\>** element is processed in each migrated user context, the end result is the desired behavior. The end result is the one we expected.
 
 ```xml
 <rules context="System">
@@ -2073,7 +2073,7 @@ The `MigXmlHelper.GenerateDocPatterns` helper function invokes the document find
 |Setting|Required?|Value|
 |--- |--- |--- |
 |*ScanProgramFiles*|No (default = FALSE)|Can be **TRUE** or **FALSE**. The *ScanProgramFiles* parameter determines whether or not the document finder scans the **Program Files** directory to gather registered file extensions for known applications. For example, when set to **TRUE** it discovers and migrates .jpg files under the Photoshop directory, if `.jpg` is a file extension registered to Photoshop.|
-|*IncludePatterns*|No (default = TRUE)|Can be **TRUE** or **FALSE**. **TRUE** generates include patterns and can be added under the **&lt;include&gt;** element. **FALSE** generates exclude patterns and can be added under the **&lt;exclude&gt;** element.|
+|*IncludePatterns*|No (default = TRUE)|Can be **TRUE** or **FALSE**. **TRUE** generates include patterns and can be added under the **\<include\>** element. **FALSE** generates exclude patterns and can be added under the **\<exclude\>** element.|
 |*SystemDrive*|No (default = FALSE)|Can be **TRUE** or **FALSE**. If **TRUE**, restricts all patterns to the system drive.|
 
 ```xml
@@ -2099,7 +2099,7 @@ The `MigXmlHelper.GenerateDocPatterns` helper function invokes the document find
 
 ### Simple executing scripts
 
-The following scripts have no return value. You can use the following errors with **&lt;script&gt;** elements that are within **&lt;processing&gt;** elements
+The following scripts have no return value. You can use the following errors with **\<script\>** elements that are within **\<processing\>** elements
 
 - **AskForLogoff()**. Prompts the user to sign out at the end of the migration. For example:
 
@@ -2143,13 +2143,13 @@ The following scripts have no return value. You can use the following errors wit
 
 - **SyncSCM(ServiceShortName).** Reads the Start type value from the registry `(HKLM\System\CurrentControlSet\Services\ServiceShortName [Start])` after the value is changed by the migration engine, and then synchronizes Service Control Manager (SCM) with the new value.
 
-## &lt;text&gt;
+## \<text\>
 
-You can use the **&lt;text&gt;** element to set a value for any environment variables that are inside one of the migration .xml files.
+You can use the **\<text\>** element to set a value for any environment variables that are inside one of the migration .xml files.
 
-- **Number of occurrences:** Once in each [&lt;variable&gt;](#variable) element.
+- **Number of occurrences:** Once in each [\<variable\>](#variable) element.
 
-- **Parent elements:** [&lt;variable&gt;](#variable)
+- **Parent elements:** [\<variable\>](#variable)
 
 - **Child elements:** None.
 
@@ -2171,17 +2171,17 @@ For example:
 </variable>
 ```
 
-## &lt;unconditionalExclude&gt;
+## \<unconditionalExclude\>
 
-The **&lt;unconditionalExclude&gt;** element excludes the specified files and registry values from the migration, regardless of the other include rules in any of the migration .xml files or in the `Config.xml` file. The objects declared here aren't migrated because this element takes precedence over all other rules. For example, even if there are explicit **&lt;include&gt;** rules to include `.mp3` files, if you specify to exclude them with this option, then they aren't migrated.
+The **\<unconditionalExclude\>** element excludes the specified files and registry values from the migration, regardless of the other include rules in any of the migration .xml files or in the `Config.xml` file. The objects declared here aren't migrated because this element takes precedence over all other rules. For example, even if there are explicit **\<include\>** rules to include `.mp3` files, if you specify to exclude them with this option, then they aren't migrated.
 
 Use this element if you want to exclude all `.mp3` files from the source computer. Or, if you're backing up `C:\UserData` using another method, you can exclude the entire folder from the migration. Use this element with caution, however, because if an application needs a file that you exclude, the application might not function properly on the destination computer.
 
 - **Number of occurrences:** Unlimited.
 
-- **Parent elements:** [&lt;rules&gt;](#rules)
+- **Parent elements:** [\<rules\>](#rules)
 
-- **Child elements:** [&lt;objectSet&gt;](#objectset)
+- **Child elements:** [\<objectSet\>](#objectset)
 
 Syntax:
 
@@ -2208,21 +2208,21 @@ The following .xml file excludes all `.mp3` files from migration. For additional
 </migration>
 ```
 
-## &lt;variable&gt;
+## \<variable\>
 
-The **&lt;variable&gt;** element is required in an **&lt;environment&gt;** element. For each **&lt;variable&gt;** element there must be one **&lt;objectSet&gt;**, **&lt;script&gt;**, or **&lt;text&gt;** element. The content of the **&lt;variable&gt;** element assigns a text value to the environment variable. This element has the following three options:
+The **\<variable\>** element is required in an **\<environment\>** element. For each **\<variable\>** element there must be one **\<objectSet\>**, **\<script\>**, or **\<text\>** element. The content of the **\<variable\>** element assigns a text value to the environment variable. This element has the following three options:
 
-1. If the **&lt;variable&gt;** element contains a **&lt;text&gt;** element, then the value of the variable element is the value of the **&lt;text&gt;** element.
+1. If the **\<variable\>** element contains a **\<text\>** element, then the value of the variable element is the value of the **\<text\>** element.
 
-2. If the **&lt;variable&gt;** element contains a **&lt;script&gt;** element and the invocation of the script produces a non-null string, then the value of the **&lt;variable&gt;** element is the result of the script invocation.
+2. If the **\<variable\>** element contains a **\<script\>** element and the invocation of the script produces a non-null string, then the value of the **\<variable\>** element is the result of the script invocation.
 
-3. If the **&lt;variable&gt;** element contains an **&lt;objectSet&gt;** element and the evaluation of the **&lt;objectSet&gt;** element produces at least one object pattern, then the value of the first object to match the resulting object pattern is the value of the variable element.
+3. If the **\<variable\>** element contains an **\<objectSet\>** element and the evaluation of the **\<objectSet\>** element produces at least one object pattern, then the value of the first object to match the resulting object pattern is the value of the variable element.
 
 - **Number of occurrences:** Unlimited
 
-- **Parent elements:** [&lt;environment&gt;](#environment)
+- **Parent elements:** [\<environment\>](#environment)
 
-- **Required child elements:** either [&lt;text&gt;](#text), or [&lt;script&gt;](#script), or [&lt;objectSet&gt;](#objectset)
+- **Required child elements:** either [\<text\>](#text), or [\<script\>](#script), or [\<objectSet\>](#objectset)
 
 Syntax:
 
@@ -2249,13 +2249,13 @@ The following example is from the `MigApp.xml` file:
 </environment>
 ```
 
-## &lt;version&gt;
+## \<version\>
 
-The **&lt;version&gt;** element defines the version for the component, but doesn't affect the migration.
+The **\<version\>** element defines the version for the component, but doesn't affect the migration.
 
 - **Number of occurrences:** zero or one
 
-- **Parent elements:** [&lt;component&gt;](#component)
+- **Parent elements:** [\<component\>](#component)
 
 - **Child elements:** none
 
@@ -2275,9 +2275,9 @@ For example:
 <version>4.*</version>
 ```
 
-## &lt;windowsObjects&gt;
+## \<windowsObjects\>
 
-The **&lt;windowsObjects&gt;** element is for USMT internal use only. Don't use this element.
+The **\<windowsObjects\>** element is for USMT internal use only. Don't use this element.
 
 ## Appendix