diff --git a/core/java/android/annotation/BinderThread.java b/core/java/android/annotation/BinderThread.java
index c69ba10..6f85e04 100644
--- a/core/java/android/annotation/BinderThread.java
+++ b/core/java/android/annotation/BinderThread.java
@@ -29,10 +29,10 @@
  * on the binder thread.
  * <p>
  * Example:
- * <pre>{@code
- *  (&#64;BinderThread
+ * <pre><code>
+ *  &#64;BinderThread
  *  public BeamShareData createBeamShareData() { ... }
- * }</pre>
+ * </code></pre>
  *
  * {@hide}
  */
diff --git a/core/java/android/annotation/CallSuper.java b/core/java/android/annotation/CallSuper.java
index 82e2723..b10a28a 100644
--- a/core/java/android/annotation/CallSuper.java
+++ b/core/java/android/annotation/CallSuper.java
@@ -25,10 +25,10 @@
  * Denotes that any overriding methods should invoke this method as well.
  * <p>
  * Example:
- * <pre>{@code
+ * <pre><code>
  *  &#64;CallSuper
  *  public abstract void onFocusLost();
- * }</pre>
+ * </code></pre>
  *
  * @hide
  */
diff --git a/core/java/android/annotation/CheckResult.java b/core/java/android/annotation/CheckResult.java
index 787514e..97d031a 100644
--- a/core/java/android/annotation/CheckResult.java
+++ b/core/java/android/annotation/CheckResult.java
@@ -29,7 +29,7 @@
  * <p>
  * Example:
  * <pre>{@code
- *  public &#64;CheckResult String trim(String s) { return s.trim(); }
+ *  public @CheckResult String trim(String s) { return s.trim(); }
  *  ...
  *  s.trim(); // this is probably an error
  *  s = s.trim(); // ok
diff --git a/core/java/android/annotation/ColorInt.java b/core/java/android/annotation/ColorInt.java
index 69d196c..4671b1b 100644
--- a/core/java/android/annotation/ColorInt.java
+++ b/core/java/android/annotation/ColorInt.java
@@ -31,7 +31,7 @@
  * <p>
  * Example:
  * <pre>{@code
- *  public abstract void setTextColor(&#64;ColorInt int color);
+ *  public abstract void setTextColor(@ColorInt int color);
  * }</pre>
  *
  * @hide
diff --git a/core/java/android/annotation/FloatRange.java b/core/java/android/annotation/FloatRange.java
index 3a7c150..05b51680 100644
--- a/core/java/android/annotation/FloatRange.java
+++ b/core/java/android/annotation/FloatRange.java
@@ -28,12 +28,12 @@
  * Denotes that the annotated element should be a float or double in the given range
  * <p>
  * Example:
- * <pre>{@code
+ * <pre><code>
  *  &#64;FloatRange(from=0.0,to=1.0)
  *  public float getAlpha() {
  *      ...
  *  }
- * }</pre>
+ * </code></pre>
  *
  * @hide
  */
diff --git a/core/java/android/annotation/IntDef.java b/core/java/android/annotation/IntDef.java
index 3cae9c5..a18bfa5 100644
--- a/core/java/android/annotation/IntDef.java
+++ b/core/java/android/annotation/IntDef.java
@@ -27,25 +27,24 @@
  * named constants. If the {@link #flag()} attribute is set to true,
  * multiple constants can be combined.
  * <p>
- * Example:
- * <pre>{@code
- *  &#64;Retention(CLASS)
- *  &#64;IntDef(&#123;NAVIGATION_MODE_STANDARD, NAVIGATION_MODE_LIST, NAVIGATION_MODE_TABS&#125;)
- *  public &#64;interface NavigationMode &#123;&#125;
+ * <pre><code>
+ *  &#64;Retention(SOURCE)
+ *  &#64;IntDef({NAVIGATION_MODE_STANDARD, NAVIGATION_MODE_LIST, NAVIGATION_MODE_TABS})
+ *  public @interface NavigationMode {}
  *  public static final int NAVIGATION_MODE_STANDARD = 0;
  *  public static final int NAVIGATION_MODE_LIST = 1;
  *  public static final int NAVIGATION_MODE_TABS = 2;
  *  ...
- *  public abstract void setNavigationMode(&#64;NavigationMode int mode);
+ *  public abstract void setNavigationMode(@NavigationMode int mode);
  *  &#64;NavigationMode
  *  public abstract int getNavigationMode();
- * }</pre>
+ * </code></pre>
  * For a flag, set the flag attribute:
- * <pre>{@code
+ * <pre><code>
  *  &#64;IntDef(
  *      flag = true
- *      value = &#123;NAVIGATION_MODE_STANDARD, NAVIGATION_MODE_LIST, NAVIGATION_MODE_TABS&#125;)
- * }</pre>
+ *      value = {NAVIGATION_MODE_STANDARD, NAVIGATION_MODE_LIST, NAVIGATION_MODE_TABS})
+ * </code></pre>
  *
  * @hide
  */
diff --git a/core/java/android/annotation/IntRange.java b/core/java/android/annotation/IntRange.java
index b489c01..c043e2d 100644
--- a/core/java/android/annotation/IntRange.java
+++ b/core/java/android/annotation/IntRange.java
@@ -29,12 +29,12 @@
  * Denotes that the annotated element should be an int or long in the given range
  * <p>
  * Example:
- * <pre>{@code
+ * <pre><code>
  *  &#64;IntRange(from=0,to=255)
  *  public int getAlpha() {
  *      ...
  *  }
- * }</pre>
+ * </code></pre>
  *
  * @hide
  */
diff --git a/core/java/android/annotation/MainThread.java b/core/java/android/annotation/MainThread.java
index 18a4283..52f8dfb 100644
--- a/core/java/android/annotation/MainThread.java
+++ b/core/java/android/annotation/MainThread.java
@@ -29,10 +29,10 @@
  * on the main thread.
  * <p>
  * Example:
- * <pre>{@code
+ * <pre><code>
  *  &#64;MainThread
  *  public void deliverResult(D data) { ... }
- * }</pre>
+ * </code></pre>
  *
  * {@hide}
  */
diff --git a/core/java/android/annotation/RequiresPermission.java b/core/java/android/annotation/RequiresPermission.java
index 113c055..59d419f 100644
--- a/core/java/android/annotation/RequiresPermission.java
+++ b/core/java/android/annotation/RequiresPermission.java
@@ -32,26 +32,26 @@
  * <p/>
  * Example of requiring a single permission:
  * <pre>{@code
- *   &#64;RequiresPermission(Manifest.permission.SET_WALLPAPER)
+ *   {@literal @}RequiresPermission(Manifest.permission.SET_WALLPAPER)
  *   public abstract void setWallpaper(Bitmap bitmap) throws IOException;
  *
- *   &#64;RequiresPermission(ACCESS_COARSE_LOCATION)
+ *   {@literal @}RequiresPermission(ACCESS_COARSE_LOCATION)
  *   public abstract Location getLastKnownLocation(String provider);
  * }</pre>
  * Example of requiring at least one permission from a set:
  * <pre>{@code
- *   &#64;RequiresPermission(anyOf = {ACCESS_COARSE_LOCATION, ACCESS_FINE_LOCATION})
+ *   {@literal @}RequiresPermission(anyOf = {ACCESS_COARSE_LOCATION, ACCESS_FINE_LOCATION})
  *   public abstract Location getLastKnownLocation(String provider);
  * }</pre>
  * Example of requiring multiple permissions:
  * <pre>{@code
- *   &#64;RequiresPermission(allOf = {ACCESS_COARSE_LOCATION, ACCESS_FINE_LOCATION})
+ *   {@literal @}RequiresPermission(allOf = {ACCESS_COARSE_LOCATION, ACCESS_FINE_LOCATION})
  *   public abstract Location getLastKnownLocation(String provider);
  * }</pre>
  * Example of requiring separate read and write permissions for a content provider:
  * <pre>{@code
- *   &#64;RequiresPermission.Read(&#64;RequiresPermission(READ_HISTORY_BOOKMARKS))
- *   &#64;RequiresPermission.Write(&#64;RequiresPermission(WRITE_HISTORY_BOOKMARKS))
+ *   {@literal @}RequiresPermission.Read(@RequiresPermission(READ_HISTORY_BOOKMARKS))
+ *   {@literal @}RequiresPermission.Write(@RequiresPermission(WRITE_HISTORY_BOOKMARKS))
  *   public static final Uri BOOKMARKS_URI = Uri.parse("content://browser/bookmarks");
  * }</pre>
  * <p>
@@ -59,7 +59,7 @@
  * a permission which depends on the value of the parameter. For example, consider
  * {@link android.app.Activity#startActivity(Intent)}:
  * <pre>{@code
- *   public void startActivity(&#64;RequiresPermission Intent intent) { ... }
+ *   public void startActivity(@RequiresPermission Intent intent) { ... }
  * }</pre>
  * Notice how there are no actual permission names listed in the annotation. The actual
  * permissions required will depend on the particular intent passed in. For example,
@@ -71,7 +71,7 @@
  * and the actual permission requirement for this particular intent is described on
  * the Intent name itself:
  * <pre>{@code
- *   &#64;RequiresPermission(Manifest.permission.CALL_PHONE)
+ *   {@literal @}RequiresPermission(Manifest.permission.CALL_PHONE)
  *   public static final String ACTION_CALL = "android.intent.action.CALL";
  * }</pre>
  *
@@ -115,7 +115,7 @@
      * When specified on a parameter, the annotation indicates that the method requires
      * a permission which depends on the value of the parameter (and typically
      * the corresponding field passed in will be one of a set of constants which have
-     * been annotated with a {@code &#64;RequiresPermission} annotation.)
+     * been annotated with a <code>@RequiresPermission</code> annotation.)
      */
     @Target({FIELD, METHOD, PARAMETER})
     @interface Read {
@@ -128,7 +128,7 @@
      * When specified on a parameter, the annotation indicates that the method requires
      * a permission which depends on the value of the parameter (and typically
      * the corresponding field passed in will be one of a set of constants which have
-     * been annotated with a {@code &#64;RequiresPermission} annotation.)
+     * been annotated with a <code>@RequiresPermission</code> annotation.)
      */
     @Target({FIELD, METHOD, PARAMETER})
     @interface Write {
diff --git a/core/java/android/annotation/Size.java b/core/java/android/annotation/Size.java
index 389b819..7c3e70f 100644
--- a/core/java/android/annotation/Size.java
+++ b/core/java/android/annotation/Size.java
@@ -31,7 +31,7 @@
  * <p>
  * Example:
  * <pre>{@code
- *  public void getLocationInWindow(&#64;Size(2) int[] location) {
+ *  public void getLocationInWindow(@Size(2) int[] location) {
  *      ...
  *  }
  * }</pre>
diff --git a/core/java/android/annotation/StringDef.java b/core/java/android/annotation/StringDef.java
index 5f7f380..8c8d5d8 100644
--- a/core/java/android/annotation/StringDef.java
+++ b/core/java/android/annotation/StringDef.java
@@ -26,20 +26,20 @@
  * type and that its value should be one of the explicitly named constants.
  * <p>
  * Example:
- * <pre>{@code
+ * <pre><code>
  *  &#64;Retention(SOURCE)
- *  &#64;StringDef(&#123;
+ *  &#64;StringDef({
  *     POWER_SERVICE,
  *     WINDOW_SERVICE,
  *     LAYOUT_INFLATER_SERVICE
- *  &#125;)
- *  public &#64;interface ServiceName &#123;&#125;
+ *  })
+ *  public @interface ServiceName {}
  *  public static final String POWER_SERVICE = "power";
  *  public static final String WINDOW_SERVICE = "window";
  *  public static final String LAYOUT_INFLATER_SERVICE = "layout_inflater";
  *  ...
- *  public abstract Object getSystemService(&#64;ServiceName String name);
- * }</pre>
+ *  public abstract Object getSystemService(@ServiceName String name);
+ * </code></pre>
  *
  * @hide
  */
diff --git a/core/java/android/annotation/UiThread.java b/core/java/android/annotation/UiThread.java
index b814600..53121e7 100644
--- a/core/java/android/annotation/UiThread.java
+++ b/core/java/android/annotation/UiThread.java
@@ -29,10 +29,10 @@
  * on the UI thread.
  * <p>
  * Example:
- * <pre>{@code
+ * <pre><code>
  *  &#64;UiThread
- *  public abstract void setText(&#64;NonNull String text) { ... }
- * }</pre>
+ *  public abstract void setText(@NonNull String text) { ... }
+ * </code></pre>
  *
  * {@hide}
  */
diff --git a/core/java/android/annotation/WorkerThread.java b/core/java/android/annotation/WorkerThread.java
index dd12e05..0d2c43e 100644
--- a/core/java/android/annotation/WorkerThread.java
+++ b/core/java/android/annotation/WorkerThread.java
@@ -29,10 +29,10 @@
  * on a worker thread.
  * <p>
  * Example:
- * <pre>{@code
- *  (&#64;WorkerThread
+ * <pre><code>
+ *  &#64;WorkerThread
  *  protected abstract FilterResults performFiltering(CharSequence constraint);
- * }</pre>
+ * </code></pre>
  *
  * {@hide}
  */
diff --git a/core/java/android/app/ActivityManager.java b/core/java/android/app/ActivityManager.java
index f7aee75..0b94632 100644
--- a/core/java/android/app/ActivityManager.java
+++ b/core/java/android/app/ActivityManager.java
@@ -81,9 +81,9 @@
 
     /**
      * <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code
-     * &lt;meta-data>}</a> name for a 'home' Activity that declares a package that is to be
+     * <meta-data>}</a> name for a 'home' Activity that declares a package that is to be
      * uninstalled in lieu of the declaring one.  The package named here must be
-     * signed with the same certificate as the one declaring the {@code &lt;meta-data>}.
+     * signed with the same certificate as the one declaring the {@code <meta-data>}.
      */
     public static final String META_HOME_ALTERNATE = "android.app.home.alternate";
 
diff --git a/core/java/android/hardware/Camera.java b/core/java/android/hardware/Camera.java
index 73bb426..8a87bff 100644
--- a/core/java/android/hardware/Camera.java
+++ b/core/java/android/hardware/Camera.java
@@ -2891,8 +2891,7 @@
          * <var>y</var> for the Y plane and row <var>c</var> for the U and V
          * planes:
          *
-         * {@code
-         * <pre>
+         * <pre>{@code
          * yStride   = (int) ceil(width / 16.0) * 16;
          * uvStride  = (int) ceil( (yStride / 2) / 16.0) * 16;
          * ySize     = yStride * height;
@@ -2900,8 +2899,9 @@
          * yRowIndex = yStride * y;
          * uRowIndex = ySize + uvSize + uvStride * c;
          * vRowIndex = ySize + uvStride * c;
-         * size      = ySize + uvSize * 2;</pre>
+         * size      = ySize + uvSize * 2;
          * }
+         *</pre>
          *
          * @param pixel_format the desired preview picture format, defined by
          *   one of the {@link android.graphics.ImageFormat} constants.  (E.g.,
diff --git a/core/java/android/hardware/package.html b/core/java/android/hardware/package.html
index 5b04da1..ee54476 100644
--- a/core/java/android/hardware/package.html
+++ b/core/java/android/hardware/package.html
@@ -4,6 +4,6 @@
 not all Android-powered devices support all hardware features, so you should declare hardware
 that your application requires using the <a
 href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code
-&lt;uses-feature&gt;}</a> manifest element.</p>
+<uses-feature>}</a> manifest element.</p>
 </BODY>
 </HTML>
diff --git a/core/java/android/net/PskKeyManager.java b/core/java/android/net/PskKeyManager.java
index f82e635..667abb4 100644
--- a/core/java/android/net/PskKeyManager.java
+++ b/core/java/android/net/PskKeyManager.java
@@ -97,7 +97,7 @@
  *
  * SSLContext sslContext = SSLContext.getInstance("TLS");
  * sslContext.init(
- *         new KeyManager[] &#123;pskKeyManager&#125;,
+ *         new KeyManager[] { pskKeyManager },
  *         new TrustManager[0], // No TrustManagers needed for TLS-PSK
  *         null // Use the default source of entropy
  *         );
diff --git a/core/java/android/nfc/NfcAdapter.java b/core/java/android/nfc/NfcAdapter.java
index b492deb..ff6eb40 100644
--- a/core/java/android/nfc/NfcAdapter.java
+++ b/core/java/android/nfc/NfcAdapter.java
@@ -914,7 +914,7 @@
      *
      * <p>If you want to prevent the Android OS from sending default NDEF
      * messages completely (for all activities), you can include a
-     * {@code &lt;meta-data>} element inside the {@code &lt;application>}
+     * {@code <meta-data>} element inside the {@code <application>}
      * element of your AndroidManifest.xml file, like this:
      * <pre>
      * &lt;application ...>
@@ -1022,7 +1022,7 @@
      *
      * <p>If you want to prevent the Android OS from sending default NDEF
      * messages completely (for all activities), you can include a
-     * {@code &lt;meta-data>} element inside the {@code &lt;application>}
+     * {@code <meta-data>} element inside the {@code <application>}
      * element of your AndroidManifest.xml file, like this:
      * <pre>
      * &lt;application ...>
diff --git a/core/java/android/os/PowerManager.java b/core/java/android/os/PowerManager.java
index 1cffa83..a0a0060 100644
--- a/core/java/android/os/PowerManager.java
+++ b/core/java/android/os/PowerManager.java
@@ -96,7 +96,7 @@
  * </table>
  * <p>
  * Any application using a WakeLock must request the {@code android.permission.WAKE_LOCK}
- * permission in an {@code &lt;uses-permission&gt;} element of the application's manifest.
+ * permission in an {@code <uses-permission>} element of the application's manifest.
  * </p>
  */
 public final class PowerManager {
@@ -1033,7 +1033,7 @@
      * to have the device stay on.
      * <p>
      * Any application using a WakeLock must request the {@code android.permission.WAKE_LOCK}
-     * permission in an {@code &lt;uses-permission&gt;} element of the application's manifest.
+     * permission in an {@code <uses-permission>} element of the application's manifest.
      * Obtain a wake lock by calling {@link PowerManager#newWakeLock(int, String)}.
      * </p><p>
      * Call {@link #acquire()} to acquire the wake lock and force the device to stay
diff --git a/core/java/android/service/dreams/DreamService.java b/core/java/android/service/dreams/DreamService.java
index 0171869..bb46e83 100644
--- a/core/java/android/service/dreams/DreamService.java
+++ b/core/java/android/service/dreams/DreamService.java
@@ -98,7 +98,7 @@
  * &lt;/service>
  * </pre>
  *
- * <p>If specified with the {@code &lt;meta-data&gt;} element,
+ * <p>If specified with the {@code <meta-data>} element,
  * additional information for the dream is defined using the
  * {@link android.R.styleable#Dream &lt;dream&gt;} element in a separate XML file.
  * Currently, the only addtional
diff --git a/core/java/android/service/textservice/package.html b/core/java/android/service/textservice/package.html
index 0b5113b..4124922 100644
--- a/core/java/android/service/textservice/package.html
+++ b/core/java/android/service/textservice/package.html
@@ -12,9 +12,9 @@
 
 <p>Applications with a spell checker service must declare the {@link
 android.Manifest.permission#BIND_TEXT_SERVICE} permission as required by the service. The service
-must also declare an intent filter with {@code &lt;action
+must also declare an intent filter with {@code <action
 android:name="android.service.textservice.SpellCheckerService" />} as the intent’s action and should
-include a {@code &lt;meta-data&gt;} element that declares configuration information for the spell
+include a {@code <meta-data>} element that declares configuration information for the spell
 checker. For example:</p>
 
 <pre>
diff --git a/core/java/android/speech/RecognitionListener.java b/core/java/android/speech/RecognitionListener.java
index bdb3ba9..1ffdf08 100644
--- a/core/java/android/speech/RecognitionListener.java
+++ b/core/java/android/speech/RecognitionListener.java
@@ -69,7 +69,7 @@
      * Called when recognition results are ready.
      * 
      * @param results the recognition results. To retrieve the results in {@code
-     *        ArrayList&lt;String&gt;} format use {@link Bundle#getStringArrayList(String)} with
+     *        ArrayList<String>} format use {@link Bundle#getStringArrayList(String)} with
      *        {@link SpeechRecognizer#RESULTS_RECOGNITION} as a parameter. A float array of
      *        confidence values might also be given in {@link SpeechRecognizer#CONFIDENCE_SCORES}.
      */
diff --git a/core/java/android/speech/RecognitionService.java b/core/java/android/speech/RecognitionService.java
index 3e74d22..674f809 100644
--- a/core/java/android/speech/RecognitionService.java
+++ b/core/java/android/speech/RecognitionService.java
@@ -303,7 +303,7 @@
          * The service should call this method when recognition results are ready.
          * 
          * @param results the recognition results. To retrieve the results in {@code
-         *        ArrayList&lt;String&gt;} format use {@link Bundle#getStringArrayList(String)} with
+         *        ArrayList<String>} format use {@link Bundle#getStringArrayList(String)} with
          *        {@link SpeechRecognizer#RESULTS_RECOGNITION} as a parameter
          */
         public void results(Bundle results) throws RemoteException {
diff --git a/core/java/android/text/format/Time.java b/core/java/android/text/format/Time.java
index d567d90..66e2ec3 100644
--- a/core/java/android/text/format/Time.java
+++ b/core/java/android/text/format/Time.java
@@ -842,7 +842,7 @@
      * the given time.
      *
      * <p>
-     * Equivalent to {@code Time.compare(this, that) &lt; 0}. See
+     * Equivalent to {@code Time.compare(this, that) < 0}. See
      * {@link #compare(Time, Time)} for details.
      *
      * @param that a given Time object to compare against
@@ -858,7 +858,7 @@
      * the given time.
      *
      * <p>
-     * Equivalent to {@code Time.compare(this, that) &gt; 0}. See
+     * Equivalent to {@code Time.compare(this, that) > 0}. See
      * {@link #compare(Time, Time)} for details.
      *
      * @param that a given Time object to compare against
diff --git a/core/java/android/transition/ArcMotion.java b/core/java/android/transition/ArcMotion.java
index 70dfe7f..fa4c8d2 100644
--- a/core/java/android/transition/ArcMotion.java
+++ b/core/java/android/transition/ArcMotion.java
@@ -36,13 +36,12 @@
  * arc between two points.
  * </p>
  * <p>This may be used in XML as an element inside a transition.</p>
- * <pre>
- * {@code
- * &lt;changeBounds>
- *   &lt;arcMotion android:minimumHorizontalAngle="15"
+ * <pre>{@code
+ * <changeBounds>
+ *   <arcMotion android:minimumHorizontalAngle="15"
  *              android:minimumVerticalAngle="0"
  *              android:maximumAngle="90"/>
- * &lt;/changeBounds>}
+ * </changeBounds>}
  * </pre>
  */
 public class ArcMotion extends PathMotion {
diff --git a/core/java/android/transition/PathMotion.java b/core/java/android/transition/PathMotion.java
index 651223d..01102a4 100644
--- a/core/java/android/transition/PathMotion.java
+++ b/core/java/android/transition/PathMotion.java
@@ -31,9 +31,9 @@
  * <p>This may be used in XML as an element inside a transition.</p>
  * <pre>
  * {@code
- * &lt;changeBounds>
- *     &lt;pathMotion class="my.app.transition.MyPathMotion"/>
- * &lt;/changeBounds>
+ * <changeBounds>
+ *     <pathMotion class="my.app.transition.MyPathMotion"/>
+ * </changeBounds>
  * }
  * </pre>
  */
diff --git a/core/java/android/transition/PatternPathMotion.java b/core/java/android/transition/PatternPathMotion.java
index 773c387..f23863f 100644
--- a/core/java/android/transition/PatternPathMotion.java
+++ b/core/java/android/transition/PatternPathMotion.java
@@ -30,11 +30,10 @@
  * The starting point of the Path will be moved to the origin and the end point will be scaled
  * and rotated so that it matches with the target end point.
  * <p>This may be used in XML as an element inside a transition.</p>
- * <pre>
- * {@code
- * &lt;changeBounds>
- *     &lt;patternPathMotion android:patternPathData="M0 0 L0 100 L100 100"/>
- * &lt;/changeBounds>}
+ * <pre>{@code
+ * <changeBounds>
+ *     <patternPathMotion android:patternPathData="M0 0 L0 100 L100 100"/>
+ * </changeBounds>}
  * </pre>
  */
 public class PatternPathMotion extends PathMotion {
diff --git a/core/java/android/transition/Transition.java b/core/java/android/transition/Transition.java
index e958058..48614c0 100644
--- a/core/java/android/transition/Transition.java
+++ b/core/java/android/transition/Transition.java
@@ -2052,18 +2052,18 @@
      *     attributed with the fully-described class name. For example:</p>
      * <pre>
      * {@code
-     * &lt;changeBounds>
-     *     &lt;pathMotion class="my.app.transition.MyPathMotion"/>
-     * &lt;/changeBounds>
+     * <changeBounds>
+     *     <pathMotion class="my.app.transition.MyPathMotion"/>
+     * </changeBounds>
      * }
      * </pre>
      * <p>or</p>
      * <pre>
      * {@code
-     * &lt;changeBounds>
-     *   &lt;arcMotion android:minimumHorizontalAngle="15"
+     * <changeBounds>
+     *   <arcMotion android:minimumHorizontalAngle="15"
      *     android:minimumVerticalAngle="0" android:maximumAngle="90"/>
-     * &lt;/changeBounds>
+     * </changeBounds>
      * }
      * </pre>
      *
@@ -2090,20 +2090,18 @@
      *     the built-in tags <code>arcMotion</code> or <code>patternPathMotion</code> or it can
      *     be a custom PathMotion using <code>pathMotion</code> with the <code>class</code>
      *     attributed with the fully-described class name. For example:</p>
-     * <pre>
-     * {@code
-     * &lt;changeBounds>
-     *     &lt;pathMotion class="my.app.transition.MyPathMotion"/>
-     * &lt;/changeBounds>}
+     * <pre>{@code
+     * <changeBounds>
+     *     <pathMotion class="my.app.transition.MyPathMotion"/>
+     * </changeBounds>}
      * </pre>
      * <p>or</p>
-     * <pre>
-     * {@code
-     * &lt;changeBounds>
-     *   &lt;arcMotion android:minimumHorizontalAngle="15"
+     * <pre>{@code
+     * <changeBounds>
+     *   <arcMotion android:minimumHorizontalAngle="15"
      *              android:minimumVerticalAngle="0"
      *              android:maximumAngle="90"/>
-     * &lt;/changeBounds>}
+     * </changeBounds>}
      * </pre>
      *
      * @return The algorithm object used to interpolate along two dimensions.
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index ab1943c..956fde4 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -580,7 +580,7 @@
  * <p>
  * Tags may be specified with character sequence values in layout XML as either
  * a single tag using the {@link android.R.styleable#View_tag android:tag}
- * attribute or multiple tags using the {@code &lt;tag&gt;} child element:
+ * attribute or multiple tags using the {@code <tag>} child element:
  * <pre>
  *     &ltView ...
  *           android:tag="@string/mytag_value" /&gt;
diff --git a/core/java/android/view/inputmethod/InputMethodInfo.java b/core/java/android/view/inputmethod/InputMethodInfo.java
index 4ac547a..4fc6665 100644
--- a/core/java/android/view/inputmethod/InputMethodInfo.java
+++ b/core/java/android/view/inputmethod/InputMethodInfo.java
@@ -48,7 +48,7 @@
 /**
  * This class is used to specify meta information of an input method.
  *
- * <p>It should be defined in an XML resource file with an {@code &lt;input-method>} element.
+ * <p>It should be defined in an XML resource file with an {@code <input-method>} element.
  * For more information, see the guide to
  * <a href="{@docRoot}guide/topics/text/creating-input-method.html">
  * Creating an Input Method</a>.</p>
diff --git a/core/java/android/view/inputmethod/InputMethodSubtype.java b/core/java/android/view/inputmethod/InputMethodSubtype.java
index 4ee155c..fbaf51c 100644
--- a/core/java/android/view/inputmethod/InputMethodSubtype.java
+++ b/core/java/android/view/inputmethod/InputMethodSubtype.java
@@ -41,7 +41,7 @@
  * the specified subtype of the designated IME directly.
  *
  * <p>It should be defined in an XML resource file of the input method with the
- * <code>&lt;subtype&gt;</code> element, which resides within an {@code &lt;input-method>} element.
+ * <code>&lt;subtype&gt;</code> element, which resides within an {@code <input-method>} element.
  * For more information, see the guide to
  * <a href="{@docRoot}guide/topics/text/creating-input-method.html">
  * Creating an Input Method</a>.</p>
diff --git a/core/java/android/webkit/WebView.java b/core/java/android/webkit/WebView.java
index 358f939..7443bce 100644
--- a/core/java/android/webkit/WebView.java
+++ b/core/java/android/webkit/WebView.java
@@ -93,7 +93,7 @@
  * </pre>
  * <p>See {@link android.content.Intent} for more information.</p>
  *
- * <p>To provide a WebView in your own Activity, include a {@code &lt;WebView&gt;} in your layout,
+ * <p>To provide a WebView in your own Activity, include a {@code <WebView>} in your layout,
  * or set the entire Activity window as a WebView during {@link
  * android.app.Activity#onCreate(Bundle) onCreate()}:</p>
  * <pre class="prettyprint">
diff --git a/core/java/android/widget/ProgressBar.java b/core/java/android/widget/ProgressBar.java
index 04c68ae..2099b04 100644
--- a/core/java/android/widget/ProgressBar.java
+++ b/core/java/android/widget/ProgressBar.java
@@ -121,7 +121,7 @@
  *     }
  * }</pre>
  *
- * <p>To add a progress bar to a layout file, you can use the {@code &lt;ProgressBar&gt;} element.
+ * <p>To add a progress bar to a layout file, you can use the {@code <ProgressBar>} element.
  * By default, the progress bar is a spinning wheel (an indeterminate indicator). To change to a
  * horizontal progress bar, apply the {@link android.R.style#Widget_ProgressBar_Horizontal
  * Widget.ProgressBar.Horizontal} style, like so:</p>
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index 57338be..aba44a5 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -709,8 +709,8 @@
 
     <!-- Required to be able to access the camera device.
          <p>This will automatically enforce the <a
-         href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code
-         &lt;uses-feature&gt;}</a> manifest element for <em>all</em> camera features.
+         href="{@docRoot}guide/topics/manifest/uses-feature-element.html">
+         <uses-feature>}</a> manifest element for <em>all</em> camera features.
          If you do not require all camera features or can properly operate if a camera
          is not available, then you must modify your manifest as appropriate in order to
          install on devices that don't support all camera features.</p>
diff --git a/core/res/res/values/attrs_manifest.xml b/core/res/res/values/attrs_manifest.xml
index 67933cd..2a11081 100644
--- a/core/res/res/values/attrs_manifest.xml
+++ b/core/res/res/values/attrs_manifest.xml
@@ -634,7 +634,7 @@
          specified, it will run in the current preferred orientation
          of the screen.
          <p>This attribute is supported by the <a
-            href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a>
+            href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
             element. -->
     <attr name="screenOrientation">
         <!-- No preference specified: let the system decide the best
@@ -923,8 +923,8 @@
         <enum name="preferExternal" value="2" />
     </attr>
 
-    <!-- Extra options for an activity's UI. Applies to either the {@code &lt;activity&gt;} or
-         {@code &lt;application&gt;} tag. If specified on the {@code &lt;application&gt;}
+    <!-- Extra options for an activity's UI. Applies to either the {@code <activity>} or
+         {@code <application>} tag. If specified on the {@code <application>}
          tag these will be considered defaults for all activities in the
          application. -->
     <attr name="uiOptions">
diff --git a/core/res/res/values/themes_holo.xml b/core/res/res/values/themes_holo.xml
index d9599b3..4cbaacb 100644
--- a/core/res/res/values/themes_holo.xml
+++ b/core/res/res/values/themes_holo.xml
@@ -46,7 +46,7 @@
          with API level 14, the default system theme is supplied by {@link #Theme_DeviceDefault},
          which might apply a different style on different devices. If you want to ensure that your
          app consistently uses the Holo theme at all times, you must explicitly declare it in your
-         manifest. For example, {@code &lt;application android:theme="@android:style/Theme.Holo"&gt;}.
+         manifest. For example, {@code <application android:theme="@android:style/Theme.Holo">}.
          For more information, read <a
          href="http://android-developers.blogspot.com/2012/01/holo-everywhere.html">Holo
          Everywhere</a>.</p>
diff --git a/core/res/res/values/themes_material.xml b/core/res/res/values/themes_material.xml
index a5b8476..b011094 100644
--- a/core/res/res/values/themes_material.xml
+++ b/core/res/res/values/themes_material.xml
@@ -33,7 +33,7 @@
     <!-- Material theme (dark version).
          <p>If you want to ensure that your
          app consistently uses the Material theme at all times, you must explicitly declare it in your
-         manifest. For example, {@code &lt;application android:theme="@style/Theme.Material"&gt;}.
+         manifest. For example, {@code <application android:theme="@style/Theme.Material">}.
 
          <p>Styles used by the Material theme are named using the convention Type.Material.Etc
          (for example, {@code Widget.Material.Button} and {@code
diff --git a/docs/html-intl/intl/es/distribute/googleplay/quality/tv.jd b/docs/html-intl/intl/es/distribute/googleplay/quality/tv.jd
index 8645858..e291e7c 100644
--- a/docs/html-intl/intl/es/distribute/googleplay/quality/tv.jd
+++ b/docs/html-intl/intl/es/distribute/googleplay/quality/tv.jd
@@ -320,7 +320,7 @@
   <td>
     <p style="margin-bottom:.5em;">
       Si la aplicación utiliza un controlador para juegos como su método de entrada principal, debe declarar el requisito
- correspondiente con la etiqueta del manifiesto <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>.
+ correspondiente con la etiqueta del manifiesto <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>.
       (<a href="{@docRoot}training/tv/games/index.html#gamepad">Obtén más información</a>)
     </p>
   </td>
diff --git a/docs/html-intl/intl/es/google/play/filters.jd b/docs/html-intl/intl/es/google/play/filters.jd
index d4890dc..03565b9 100644
--- a/docs/html-intl/intl/es/google/play/filters.jd
+++ b/docs/html-intl/intl/es/google/play/filters.jd
@@ -329,23 +329,23 @@
   <tr><th>Elemento del manifiesto</th><th>Resumen:</th></tr>
   <tr>
     <td><nobr><a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a></nobr></td>
+<compatible-screens>}</a></nobr></td>
     <td>
       <p>Google Play filtra la aplicación si el tamaño de pantalla del dispositivo no coincide con
- ninguna de las configuraciones de pantalla (declaradas por un elemento {@code &lt;screen&gt;}) en el elemento {@code
-&lt;compatible-screens&gt;}.</p>
+ ninguna de las configuraciones de pantalla (declaradas por un elemento {@code <screen>}) en el elemento {@code
+<compatible-screens>}.</p>
       <p class="caution"><strong>Advertencia:</strong> Normalmente, <strong>no deberías usar este elemento
  del manifiesto</strong>. El uso de este elemento puede reducir
  notablemente la base de usuarios potenciales para tu aplicación, al excluir todas las combinaciones de tamaño de pantalla
  y densidad que no indicaste. En su lugar, debes usar el elemento del manifiesto <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> (descrito anteriormente en la <a href="#table1">tabla
+<supports-screens>}</a> (descrito anteriormente en la <a href="#table1">tabla
 1</a>) para habilitar el modo de compatibilidad de pantalla para las configuraciones de pantalla que no abarcaste
  con recursos adicionales.</p>
     </td>
   </tr>
   <tr>
     <td><nobr><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a></nobr></td>
+<supports-gl-texture>}</a></nobr></td>
     <td>
       <p>Google Play filtrará la aplicación a menos que uno o más de los formatos de compresión
  de texturas GL compatibles con la aplicación también sean compatibles con el dispositivo. </p>
@@ -408,16 +408,16 @@
 <ul>
   <li>Formatos de compresión de texturas OpenGL
     <p>Mediante el uso del elemento <a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a>.</p>
+<supports-gl-texture>}</a>.</p>
   </li>
   <li>Tamaño de pantalla (y, opcionalmente, densidad de la pantalla)
     <p>Mediante el uso del elemento <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> o <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a>.</p>
+<supports-screens>}</a> o <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
+<compatible-screens>}</a>.</p>
   </li>
   <li>Nivel de API
     <p>Mediante el uso del elemento <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code
-&lt;uses-sdk&gt;}</a>.</p>
+<uses-sdk>}</a>.</p>
   </li>
   <li>Arquitectura de CPU (ABI)
     <p>Mediante la inclusión de bibliotecas nativas creadas con el <a href="{@docRoot}tools/sdk/ndk/index.html">NDK de
diff --git a/docs/html-intl/intl/es/preview/api-overview.jd b/docs/html-intl/intl/es/preview/api-overview.jd
index 9f68613..1f3e9bf 100644
--- a/docs/html-intl/intl/es/preview/api-overview.jd
+++ b/docs/html-intl/intl/es/preview/api-overview.jd
@@ -133,8 +133,8 @@
 <pre class="no-prettyprint">
 adb -e emu finger touch &lt;finger_id&gt;
 </pre>
-<p>En Windows, posiblemente tenga que ejecutar {@code telnet 127.0.0.1 &lt;emulator-id&gt;} seguido de
-  {@code finger touch &lt;finger_id&gt;}.
+<p>En Windows, posiblemente tenga que ejecutar {@code telnet 127.0.0.1 <emulator-id>} seguido de
+  {@code finger touch <finger_id>}.
 </p>
 </li>
 </ol>
@@ -192,7 +192,7 @@
 </pre>
 
 <p>Para cada actividad que desee exponer a {@code ChooserTargetService}, agregue un elemento
-{@code &lt;meta-data&gt;} con el nombre
+{@code <meta-data>} con el nombre
 {@code "android.service.chooser.chooser_target_service"} en el manifiesto de su aplicación.
 </p>
 
diff --git a/docs/html-intl/intl/ja/distribute/googleplay/quality/tv.jd b/docs/html-intl/intl/ja/distribute/googleplay/quality/tv.jd
index 4c64184f..4c0e478 100644
--- a/docs/html-intl/intl/ja/distribute/googleplay/quality/tv.jd
+++ b/docs/html-intl/intl/ja/distribute/googleplay/quality/tv.jd
@@ -286,7 +286,7 @@
   </td>
   <td>
     <p style="margin-bottom:.5em;">
-      アプリがその主要な入力方式としてゲーム コントローラを使用する場合、<a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a> マニフェスト タグで適切な要件を宣言しています。（<a href="{@docRoot}training/tv/games/index.html#gamepad">こちらを参照してください</a>）
+      アプリがその主要な入力方式としてゲーム コントローラを使用する場合、<a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> マニフェスト タグで適切な要件を宣言しています。（<a href="{@docRoot}training/tv/games/index.html#gamepad">こちらを参照してください</a>）
     </p>
   </td>
 </tr>
diff --git a/docs/html-intl/intl/ja/google/play/filters.jd b/docs/html-intl/intl/ja/google/play/filters.jd
index a1b9ec0..5ab6336 100644
--- a/docs/html-intl/intl/ja/google/play/filters.jd
+++ b/docs/html-intl/intl/ja/google/play/filters.jd
@@ -208,14 +208,14 @@
 <table>
   <tr><th>マニフェスト要素</th><th>概要</th></tr>
   <tr>
-    <td><nobr><a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code &lt;compatible-screens&gt;}</a></nobr></td>
+    <td><nobr><a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code <compatible-screens>}</a></nobr></td>
     <td>
-      <p>Google Play はデバイス画面サイズと密度が {@code &lt;compatible-screens&gt;} の要素の画面設定（{@code &lt;screen&gt;} 要素で宣言）のいずれにも適合しない場合、アプリをフィルタリングします。</p>
-      <p class="caution"><strong>警告:</strong> 通常は、<strong>このマニフェスト要素を使用すべきではありません</strong>。この要素を使用すると、指定していない画面サイズと密度のすべての組み合わせが除外されることになり、アプリの潜在的なユーザー ベースが大幅に減少する可能性があります。代わりに <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code &lt;supports-screens&gt;}</a> マニフェスト要素（<a href="#table1">表 1</a> に記載）を使用して、考慮に入れていない画面設定に対して、代替リソースを使用した画面の互換性モードを有効にすることをお勧めします。</p>
+      <p>Google Play はデバイス画面サイズと密度が {@code <compatible-screens>} の要素の画面設定（{@code <screen>} 要素で宣言）のいずれにも適合しない場合、アプリをフィルタリングします。</p>
+      <p class="caution"><strong>警告:</strong> 通常は、<strong>このマニフェスト要素を使用すべきではありません</strong>。この要素を使用すると、指定していない画面サイズと密度のすべての組み合わせが除外されることになり、アプリの潜在的なユーザー ベースが大幅に減少する可能性があります。代わりに <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code <supports-screens>}</a> マニフェスト要素（<a href="#table1">表 1</a> に記載）を使用して、考慮に入れていない画面設定に対して、代替リソースを使用した画面の互換性モードを有効にすることをお勧めします。</p>
     </td>
   </tr>
   <tr>
-    <td><nobr><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code &lt;supports-gl-texture&gt;}</a></nobr></td>
+    <td><nobr><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code <supports-gl-texture>}</a></nobr></td>
     <td>
       <p>Google Play はアプリでサポートされる 1 つ以上の GL テクスチャ圧縮フォーマットがデバイスで同様にサポートされない場合、アプリをフィルタリングします。 </p>
     </td>
@@ -249,11 +249,11 @@
 
 <p>現時点では、Google Play では各 APK が次の設定に基づいて別々のフィルタを提供する際にのみ、同じアプリの複数の APK を公開できます。</p>
 <ul>
-  <li>OpenGL テクスチャ圧縮フォーマット <p><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code &lt;supports-gl-texture&gt;}</a> 要素の使用による。</p>
+  <li>OpenGL テクスチャ圧縮フォーマット <p><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code <supports-gl-texture>}</a> 要素の使用による。</p>
   </li>
-  <li>画面サイズ（画面密度も指定可能） <p><a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code &lt;supports-screens&gt;}</a>要素または<a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code &lt;compatible-screens&gt;}</a> 要素の使用による。</p>
+  <li>画面サイズ（画面密度も指定可能） <p><a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code <supports-screens>}</a>要素または<a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code <compatible-screens>}</a> 要素の使用による。</p>
   </li>
-  <li>API レベル <p><a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk&gt;}</a> 要素の使用による。</p>
+  <li>API レベル <p><a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a> 要素の使用による。</p>
   </li>
   <li>CPU アーキテクチャ（ABI） <p>特定の CPU アーキテクチャ（ARM EABI v7 または x86 など）を対象とする<a href="{@docRoot}tools/sdk/ndk/index.html"> Android NDK</a> で構築されたネイティブ ライブラリの組み込みによる。</p>
   </li>
diff --git a/docs/html-intl/intl/ja/guide/topics/fundamentals.jd b/docs/html-intl/intl/ja/guide/topics/fundamentals.jd
index cf9f7dd..d76c92e 100644
--- a/docs/html-intl/intl/ja/guide/topics/fundamentals.jd
+++ b/docs/html-intl/intl/ja/guide/topics/fundamentals.jd
@@ -329,7 +329,7 @@
 <p style="margin-left: 2em">{@code FLAG_ACTIVITY_NEW_TASK} <br/>{@code FLAG_ACTIVITY_CLEAR_TOP} <br/>{@code FLAG_ACTIVITY_RESET_TASK_IF_NEEDED} <br/>{@code FLAG_ACTIVITY_SINGLE_TOP}</p>
 
 <p>
-また、主に使用する {@code &lt;activity&gt;} 属性は以下のとおりです:
+また、主に使用する {@code <activity>} 属性は以下のとおりです:
   
 <p style="margin-left: 2em">{@code taskAffinity} <br/>{@code launchMode} <br/>{@code allowTaskReparenting} <br/>{@code clearTaskOnLaunch} <br/>{@code alwaysRetainTaskState} <br/>{@code finishOnTaskLaunch}</p>
 
@@ -341,7 +341,7 @@
 <h3 id="afftask">親和性と新しいタスク</h3>
 
 <p>
-デフォルトでは、アプリケーション内のすべてのアクティビティは相互に親和性があり、すべてのアクティビティができる限り同じタスクに属そうとします。<i></i>ただし、{@code &lt;activity&gt;} 要素の {@code taskAffinity} 属性を使用して、アクティビティごとに個別の親和性を設定することもできます。つまり、別々のアプリケーションで定義されているアクティビティで親和性を共有したり、同じアプリケーションで定義されているアクティビティに別々の親和性を割り当てたりできるということです。親和性が作用する状況は 2 つあります。1 つはアクティビティを起動する Intent オブジェクトに {@code FLAG_ACTIVITY_NEW_TASK} フラグが含まれている場合、もう 1 つはアクティビティの {@code allowTaskReparenting} 属性が "{@code true}" に設定されている場合です。 
+デフォルトでは、アプリケーション内のすべてのアクティビティは相互に親和性があり、すべてのアクティビティができる限り同じタスクに属そうとします。<i></i>ただし、{@code <activity>} 要素の {@code taskAffinity} 属性を使用して、アクティビティごとに個別の親和性を設定することもできます。つまり、別々のアプリケーションで定義されているアクティビティで親和性を共有したり、同じアプリケーションで定義されているアクティビティに別々の親和性を割り当てたりできるということです。親和性が作用する状況は 2 つあります。1 つはアクティビティを起動する Intent オブジェクトに {@code FLAG_ACTIVITY_NEW_TASK} フラグが含まれている場合、もう 1 つはアクティビティの {@code allowTaskReparenting} 属性が "{@code true}" に設定されている場合です。
 </p>
 
 <dl>
@@ -361,7 +361,7 @@
 <h3 id="lmodes">起動モード</h3>
 
 <p>
-<code><a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">launchMode</a></code> 属性の {@code &lt;activity&gt;} 要素には、以下の 4 種類の起動モードを割り当てることができます:
+<code><a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">launchMode</a></code> 属性の {@code <activity>} 要素には、以下の 4 種類の起動モードを割り当てることができます:
 </p>
 
 <p style="margin-left: 2em">"{@code standard}"（デフォルト モード）<br>"{@code singleTop}"<br>"{@code singleTask}"<br>"{@code singleInstance}"</p>
@@ -470,7 +470,7 @@
 </p> 
 
 <p>
-ユーザーがアクティビティに戻ることができるようにしない場合は、{@code &lt;activity&gt;} 要素の {@code finishOnTaskLaunch} を "{@code true}" に設定します。詳しくは、<a href="#clearstack">スタックのクリア</a>をご覧ください。
+ユーザーがアクティビティに戻ることができるようにしない場合は、{@code <activity>} 要素の {@code finishOnTaskLaunch} を "{@code true}" に設定します。詳しくは、<a href="#clearstack">スタックのクリア</a>をご覧ください。
 </p>
 
 
@@ -488,7 +488,7 @@
 <h3 id="procs">プロセス</h3>
 
 <p>
-コンポーネントを実行するプロセスは、マニフェスト ファイルで管理します。コンポーネントの各要素（{@code &lt;activity&gt;}、{@code &lt;service&gt;}、{@code &lt;receiver&gt;}、および {@code &lt;provider&gt;}）には {@code process} 属性があり、そのコンポーネントをどのプロセスで実行すべきかを指定できるようになっています。これらの属性の設定によって、それぞれのコンポーネントを専用のプロセスで実行したり、一部のコンポーネントだけでプロセスを共有したりできます。また、別々のアプリケーションのコンポーネントが、同じプロセスで実行されるように設定することもできます。この場合は、それらのアプリケーションが同じ Linux ユーザー ID を共有し、同じ認証機関によって署名されている必要があります。{@code &lt;application&gt;} 要素にも {@code process} 属性があり、すべてのコンポーネントに適用されるデフォルト値を設定できます。
+コンポーネントを実行するプロセスは、マニフェスト ファイルで管理します。コンポーネントの各要素（{@code <activity>}、{@code <service>}、{@code <receiver>}、および {@code <provider>}）には {@code process} 属性があり、そのコンポーネントをどのプロセスで実行すべきかを指定できるようになっています。これらの属性の設定によって、それぞれのコンポーネントを専用のプロセスで実行したり、一部のコンポーネントだけでプロセスを共有したりできます。また、別々のアプリケーションのコンポーネントが、同じプロセスで実行されるように設定することもできます。この場合は、それらのアプリケーションが同じ Linux ユーザー ID を共有し、同じ認証機関によって署名されている必要があります。{@code <application>} 要素にも {@code process} 属性があり、すべてのコンポーネントに適用されるデフォルト値を設定できます。
 </p>
 
 <p>
diff --git a/docs/html-intl/intl/ja/preview/api-overview.jd b/docs/html-intl/intl/ja/preview/api-overview.jd
index 2c0816b..33cabc3 100644
--- a/docs/html-intl/intl/ja/preview/api-overview.jd
+++ b/docs/html-intl/intl/ja/preview/api-overview.jd
@@ -133,8 +133,8 @@
 <pre class="no-prettyprint">
 adb -e emu finger touch &lt;finger_id&gt;
 </pre>
-<p>Windows では、{@code telnet 127.0.0.1 &lt;emulator-id&gt;}、
-{@code finger touch &lt;finger_id&gt;} の順に実行する必要がある場合があります。
+<p>Windows では、{@code telnet 127.0.0.1 <emulator-id>}、
+{@code finger touch <finger_id>} の順に実行する必要がある場合があります。
 </p>
 </li>
 </ol>
@@ -192,7 +192,7 @@
 </pre>
 
 <p>{@code ChooserTargetService} に公開するアクティビティごとに、 {@code "android.service.chooser.chooser_target_service"} という名前の
-{@code &lt;meta-data&gt;} 要素をアプリのマニフェストに追加します。
+{@code <meta-data>} 要素をアプリのマニフェストに追加します。
 
 </p>
 
diff --git a/docs/html-intl/intl/ja/training/basics/activity-lifecycle/starting.jd b/docs/html-intl/intl/ja/training/basics/activity-lifecycle/starting.jd
index 7c865a9..124c323 100644
--- a/docs/html-intl/intl/ja/training/basics/activity-lifecycle/starting.jd
+++ b/docs/html-intl/intl/ja/training/basics/activity-lifecycle/starting.jd
@@ -150,7 +150,7 @@
 
 <p>アプリのメインのアクティビティは、{@link
 android.content.Intent#ACTION_MAIN MAIN} アクションと {@link android.content.Intent#CATEGORY_LAUNCHER LAUNCHER} カテゴリを含む <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a> を使用してマニフェストで宣言する必要があります。
+<intent-filter>}</a> を使用してマニフェストで宣言する必要があります。
 次に例を示します。</p> 
 
 <pre>
diff --git a/docs/html-intl/intl/ja/training/basics/intents/filters.jd b/docs/html-intl/intl/ja/training/basics/intents/filters.jd
index 5f0d69a..1bcb266 100644
--- a/docs/html-intl/intl/ja/training/basics/intents/filters.jd
+++ b/docs/html-intl/intl/ja/training/basics/intents/filters.jd
@@ -31,7 +31,7 @@
 
 </p>
 
-<p>他のアプリからアクティビティを開始できるようにするには、対応する <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>要素のマニフェスト ファイルに <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a> 要素を追加する必要があります。
+<p>他のアプリからアクティビティを開始できるようにするには、対応する <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>要素のマニフェスト ファイルに <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a> 要素を追加する必要があります。
 </p>
 
 <p>アプリが端末にインストールされている場合、システムはインテント フィルタを識別し、インストールされているすべてのアプリでサポートされるインテントの内部カタログに情報を追加します。アプリが暗黙的インテントを使って {@link android.app.Activity#startActivity
@@ -56,13 +56,13 @@
   <dt>アクション</dt>
     <dd>実行するアクション名を表す文字列。通常、
 {@link android.content.Intent#ACTION_SEND} や {@link android.content.Intent#ACTION_VIEW} などのプラットフォームに定義された値のいずれか。
-    <p><a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action&gt;}</a> 要素を使用してインテント フィルタでこれを指定します。この要素で指定した値は、API 定数ではなく、アクションの完全な文字列名（下記の例を参照）である必要があります。
+    <p><a href="{@docRoot}guide/topics/manifest/action-element.html">{@code <action>}</a> 要素を使用してインテント フィルタでこれを指定します。この要素で指定した値は、API 定数ではなく、アクションの完全な文字列名（下記の例を参照）である必要があります。
 
 </p></dd>
 
   <dt>データ</dt>
     <dd>インテントに関連するデータの詳細。
-    <p><a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a> 要素を使用して、インテント フィルタでこれを指定します。この要素で 1 つ以上の属性を
+    <p><a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a> 要素を使用して、インテント フィルタでこれを指定します。この要素で 1 つ以上の属性を
 使用して、MIME タイプのみ、URI 接頭辞のみ、URI スキームのみ、またはこれらと受け入れられるデータ タイプを示すその他の項目の組み合わせを指定することができます。
 
 </p>
@@ -76,11 +76,11 @@
 システムでサポートされているいくつかの異なるカテゴリがありますが、大抵のカテゴリはほとんど使用されません。
 しかし、すべての暗黙的インテントは、デフォルトでは
 {@link android.content.Intent#CATEGORY_DEFAULT} を使用して定義されています。
-    <p><a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category&gt;}</a>
+    <p><a href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a>
 要素を使用して、インテント フィルタでこれを指定します。</p></dd>
 </dl>
 
-<p>インテント フィルタでは、それぞれの基準を<a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a> 要素内でネストした対応する XML 要素を使用して宣言することによって、アクティビティが受け入れる基準を宣言することができます。
+<p>インテント フィルタでは、それぞれの基準を<a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a> 要素内でネストした対応する XML 要素を使用して宣言することによって、アクティビティが受け入れる基準を宣言することができます。
 
 </p>
 
@@ -100,10 +100,10 @@
 
 <p>受信するインテントはそれぞれ 1 つのアクションと 1 つのデータ タイプのみを指定しますが、各
 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a> 内で <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
-&lt;action&gt;}</a>、<a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
-&lt;category&gt;}</a>、<a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
-&lt;data&gt;}</a> 要素の複数のインスタンスを宣言することもできます。
+<intent-filter>}</a> 内で <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
+<action>}</a>、<a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
+<category>}</a>、<a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
+<data>}</a> 要素の複数のインスタンスを宣言することもできます。
 </p>
 
 <p>アクションとデータのいずれか 2 つのペアが、各自の動作において相互に排他的である場合は、別のインテント フィルタを作成して、どのデータ タイプと組み合わされたときにとのアクションが受け入れられるかを指定する必要があります。
diff --git a/docs/html-intl/intl/ja/training/tv/start/start.jd b/docs/html-intl/intl/ja/training/tv/start/start.jd
index bc99ff9..3678df9 100755
--- a/docs/html-intl/intl/ja/training/tv/start/start.jd
+++ b/docs/html-intl/intl/ja/training/tv/start/start.jd
@@ -156,7 +156,7 @@
 <h2 id="tv-libraries">TV サポート ライブラリを追加する</h3>
 
 <p>
-  Android SDK には、TV アプリ向けのサポート ライブラリが用意されています。これらのライブラリでは、TV 端末向けに使用できる API とユーザー インターフェース ウィジェットを提供しています。同ライブラリは {@code &lt;sdk&gt;/extras/android/support/} ディレクトリにあります。ライブラリとその全般的な用途の一覧を次に示します。
+  Android SDK には、TV アプリ向けのサポート ライブラリが用意されています。これらのライブラリでは、TV 端末向けに使用できる API とユーザー インターフェース ウィジェットを提供しています。同ライブラリは {@code <sdk>/extras/android/support/} ディレクトリにあります。ライブラリとその全般的な用途の一覧を次に示します。
 </p>
 
 <ul>
diff --git a/docs/html-intl/intl/ko/distribute/googleplay/quality/tv.jd b/docs/html-intl/intl/ko/distribute/googleplay/quality/tv.jd
index 83d71e9..721d63a 100644
--- a/docs/html-intl/intl/ko/distribute/googleplay/quality/tv.jd
+++ b/docs/html-intl/intl/ko/distribute/googleplay/quality/tv.jd
@@ -319,7 +319,7 @@
   </td>
   <td>
     <p style="margin-bottom:.5em;">
-      앱이 게임 컨트롤러를 기본 입력 방법으로 사용하는 경우 <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a> 매니페스트 태그로 적합한 요구사항을 선언합니다.
+      앱이 게임 컨트롤러를 기본 입력 방법으로 사용하는 경우 <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> 매니페스트 태그로 적합한 요구사항을 선언합니다.
 
       (<a href="{@docRoot}training/tv/games/index.html#gamepad">방법 알아보기</a>)
     </p>
diff --git a/docs/html-intl/intl/ko/google/play/filters.jd b/docs/html-intl/intl/ko/google/play/filters.jd
index c1f73c7..42b1c77 100644
--- a/docs/html-intl/intl/ko/google/play/filters.jd
+++ b/docs/html-intl/intl/ko/google/play/filters.jd
@@ -329,23 +329,23 @@
   <tr><th>매니페스트 요소</th><th>요약</th></tr>
   <tr>
     <td><nobr><a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a></nobr></td>
+<compatible-screens>}</a></nobr></td>
     <td>
       <p>Google Play가 장치 화면
 크기와 밀도가 {@code
-&lt;compatible-screens&gt;} 요소에서 {@code &lt;screen&gt;} 요소가 선언한 화면 구성과 일치하지 않는 경우에 애플리케이션을 필터링합니다.</p>
+<compatible-screens>} 요소에서 {@code <screen>} 요소가 선언한 화면 구성과 일치하지 않는 경우에 애플리케이션을 필터링합니다.</p>
       <p class="caution"><strong>주의:</strong> 일반적으로 <strong>이 매니페스트 요소를 사용하면 안 됩니다</strong>.
  이 요소를 사용하면 목록에 없는 화면 크기와 밀도의 조합을 모두 제외시켜 애플리케이션의 잠재적 사용자 기반이 현저히 줄어들 수 있습니다.
 
  대신 위의 <a href="#table1">표 1</a>에 나오는 <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> 매니페스트 요소를 사용하여 대체 리소스로 고려하지 않은 화면 구성에 대해 화면 호환성 모드를 활성화해야 합니다.
+<supports-screens>}</a> 매니페스트 요소를 사용하여 대체 리소스로 고려하지 않은 화면 구성에 대해 화면 호환성 모드를 활성화해야 합니다.
 
 </p>
     </td>
   </tr>
   <tr>
     <td><nobr><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a></nobr></td>
+<supports-gl-texture>}</a></nobr></td>
     <td>
       <p>Google Play는 애플리케이션에서 지원되는 하나 이상의 GL 텍스처 압축 형식이 장치에서도 지원되는 경우를 제외하고 애플리케이션을 필터링합니다.
  </p>
@@ -408,16 +408,16 @@
 <ul>
   <li>OpenGL 텍스처 압축 형식
     <p><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a> 요소를 사용하여 필터링합니다.</p>
+<supports-gl-texture>}</a> 요소를 사용하여 필터링합니다.</p>
   </li>
   <li>화면 크기(및 선택적 화면 밀도)
     <p><a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> 또는 <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a> 요소를 사용하여 필터링합니다.</p>
+<supports-screens>}</a> 또는 <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
+<compatible-screens>}</a> 요소를 사용하여 필터링합니다.</p>
   </li>
   <li>API 레벨
     <p><a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code
-&lt;uses-sdk&gt;}</a> 요소를 사용하여 필터링합니다.</p>
+<uses-sdk>}</a> 요소를 사용하여 필터링합니다.</p>
   </li>
   <li>CPU 아키텍처(ABI)
     <p>특정 CPU 아키텍처(예: ARM EABI v7 또는 x86)를 대상으로 하는 <a href="{@docRoot}tools/sdk/ndk/index.html">Android NDK</a>로 작성된 네이티브 라이브러리를 포함하여 필터링합니다.
diff --git a/docs/html-intl/intl/ko/preview/api-overview.jd b/docs/html-intl/intl/ko/preview/api-overview.jd
index aac9a44..f9308b1 100644
--- a/docs/html-intl/intl/ko/preview/api-overview.jd
+++ b/docs/html-intl/intl/ko/preview/api-overview.jd
@@ -133,7 +133,7 @@
 <pre class="no-prettyprint">
 adb -e emu finger touch &lt;finger_id&gt;
 </pre>
-<p>Windows에서는 {@code telnet 127.0.0.1 &lt;emulator-id&gt;}에 뒤이어 {@code finger touch &lt;finger_id&gt;}를 실행해야 할 수도 있습니다.
+<p>Windows에서는 {@code telnet 127.0.0.1 <emulator-id>}에 뒤이어 {@code finger touch <finger_id>}를 실행해야 할 수도 있습니다.
 
 </p>
 </li>
@@ -191,7 +191,7 @@
 &lt;/service&gt;
 </pre>
 
-<p>{@code ChooserTargetService}에 노출하고자 하는 액티비티마다 {@code &lt;meta-data&gt;} 요소를 하나씩 추가하고, 앱 매니페스트에 {@code "android.service.chooser.chooser_target_service"} 이름을 추가합니다.
+<p>{@code ChooserTargetService}에 노출하고자 하는 액티비티마다 {@code <meta-data>} 요소를 하나씩 추가하고, 앱 매니페스트에 {@code "android.service.chooser.chooser_target_service"} 이름을 추가합니다.
 
 
 </p>
diff --git a/docs/html-intl/intl/ko/training/basics/activity-lifecycle/starting.jd b/docs/html-intl/intl/ko/training/basics/activity-lifecycle/starting.jd
index 71ecf06..ef13487 100644
--- a/docs/html-intl/intl/ko/training/basics/activity-lifecycle/starting.jd
+++ b/docs/html-intl/intl/ko/training/basics/activity-lifecycle/starting.jd
@@ -150,7 +150,7 @@
 
 <p>앱의 메인 액티비티는 {@link
 android.content.Intent#ACTION_MAIN MAIN} 작업 및{@link android.content.Intent#CATEGORY_LAUNCHER LAUNCHER} 카테고리를 포함하는 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a>와 함께
+<intent-filter>}</a>와 함께
 매니페스트 파일에 선언되어야 합니다. 예를 들면 다음과 같습니다.</p> 
 
 <pre>
diff --git a/docs/html-intl/intl/ko/training/basics/intents/filters.jd b/docs/html-intl/intl/ko/training/basics/intents/filters.jd
index 265534c..251d262 100644
--- a/docs/html-intl/intl/ko/training/basics/intents/filters.jd
+++ b/docs/html-intl/intl/ko/training/basics/intents/filters.jd
@@ -31,8 +31,8 @@
 "공유" 작업을 시작하고 이 작업을 수행하기 위해 여러분 자신의 앱을 시작할 수 있도록
 {@link android.content.Intent#ACTION_SEND} 인텐트를 지원하는 것이 좋습니다.</p>
 
-<p>다른 앱이 자신의 액티비티를 시작할 수 있도록 하기 위해서는 <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
-요소에 상응하는 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a> 요소를 매니페스트 파일에 추가해야 합니다.</p>
+<p>다른 앱이 자신의 액티비티를 시작할 수 있도록 하기 위해서는 <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
+요소에 상응하는 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a> 요소를 매니페스트 파일에 추가해야 합니다.</p>
 
 <p>앱이 기기에 설치되면 시스템이 인텐트
 필터를 식별한 후 설치된 모든 앱에서 지원되는 인텐트의 내부 카탈로그에 해당 정보를 추가합니다.
@@ -56,13 +56,13 @@
   <dt>작업</dt>
     <dd>수행할 작업의 이름을 지정하는 문자열입니다. 일반적으로, 플랫폼에서 정의하는 값 중
 하나입니다(예: {@link android.content.Intent#ACTION_SEND} 또는 {@link android.content.Intent#ACTION_VIEW}).
-    <p><a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action&gt;}</a> 요소를 사용하여 인텐트 필터에 지정합니다.
+    <p><a href="{@docRoot}guide/topics/manifest/action-element.html">{@code <action>}</a> 요소를 사용하여 인텐트 필터에 지정합니다.
 이 요소에 지정하는 값은 API 상수 대신
 작업의 전체 문자열 이름이어야 합니다(다음 예제 참조).</p></dd>
 
   <dt>데이터</dt>
     <dd>인텐트와 관련된 데이터에 대한 설명입니다.
-    <p><a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a> 요소를 사용하여 인텐트 필터에 지정합니다. 이 요소에서
+    <p><a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a> 요소를 사용하여 인텐트 필터에 지정합니다. 이 요소에서
 하나 이상의 특성을 사용하여 MIME 유형, URI 접두사, URI 스키마, 또는
 이들의 조합 그리고 수락된 데이터 유형을 나타내는 다른 요소들을 지정할 수
 있습니다.</p>
@@ -76,12 +76,12 @@
 관련되어 있습니다. 시스템이 지원하는 카테고리는
 여러 가지가 있지만 대부분은 거의 사용되지 않습니다. 하지만 모든 암묵적인 인텐트는 기본적으로
 {@link android.content.Intent#CATEGORY_DEFAULT}로 정의됩니다.
-    <p><a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category&gt;}</a> 요소를 사용하여 인텐트 필터에
+    <p><a href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a> 요소를 사용하여 인텐트 필터에
 지정합니다.</p></dd>
 </dl>
 
 <p>인텐트 필터에서 액티비티가 허용하는 기준을 선언할 수 있습니다.
-이는 이러한 기준 각각을 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a> 요소 내에 해당 XML 요소를 중첩하여 선언하면
+이는 이러한 기준 각각을 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a> 요소 내에 해당 XML 요소를 중첩하여 선언하면
 가능합니다.</p>
 
 <p>예를 들어, 다음은 데이터 유형이 텍스트 또는 이미지인 경우 {@link
@@ -100,10 +100,10 @@
 
 <p>수신되는 인텐트는 각각 하나의 작업 및 하나의 데이터 유형만 지정합니다. 하지만
 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a> 각각에 <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
-&lt;action&gt;}</a>, <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
-&lt;category&gt;}</a> 및 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
-&lt;data&gt;}</a>에 대한 여러
+<intent-filter>}</a> 각각에 <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
+<action>}</a>, <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
+<category>}</a> 및 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
+<data>}</a>에 대한 여러
 인스턴스를 선언해도 문제가 되지는 않습니다.</p>
 
 <p>작업 및 데이터의 두 쌍이 상호 배타적으로
diff --git a/docs/html-intl/intl/pt-br/preview/api-overview.jd b/docs/html-intl/intl/pt-br/preview/api-overview.jd
index 33e8c1f..139fb33 100644
--- a/docs/html-intl/intl/pt-br/preview/api-overview.jd
+++ b/docs/html-intl/intl/pt-br/preview/api-overview.jd
@@ -133,8 +133,8 @@
 <pre class="no-prettyprint">
 adb -e emu finger touch &lt;finger_id&gt;
 </pre>
-<p>No Windows, talvez seja necessário executar {@code telnet 127.0.0.1 &lt;emulator-id&gt;} seguido de 
-{@code finger touch &lt;finger_id&gt;}.
+<p>No Windows, talvez seja necessário executar {@code telnet 127.0.0.1 <emulator-id>} seguido de
+{@code finger touch <finger_id>}.
 </p>
 </li>
 </ol>
@@ -192,7 +192,7 @@
 </pre>
 
 <p>Para cada atividade que quiser expor ao {@code ChooserTargetService}, adicione um elemento 
-{@code &lt;meta-data&gt;} com o nome 
+{@code <meta-data>} com o nome
 {@code "android.service.chooser.chooser_target_service"} no manifesto do aplicativo.
 </p>
 
diff --git a/docs/html-intl/intl/pt-br/training/basics/activity-lifecycle/starting.jd b/docs/html-intl/intl/pt-br/training/basics/activity-lifecycle/starting.jd
index 1f8f080..efe2bad 100644
--- a/docs/html-intl/intl/pt-br/training/basics/activity-lifecycle/starting.jd
+++ b/docs/html-intl/intl/pt-br/training/basics/activity-lifecycle/starting.jd
@@ -149,7 +149,7 @@
 na raiz do diretório do seu projeto.</p>
 
 <p>A principal atividade do aplicativo deve ser declarada no manifesto com um <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a> que inclui a ação {@link
+<intent-filter>}</a> que inclui a ação {@link
 android.content.Intent#ACTION_MAIN MAIN} e categoria
 {@link android.content.Intent#CATEGORY_LAUNCHER LAUNCHER}. Por exemplo:</p> 
 
diff --git a/docs/html-intl/intl/pt-br/training/basics/intents/filters.jd b/docs/html-intl/intl/pt-br/training/basics/intents/filters.jd
index 73f0b84..f3b3b12 100644
--- a/docs/html-intl/intl/pt-br/training/basics/intents/filters.jd
+++ b/docs/html-intl/intl/pt-br/training/basics/intents/filters.jd
@@ -31,8 +31,8 @@
 que ele possa responder à intenção {@link android.content.Intent#ACTION_SEND} para que os usuários consigam iniciar uma
 ação de “compartilhar” por outro aplicativo e iniciar seu aplicativo para executar a ação.</p>
 
-<p>Para permitir que outros aplicativos iniciem sua atividade, adicione um elemento <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a>
-em seu arquivo de manifesto para o elemento <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> correspondente.</p>
+<p>Para permitir que outros aplicativos iniciem sua atividade, adicione um elemento <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>
+em seu arquivo de manifesto para o elemento <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> correspondente.</p>
 
 <p>Quando seu aplicativo é instalado em um dispositivo, o sistema identifica seu filtro de
 intenções e adiciona a informação a um catálogo interno de intenções suportado por todos os aplicativos instalados.
@@ -56,13 +56,13 @@
   <dt>Ação</dt>
     <dd>Uma cadeia de caracteres que dá nome a ação a ser executada. Geralmente, um dos valores definidos para a plataforma
 como {@link android.content.Intent#ACTION_SEND} ou {@link android.content.Intent#ACTION_VIEW}.
-    <p>Especifique-o em seu filtro de intenções com o elemento <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action&gt;}</a>.
+    <p>Especifique-o em seu filtro de intenções com o elemento <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code <action>}</a>.
 O valor especificado neste elemento deve ser o nome completo da cadeia de caracteres para a ação e não a
 API constante (veja exemplos abaixo).</p></dd>
 
   <dt>Dados</dt>
     <dd>A descrição dos dados associados à intenção.
-    <p>Especifique-a em seu filtro de intenções com o elemento <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a>. Através de um
+    <p>Especifique-a em seu filtro de intenções com o elemento <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a>. Através de um
 ou mais atributos neste elemento, você pode especificar apenas o tipo MIME, apenas um prefixo de URI,
 apenas um esquema de URI ou uma combinação destes e outros elementos que indicam o tipo de dados
 aceito.</p>
@@ -76,12 +76,12 @@
 ao gesto do usuário ou localização onde foi iniciada. Há diferentes categorias
 compatíveis com o sistema, mas a maioria raramente é utilizada. No entanto, todas as intenções implícitas são definidas com
 {@link android.content.Intent#CATEGORY_DEFAULT} por padrão.
-    <p>Especifique-a em seu filtro de intenções com o elemento <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category&gt;}</a>
+    <p>Especifique-a em seu filtro de intenções com o elemento <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a>
 .</p></dd>
 </dl>
 
 <p>Em seu filtro de intenções, declare quais critérios serão aceitos por sua atividade
-informando cada um deles com elementos XML correspondentes aninhados no elemento <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a>
+informando cada um deles com elementos XML correspondentes aninhados no elemento <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>
 .</p>
 
 <p>Este é um exemplo de atividade com filtro de intenções que responde à intenção {@link
@@ -100,11 +100,11 @@
 
 <p>Cada intenção em entrada especifica apenas uma ação e um tipo de dado, mas pode-se declarar
 múltiplas instâncias dos elementos <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
-&lt;action&gt;}</a>, <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
-&lt;category&gt;}</a> e <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
-&lt;data&gt;}</a> em cada
+<action>}</a>, <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
+<category>}</a> e <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
+<data>}</a> em cada
 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a>.</p>
+<intent-filter>}</a>.</p>
 
 <p>Se dois pares de ação e dados fores mutuamente exclusivos em
 seus comportamentos, crie filtros de intenções separados para especificar quais ações são aceitáveis
diff --git a/docs/html-intl/intl/ru/distribute/googleplay/quality/tv.jd b/docs/html-intl/intl/ru/distribute/googleplay/quality/tv.jd
index 995f2e5..e478f9a 100644
--- a/docs/html-intl/intl/ru/distribute/googleplay/quality/tv.jd
+++ b/docs/html-intl/intl/ru/distribute/googleplay/quality/tv.jd
@@ -320,7 +320,7 @@
   <td>
     <p style="margin-bottom:.5em;">
       Если приложение использует игровой контроллер в качестве основного устройства ввода,
- это требование должно быть задекларировано в теге манифеста <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>.
+ это требование должно быть задекларировано в теге манифеста <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>.
       (<a href="{@docRoot}training/tv/games/index.html#gamepad">См. как это сделать</a>)
     </p>
   </td>
diff --git a/docs/html-intl/intl/ru/google/play/filters.jd b/docs/html-intl/intl/ru/google/play/filters.jd
index f9af767..0059a1a 100644
--- a/docs/html-intl/intl/ru/google/play/filters.jd
+++ b/docs/html-intl/intl/ru/google/play/filters.jd
@@ -329,23 +329,23 @@
   <tr><th>Элемент манифеста</th><th>Сводная информация</th></tr>
   <tr>
     <td><nobr><a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a></nobr></td>
+<compatible-screens>}</a></nobr></td>
     <td>
       <p>Google Play отфильтровывает приложение, если размер и разрешение экрана устройства
-не соответствуют какой-либо конфигурации экрана(декларируемые элементом {@code &lt;screen&gt;}) в элементе {@code
-&lt;compatible-screens&gt;}.</p>
+не соответствуют какой-либо конфигурации экрана(декларируемые элементом {@code <screen>}) в элементе {@code
+<compatible-screens>}.</p>
       <p class="caution"><strong>Внимание!</strong> В обычной практике <strong>вы не должны использовать
 этот элемент манифеста</strong>. Применение этого элемента существенно
 сокращает число потенциальных пользователей вашего приложения, исключая все комбинации размеров
 и разрешения экрана, которые не указаны в списке. Вместо этого используйте элемент манифеста <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> (описанный выше в <a href="#table1">
+<supports-screens>}</a> (описанный выше в <a href="#table1">
 таблице 1</a>), чтобы определить режим совместимости для неучтенных альтернативными ресурсами
 конфигураций экранов.</p>
     </td>
   </tr>
   <tr>
     <td><nobr><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a></nobr></td>
+<supports-gl-texture>}</a></nobr></td>
     <td>
       <p>Google Play будет отфильтровывать приложение, если не окажется ни одного формата
 сжатия GL-текстуры, поддерживаемого устройством. </p>
@@ -408,16 +408,16 @@
 <ul>
   <li>Форматы сжатия текстур OpenGL
     <p>Используя элемент <a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a>.</p>
+<supports-gl-texture>}</a>.</p>
   </li>
   <li>Размер экрана (а в некоторых случаях и разрешение)
     <p>Используя элемент <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> или <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a>.</p>
+<supports-screens>}</a> или <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
+<compatible-screens>}</a>.</p>
   </li>
   <li>Уровень API-интерфейса
     <p>Используя элемент <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code
-&lt;uses-sdk&gt;}</a>.</p>
+<uses-sdk>}</a>.</p>
   </li>
   <li>Архитектура процессора (ABI)
     <p>Включая специфичные библиотеки, созданные на основе <a href="{@docRoot}tools/sdk/ndk/index.html">Android
diff --git a/docs/html-intl/intl/ru/preview/api-overview.jd b/docs/html-intl/intl/ru/preview/api-overview.jd
index ae30e09..aa4a057 100644
--- a/docs/html-intl/intl/ru/preview/api-overview.jd
+++ b/docs/html-intl/intl/ru/preview/api-overview.jd
@@ -133,8 +133,8 @@
 <pre class="no-prettyprint">
 adb -e emu finger touch &lt;finger_id&gt;
 </pre>
-<p>В Windows, возможно, потребуется выполнить команду {@code telnet 127.0.0.1 &lt;emulator-id&gt;}, а затем
-{@code finger touch &lt;finger_id&gt;}.
+<p>В Windows, возможно, потребуется выполнить команду {@code telnet 127.0.0.1 <emulator-id>}, а затем
+{@code finger touch <finger_id>}.
 </p>
 </li>
 </ol>
@@ -192,7 +192,7 @@
 </pre>
 
 <p>Для каждого действия, которое необходимо сделать доступным для {@code ChooserTargetService}, добавьте в манифест вашего приложения элемент
-{@code &lt;meta-data&gt;} с именем
+{@code <meta-data>} с именем
 {@code "android.service.chooser.chooser_target_service"}.
 </p>
 
diff --git a/docs/html-intl/intl/ru/training/basics/activity-lifecycle/starting.jd b/docs/html-intl/intl/ru/training/basics/activity-lifecycle/starting.jd
index 3a946e2..ef8be5b 100644
--- a/docs/html-intl/intl/ru/training/basics/activity-lifecycle/starting.jd
+++ b/docs/html-intl/intl/ru/training/basics/activity-lifecycle/starting.jd
@@ -149,7 +149,7 @@
 который находится в корневом каталоге вашего проекта.</p>
 
 <p>Основная операция приложения должна декларироваться в манифесте с помощью фильтра <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a>, включающего действие {@link
+<intent-filter>}</a>, включающего действие {@link
 android.content.Intent#ACTION_MAIN MAIN} и категорию
 {@link android.content.Intent#CATEGORY_LAUNCHER LAUNCHER}. Например:</p> 
 
diff --git a/docs/html-intl/intl/ru/training/basics/intents/filters.jd b/docs/html-intl/intl/ru/training/basics/intents/filters.jd
index 0f5bb31..c3cbfc9 100644
--- a/docs/html-intl/intl/ru/training/basics/intents/filters.jd
+++ b/docs/html-intl/intl/ru/training/basics/intents/filters.jd
@@ -31,8 +31,8 @@
 будет поддерживать объекты Intent (намерения) {@link android.content.Intent#ACTION_SEND}, чтобы пользователи могли
 поделиться контентом из другого приложения и запускать ваше приложение для выполнения требуемого действия.</p>
 
-<p>Чтобы разрешить другим приложениям запускать ваши операции, вам нужно добавить в ваш файл манифеста элемент <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a>
- для соответствующего элемента <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>.</p>
+<p>Чтобы разрешить другим приложениям запускать ваши операции, вам нужно добавить в ваш файл манифеста элемент <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>
+ для соответствующего элемента <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>.</p>
 
 <p>Если ваше приложение установлено на устройстве, система идентифицирует ваши
 фильтры Intent и добавляет информацию во внутренний каталог намерений, поддерживаемый всеми установленными приложениями.
@@ -56,13 +56,13 @@
   <dt>Действие</dt>
     <dd>Строка, называющая действие, которое необходимо выполнить. Обычно это одно из определяемых платформой значений,
 например, {@link android.content.Intent#ACTION_SEND} или {@link android.content.Intent#ACTION_VIEW}.
-    <p>Это следует указать в фильтре Intent с элементом <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action&gt;}</a>.
+    <p>Это следует указать в фильтре Intent с элементом <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code <action>}</a>.
 Указанное в этом элементе значение должно представлять собой полное имя строки действия, а не
 постоянное значение API-интерфейса (см. примеры ниже).</p></dd>
 
   <dt>Данные</dt>
     <dd>Описание данных, связанных с объектом Intent.
-    <p>Указывается в фильтре Intent с элементом <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a>. Используя один
+    <p>Указывается в фильтре Intent с элементом <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a>. Используя один
 или несколько атрибутов в этом элементе, вы можете указать только тип MIME, только префикс URI,
 только схему URI или из сочетание, а также другие индикаторы типа
 принимаемых данных.</p>
@@ -76,12 +76,12 @@
 с жестом пользователя или местом запуска. Система поддерживает несколько разных категорий,
 но большинство из них используется редко. Однако по умолчанию все неявные объекты Intent определяются с
 {@link android.content.Intent#CATEGORY_DEFAULT}.
-    <p>Это указывается в фильтре Intent с элементом <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category&gt;}</a>
+    <p>Это указывается в фильтре Intent с элементом <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a>
 .</p></dd>
 </dl>
 
 <p>В своем фильтре Intent вы можете декларировать критерии, принимаемые вашей операцией.
-Для этого нужно декларировать каждый из них с соответствующими элементами XML, вложенными в элемент <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a>
+Для этого нужно декларировать каждый из них с соответствующими элементами XML, вложенными в элемент <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>
 .</p>
 
 <p>Рассмотрим в качестве примера операцию с фильтром Intent, обрабатывающим объект {@link
@@ -100,11 +100,11 @@
 
 <p>Каждый входящий объект Intent указывает только одно действие и только один тип данных, однако допускается декларирование нескольких
 экземпляров элементов <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
-&lt;action&gt;}</a>, <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
-&lt;category&gt;}</a> и <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
-&lt;data&gt;}</a> в каждом
+<action>}</a>, <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
+<category>}</a> и <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
+<data>}</a> в каждом
 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a>.</p>
+<intent-filter>}</a>.</p>
 
 <p>Если поведение любых двух пар действий и данных является взаимоисключающим,
 необходимо создать отдельные фильтры Intent с указанием допустимых действий
diff --git a/docs/html-intl/intl/zh-cn/distribute/googleplay/quality/tv.jd b/docs/html-intl/intl/zh-cn/distribute/googleplay/quality/tv.jd
index 5eea293..6a60945 100644
--- a/docs/html-intl/intl/zh-cn/distribute/googleplay/quality/tv.jd
+++ b/docs/html-intl/intl/zh-cn/distribute/googleplay/quality/tv.jd
@@ -320,7 +320,7 @@
   <td>
     <p style="margin-bottom:.5em;">
       如果应用使用游戏手柄作为主要输入方法，则要通过
-<a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>清单文件标记来声明相应的要求。
+<a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>清单文件标记来声明相应的要求。
       （<a href="{@docRoot}training/tv/games/index.html#gamepad">了解方法</a>）
     </p>
   </td>
diff --git a/docs/html-intl/intl/zh-cn/google/play/filters.jd b/docs/html-intl/intl/zh-cn/google/play/filters.jd
index 70f8d9b..9d68faf 100644
--- a/docs/html-intl/intl/zh-cn/google/play/filters.jd
+++ b/docs/html-intl/intl/zh-cn/google/play/filters.jd
@@ -329,23 +329,23 @@
   <tr><th>清单文件元素</th><th>摘要</th></tr>
   <tr>
     <td><nobr><a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a></nobr></td>
+<compatible-screens>}</a></nobr></td>
     <td>
       <p>如果设备屏幕尺寸和密度不符合
  {@code
-&lt;compatible-screens&gt;} 元素中的任何屏幕配置（由{@code &lt;screen&gt;} 元素声明），则 Google Play 会将该应用筛选掉。</p>
+<compatible-screens>} 元素中的任何屏幕配置（由{@code <screen>} 元素声明），则 Google Play 会将该应用筛选掉。</p>
       <p class="caution"><strong>注意：</strong>正常情况下，<strong>不能使用此清单文件元素</strong>。
 使用此元素可能会显著减少应用的潜在用户群，因为排除了您未列出的所有屏幕尺寸和密度组合。
 
 应当改用 <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> 清单文件元素（上面<a href="#table1">表
+<supports-screens>}</a> 清单文件元素（上面<a href="#table1">表
 1</a> 所述），通过替代资源为您没有考虑的屏幕配置启用屏幕兼容模式。
 </p>
     </td>
   </tr>
   <tr>
     <td><nobr><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a></nobr></td>
+<supports-gl-texture>}</a></nobr></td>
     <td>
       <p>除非应用所支持的一种或多种 GL 纹理压缩格式也受到设备支持，否则 Google Play 将应用筛选掉。
  </p>
@@ -408,16 +408,16 @@
 <ul>
   <li>OpenGL 纹理压缩格式
     <p>使用 <a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a> 元素。</p>
+<supports-gl-texture>}</a> 元素。</p>
   </li>
   <li>屏幕尺寸（以及可选的屏幕密度）
     <p>使用 <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> 或 <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a> 元素。</p>
+<supports-screens>}</a> 或 <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
+<compatible-screens>}</a> 元素。</p>
   </li>
   <li>API 级别
     <p>使用 <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code
-&lt;uses-sdk&gt;}</a> 元素。</p>
+<uses-sdk>}</a> 元素。</p>
   </li>
   <li>CPU 架构 (ABI)
     <p>包括针对特定 CPU 架构（例如 ARM EABI v7 或 x86）的、通过 <a href="{@docRoot}tools/sdk/ndk/index.html">Android
diff --git a/docs/html-intl/intl/zh-cn/preview/api-overview.jd b/docs/html-intl/intl/zh-cn/preview/api-overview.jd
index c64a38e..f7764cd 100644
--- a/docs/html-intl/intl/zh-cn/preview/api-overview.jd
+++ b/docs/html-intl/intl/zh-cn/preview/api-overview.jd
@@ -134,7 +134,7 @@
 adb -e emu finger touch &lt;finger_id&gt;
 </pre>
 <p>在 Windows 上，您可能需要运行带有 
-{@code finger touch &lt;finger_id&gt;} 参数的 {@code telnet 127.0.0.1 &lt;emulator-id&gt;} 命令。
+{@code finger touch <finger_id>} 参数的 {@code telnet 127.0.0.1 <emulator-id>} 命令。
 </p>
 </li>
 </ol>
@@ -193,7 +193,7 @@
 
 <p>对于您想要向 {@code ChooserTargetService} 公开的每个活动，请在您的应用清单文件中为其添加一个名为 
 {@code "android.service.chooser.chooser_target_service"} 的 
-{@code &lt;meta-data&gt;} 元素。
+{@code <meta-data>} 元素。
 </p>
 
 <pre>
diff --git a/docs/html-intl/intl/zh-cn/training/basics/activity-lifecycle/starting.jd b/docs/html-intl/intl/zh-cn/training/basics/activity-lifecycle/starting.jd
index 05f9728..cebd748 100644
--- a/docs/html-intl/intl/zh-cn/training/basics/activity-lifecycle/starting.jd
+++ b/docs/html-intl/intl/zh-cn/training/basics/activity-lifecycle/starting.jd
@@ -149,7 +149,7 @@
 </p>
 
 <p>您的应用的主Activity必须使用 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a>（包括 {@link
+<intent-filter>}</a>（包括 {@link
 android.content.Intent#ACTION_MAIN MAIN} 操作和
 {@link android.content.Intent#CATEGORY_LAUNCHER LAUNCHER} 类别）在宣示说明中声明。例如：</p> 
 
diff --git a/docs/html-intl/intl/zh-cn/training/basics/intents/filters.jd b/docs/html-intl/intl/zh-cn/training/basics/intents/filters.jd
index 4bcbdf9..ff5c792 100644
--- a/docs/html-intl/intl/zh-cn/training/basics/intents/filters.jd
+++ b/docs/html-intl/intl/zh-cn/training/basics/intents/filters.jd
@@ -31,8 +31,8 @@
 
 </p>
 
-<p>要允许其他应用开始您的Activity，您需要 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a>
-在相应元素的宣示说明文件中添加一个 <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> 元素。</p>
+<p>要允许其他应用开始您的Activity，您需要 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>
+在相应元素的宣示说明文件中添加一个 <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> 元素。</p>
 
 <p>当您的应用安装在设备上时，系统会识别您的意向过滤器并添加信息至所有已安装应用支持的意向内部目录。当应用通过隐含意向调用 {@link android.app.Activity#startActivity
 startActivity()} 或 {@link android.app.Activity#startActivityForResult startActivityForResult()} 时，系统会找到可以响应该意向的Activity。
@@ -56,13 +56,13 @@
   <dt>操作</dt>
     <dd>对要执行的操作命名的字符串。通常是平台定义的值之一，比如
  {@link android.content.Intent#ACTION_SEND} 或 {@link android.content.Intent#ACTION_VIEW}。
-    <p>使用 <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action&gt;}</a> 元素在您的意向过滤器中指定此值。您在此元素中指定的值必须是操作的完整字符串名称，而不是 API 常数（请参阅以下示例）。
+    <p>使用 <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code <action>}</a> 元素在您的意向过滤器中指定此值。您在此元素中指定的值必须是操作的完整字符串名称，而不是 API 常数（请参阅以下示例）。
 
 </p></dd>
 
   <dt>数据</dt>
     <dd>与意向关联的数据描述。
-    <p>用 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a> 元素在您的意向过滤器中指定此内容。使用此元素中的一个或多个属性，您可以只指定 MIME 类型、URI 前缀、URI 架构或这些的组合以及其他指示所接受数据类型的项。
+    <p>用 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a> 元素在您的意向过滤器中指定此内容。使用此元素中的一个或多个属性，您可以只指定 MIME 类型、URI 前缀、URI 架构或这些的组合以及其他指示所接受数据类型的项。
 
 
 </p>
@@ -76,11 +76,11 @@
 系统支持多种不同的类别，但大多数都很少使用。
 ﻿但是，所有隐含意向默认使用
 {@link android.content.Intent#CATEGORY_DEFAULT} 进行定义。
-    <p>用 <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category&gt;}</a>
+    <p>用 <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a>
  元素在您的意向过滤器中指定此内容。</p></dd>
 </dl>
 
-<p>在您的意向过滤器中，您可以通过声明嵌套在 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a>
+<p>在您的意向过滤器中，您可以通过声明嵌套在 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>
 元素中的具有相应 XML 元素的各项，来声明您的Activity接受的条件。
 </p>
 
@@ -100,11 +100,11 @@
 
 <p>每个入站意向仅指定一项操作和一个数据类型，但可以在每个
 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html"> {@code
-&lt;intent-filter&gt;}</a> 中声明
+<intent-filter>}</a> 中声明
  <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
-&lt;action&gt;}</a>、<a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
-&lt;category&gt;}</a> 和 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
-&lt;data&gt;}</a> 元素的多个实例。</p>
+<action>}</a>、<a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
+<category>}</a> 和 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
+<data>}</a> 元素的多个实例。</p>
 
 <p>如果任何两对操作和数据的行为相斥，您应创建单独的意向过滤器指定与哪种数据类型配对时哪些操作可接受。
 
diff --git a/docs/html-intl/intl/zh-tw/distribute/googleplay/quality/tv.jd b/docs/html-intl/intl/zh-tw/distribute/googleplay/quality/tv.jd
index 9329606..996df61 100644
--- a/docs/html-intl/intl/zh-tw/distribute/googleplay/quality/tv.jd
+++ b/docs/html-intl/intl/zh-tw/distribute/googleplay/quality/tv.jd
@@ -285,7 +285,7 @@
   </td>
   <td>
     <p style="margin-bottom:.5em;">
-      若應用程式將遊戲手把用作主要輸入方式，會使用 <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a> 宣示說明標籤宣告相應的需求。(<a href="{@docRoot}training/tv/games/index.html#gamepad">進行了解</a>)
+      若應用程式將遊戲手把用作主要輸入方式，會使用 <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> 宣示說明標籤宣告相應的需求。(<a href="{@docRoot}training/tv/games/index.html#gamepad">進行了解</a>)
     </p>
   </td>
 </tr>
diff --git a/docs/html-intl/intl/zh-tw/google/play/filters.jd b/docs/html-intl/intl/zh-tw/google/play/filters.jd
index 8cfd59a..e96b9dd 100644
--- a/docs/html-intl/intl/zh-tw/google/play/filters.jd
+++ b/docs/html-intl/intl/zh-tw/google/play/filters.jd
@@ -208,14 +208,14 @@
 <table>
   <tr><th>宣示說明元素</th><th>摘要</th></tr>
   <tr>
-    <td><nobr><a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code &lt;compatible-screens&gt;}</a></nobr></td>
+    <td><nobr><a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code <compatible-screens>}</a></nobr></td>
     <td>
-      <p>若裝置螢幕大小與密度不符合元素中的{@code &lt;compatible-screens&gt;}任何螢幕組態 (由 {@code &lt;screen&gt;} 元素宣告)，Google Play 會對應用程式進行篩選。</p>
-      <p class="caution"><strong>注意：</strong>通常，<strong>您不應使用此宣示說明元素</strong>。若使用此元素，會將您未列出的螢幕大小與密度的所有組合排除在外，從而大幅減少您應用程式可能擁有的使用者。您應改為針對未使用替代資源說明的螢幕組態，使用 <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code &lt;supports-screens&gt;}</a> 宣示說明元素 (如<a href="#table1">表 1</a> 所述) 啟用螢幕相容性模式。</p>
+      <p>若裝置螢幕大小與密度不符合元素中的{@code <compatible-screens>}任何螢幕組態 (由 {@code <screen>} 元素宣告)，Google Play 會對應用程式進行篩選。</p>
+      <p class="caution"><strong>注意：</strong>通常，<strong>您不應使用此宣示說明元素</strong>。若使用此元素，會將您未列出的螢幕大小與密度的所有組合排除在外，從而大幅減少您應用程式可能擁有的使用者。您應改為針對未使用替代資源說明的螢幕組態，使用 <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code <supports-screens>}</a> 宣示說明元素 (如<a href="#table1">表 1</a> 所述) 啟用螢幕相容性模式。</p>
     </td>
   </tr>
   <tr>
-    <td><nobr><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code &lt;supports-gl-texture&gt;}</a></nobr></td>
+    <td><nobr><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code <supports-gl-texture>}</a></nobr></td>
     <td>
       <p>除非裝置支援應用程式所支援的一或多個 GL 材質壓縮格式，否則 Google Play 會對應用程式進行篩選。 </p>
     </td>
@@ -249,11 +249,11 @@
 
 <p>目前，只有在每個 APK 根據以下組態提供不同的篩選器時，Google Play 才允許您針對同一應用程式發行多個 APK：</p>
 <ul>
-  <li>OpenGL 材質壓縮格式 <p>透過使用 <a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code &lt;supports-gl-texture&gt;}</a>元素。</p>
+  <li>OpenGL 材質壓縮格式 <p>透過使用 <a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code <supports-gl-texture>}</a>元素。</p>
   </li>
-  <li>螢幕大小 (以及可選的螢幕密度) <p>透過使用 <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code &lt;supports-screens&gt;}</a>或<a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code &lt;compatible-screens&gt;}</a> 元素。</p>
+  <li>螢幕大小 (以及可選的螢幕密度) <p>透過使用 <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code <supports-screens>}</a>或<a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code <compatible-screens>}</a> 元素。</p>
   </li>
-  <li>API 層級 <p>透過使用 <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk&gt;}</a>元素。</p>
+  <li>API 層級 <p>透過使用 <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a>元素。</p>
   </li>
   <li>CPU 架構 (ABI) <p>透過納入使用 <a href="{@docRoot}tools/sdk/ndk/index.html">Android NDK</a> (針對諸如 ARM EABI v7 或 x86 等特定 CPU 架構) 而建置的原生資源庫。</p>
   </li>
diff --git a/docs/html-intl/intl/zh-tw/preview/api-overview.jd b/docs/html-intl/intl/zh-tw/preview/api-overview.jd
index f6c5696..a68f0cd 100644
--- a/docs/html-intl/intl/zh-tw/preview/api-overview.jd
+++ b/docs/html-intl/intl/zh-tw/preview/api-overview.jd
@@ -133,8 +133,8 @@
 <pre class="no-prettyprint">
 adb -e emu finger touch &lt;finger_id&gt;
 </pre>
-<p>在 Windows 上，您可能必須執行 {@code telnet 127.0.0.1 &lt;emulator-id&gt;}，後面接著
-{@code finger touch &lt;finger_id&gt;}。
+<p>在 Windows 上，您可能必須執行 {@code telnet 127.0.0.1 <emulator-id>}，後面接著
+{@code finger touch <finger_id>}。
 </p>
 </li>
 </ol>
@@ -193,7 +193,7 @@
 
 <p>針對您要向 {@code ChooserTargetService} 公開的每個活動，在您的應用程式宣示說明中，新增名稱為
 {@code "android.service.chooser.chooser_target_service"} 的
-{@code &lt;meta-data&gt;} 元素。
+{@code <meta-data>} 元素。
 </p>
 
 <pre>
diff --git a/docs/html-intl/intl/zh-tw/training/basics/activity-lifecycle/starting.jd b/docs/html-intl/intl/zh-tw/training/basics/activity-lifecycle/starting.jd
index 3453ac5..fae2fa3 100644
--- a/docs/html-intl/intl/zh-tw/training/basics/activity-lifecycle/starting.jd
+++ b/docs/html-intl/intl/zh-tw/training/basics/activity-lifecycle/starting.jd
@@ -149,7 +149,7 @@
 </p>
 
 <p>必須在宣示說明中使用 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a> (包括 {@link
+<intent-filter>}</a> (包括 {@link
 android.content.Intent#ACTION_MAIN MAIN} 行為與 {@link android.content.Intent#CATEGORY_LAUNCHER LAUNCHER} 類別) 宣告您應用程式的主要應用行為顯示。
 例如：</p> 
 
diff --git a/docs/html-intl/intl/zh-tw/training/basics/intents/filters.jd b/docs/html-intl/intl/zh-tw/training/basics/intents/filters.jd
index 2088b27..6b4eebf 100644
--- a/docs/html-intl/intl/zh-tw/training/basics/intents/filters.jd
+++ b/docs/html-intl/intl/zh-tw/training/basics/intents/filters.jd
@@ -31,7 +31,7 @@
 
 </p>
 
-<p>若要允許其他應用程式啟動您的應用行為顯示，需要在您的宣示說明檔案中針對對應的 <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> 元素新增 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a> 元素。
+<p>若要允許其他應用程式啟動您的應用行為顯示，需要在您的宣示說明檔案中針對對應的 <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> 元素新增 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a> 元素。
 </p>
 
 <p>若您的應用程式安裝在裝置上，系統會識別您的意圖篩選器，並將資訊新增至安裝的所有應用程式都支援的意圖內部目錄中。在應用程式使用隱含意圖呼叫 {@link android.app.Activity#startActivity
@@ -56,13 +56,13 @@
   <dt>行為</dt>
     <dd>對要執行的行為進行命名的字串。通常是平台所定義值 (例如 {@link android.content.Intent#ACTION_SEND} 或 {@link android.content.Intent#ACTION_VIEW}) 的其中之一。
 
-    <p>請在您的意圖篩選器中使用 <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action&gt;}</a> 元素指定此項目。在此元素中指定的值必須是行為的完整字串名稱，而非 API 常數 (請參閱以下範例)。
+    <p>請在您的意圖篩選器中使用 <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code <action>}</a> 元素指定此項目。在此元素中指定的值必須是行為的完整字串名稱，而非 API 常數 (請參閱以下範例)。
 
 </p></dd>
 
   <dt>資料</dt>
     <dd>對意圖所關聯資料的描述。
-    <p>請在意圖篩選器中使用 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a> 元素指定此項目。在此元素中使用一或多個屬性，您可以僅指定 MIME 類型、URI 首碼、URI 配置，或指定這些項目的組合，以及表示所接受資料類型的其他項目。
+    <p>請在意圖篩選器中使用 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a> 元素指定此項目。在此元素中使用一或多個屬性，您可以僅指定 MIME 類型、URI 首碼、URI 配置，或指定這些項目的組合，以及表示所接受資料類型的其他項目。
 
 
 </p>
@@ -76,11 +76,11 @@
 系統支援多種不同的類別，但大多數類別很少使用。
 然而依預設，所有隱含意圖都與 {@link android.content.Intent#CATEGORY_DEFAULT} 一併定義。
 
-    <p>請在意圖篩選器中使用 <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category&gt;}</a> 元素指定此項目。
+    <p>請在意圖篩選器中使用 <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a> 元素指定此項目。
 </p></dd>
 </dl>
 
-<p>在意圖篩選器中，您可以宣告每個條件以及 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a> 元素中巢套的對應 XML 元素，以宣告應用行為顯示所接受的條件。
+<p>在意圖篩選器中，您可以宣告每個條件以及 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a> 元素中巢套的對應 XML 元素，以宣告應用行為顯示所接受的條件。
 
 </p>
 
@@ -99,10 +99,10 @@
 </pre>
 
 <p>傳入的每項意圖只會指定一項行為與一種資料類型，但是在每個 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a> 中，可以宣告 <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
-&lt;action&gt;}</a>、<a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
-&lt;category&gt;}</a> 與 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
-&lt;data&gt;}</a> 元素的多個執行個體。
+<intent-filter>}</a> 中，可以宣告 <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
+<action>}</a>、<a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
+<category>}</a> 與 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
+<data>}</a> 元素的多個執行個體。
 
 </p>
 
diff --git a/docs/html/about/dashboards/index.jd b/docs/html/about/dashboards/index.jd
index e04940b..ff6b681 100644
--- a/docs/html/about/dashboards/index.jd
+++ b/docs/html/about/dashboards/index.jd
@@ -112,10 +112,10 @@
 
 <p>To declare which version of OpenGL ES your application requires, you should use the {@code
 android:glEsVersion} attribute of the <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element. You can also use the <a
 href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a> element to declare the GL compression formats that your application
+<supports-gl-texture>}</a> element to declare the GL compression formats that your application
 uses.</p>
 
 
diff --git a/docs/html/about/versions/android-1.6.jd b/docs/html/about/versions/android-1.6.jd
index 8e97ff6..e727f55 100644
--- a/docs/html/about/versions/android-1.6.jd
+++ b/docs/html/about/versions/android-1.6.jd
@@ -296,7 +296,7 @@
 
     <ul>
       <li>New <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code 
-      &lt;supports-screens>}</a> element lets you specify the device screen sizes that your 
+      <supports-screens>}</a> element lets you specify the device screen sizes that your
       application is designed and tested to support, where "size" is a combination
       of resolution and density. If your application is run on a device whose screen 
       size is not specified in the <code>&lt;supports-screen&gt;</code> element, the system 
@@ -331,7 +331,7 @@
     </p>
     </li>
 
-      <li>New <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature>}</a>
+      <li>New <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
         element lets an application specify hardware (or other)
         features that it requires to function normally. When an application
         specifies such features, the system allows the application to be installed only
@@ -345,7 +345,7 @@
         </ul>
       </li>
       <li>New attributes for the 
-      <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk>}</a> element:
+      <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a> element:
         <ul>
           <li><code>targetSdkVersion</code>: Indicates the API Level that the application is targeting. 
           It is able to run on older versions (down to minSdkVersion), but was explicitly tested to 
diff --git a/docs/html/about/versions/android-2.0-highlights.jd b/docs/html/about/versions/android-2.0-highlights.jd
index 3b23e4d..c16088a 100644
--- a/docs/html/about/versions/android-2.0-highlights.jd
+++ b/docs/html/about/versions/android-2.0-highlights.jd
@@ -159,7 +159,7 @@
       <li>Database API support, for client-side databases using SQL.</li>
       <li>Application cache support, for offline applications.</li>
       <li>Geolocation API support, to provide location information about the device.</li>
-      <li>{@code &lt;video>} tag support in fullscreen mode.</li>
+      <li>{@code <video>} tag support in fullscreen mode.</li>
     </ul>
   </li>
 </ul>
diff --git a/docs/html/about/versions/android-2.3.jd b/docs/html/about/versions/android-2.3.jd
index 4b8ef91..34fdb52 100644
--- a/docs/html/about/versions/android-2.3.jd
+++ b/docs/html/about/versions/android-2.3.jd
@@ -589,7 +589,7 @@
 <ul>
 <li>New <code>xlargeScreens</code> attribute for <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a>
+<supports-screens>}</a>
 element, to indicate whether the application supports
 extra large screen form-factors. For details, see <a
 href="{@docRoot}guide/practices/screens_support.html">Supporting Multiple
diff --git a/docs/html/about/versions/android-3.0.jd b/docs/html/about/versions/android-3.0.jd
index f319fed..5184743 100644
--- a/docs/html/about/versions/android-3.0.jd
+++ b/docs/html/about/versions/android-3.0.jd
@@ -257,7 +257,7 @@
 such as from a content provider.</p>
 
 <p>The {@link android.appwidget.AppWidgetProviderInfo} class (defined in XML with an {@code
-&lt;appwidget-provider&gt;} element) also supports two new fields: {@link
+<appwidget-provider>} element) also supports two new fields: {@link
 android.appwidget.AppWidgetProviderInfo#autoAdvanceViewId} and {@link
 android.appwidget.AppWidgetProviderInfo#previewImage}. The {@link
 android.appwidget.AppWidgetProviderInfo#autoAdvanceViewId} field lets you specify the view ID of the
@@ -535,9 +535,9 @@
 
 <p>You can now enable the OpenGL renderer for your application by setting {@code
 android:hardwareAccelerated="true"} in your manifest element's <a
-href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 element or for individual <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
 elements.</p>
 
 <p>This flag helps applications by making them draw faster. This results in smoother animations,
@@ -683,7 +683,7 @@
 href="{@docRoot}guide/topics/ui/menus.html#options-menu">Options Menu</a>, you can register keyboard
 shortcuts by setting either the {@code android:alphabeticShortcut} or {@code
 android:numericShortcut} attribute for each <a
-href="{@docRoot}guide/topics/resources/menu-resource.html#item-element">{@code &lt;item&gt;}</a>
+href="{@docRoot}guide/topics/resources/menu-resource.html#item-element">{@code <item>}</a>
 element (or with {@link android.view.MenuItem#setShortcut setShortcut()}).</li>
 
 <li>Android 3.0 includes a new "virtual keyboard" device with the id {@link
@@ -715,9 +715,9 @@
 <li>The {@link android.R.attr#splitMotionEvents android:splitMotionEvents} attribute for view groups
 allows you to disable split touch events that occur between child views in a layout. For example:
 <pre>
-&lt;LinearLayout android:splitMotionEvents="false" ... >
+&lt;LinearLayout android:splitMotionEvents="false" ... &gt;
     ...
-&lt;/LinearLayout>
+&lt;/LinearLayout&gt;
 </pre>
 <p>This way, child views in the linear layout cannot split touch events&mdash;only one view can
 receive touch events at a time.</p>
@@ -727,14 +727,14 @@
 allows you to disable split touch events across windows, by applying it to a theme for the activity
 or entire application. For example:
 <pre>
-&lt;style name="NoSplitMotionEvents" parent="android:Theme.Holo">
-    &lt;item name="android:windowEnableSplitTouch">false&lt;/item>
+&lt;style name="NoSplitMotionEvents" parent="android:Theme.Holo"&gt;
+    &lt;item name="android:windowEnableSplitTouch">false&lt;/item&gt;
     ...
-&lt;/style>
+&lt;/style&gt;
 </pre>
 <p>When this theme is applied to an <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> or <a
-href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>,
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> or <a
+href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>,
 only touch events within the current activity window are accepted. For example, by disabling split
 touch events across windows, the system bar cannot receive touch events at the same time as the
 activity. This does <em>not</em> affect whether views inside the activity can split touch
@@ -794,7 +794,7 @@
 capabilities of the device. For example, the following HTML provides an input for the user to
 capture a photo to upload:</p>
 <pre>
-&lt;input type="file" accept="image/*;capture=camera" />
+&lt;input type="file" accept="image/*;capture=camera" /&gt;
 </pre>
 <p>Or by excluding the {@code capture=camera} parameter, the user can choose to either capture a
 new image with the camera or select one from the device (such as from the Gallery application).</p>
@@ -850,7 +850,7 @@
 <h3>New feature constants</h3>
 
 <p>The <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a> 
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 manfest element should be used to inform external entities (such as Google Play) of the set of
 hardware and software features on which your application depends. In this release, Android adds the
 following new constants that applications can declare with this element:</p>
@@ -868,14 +868,14 @@
 <em>not</em> want your application filtered from devices with an emulated touchscreen, you
 should declare {@link
 android.content.pm.PackageManager#FEATURE_FAKETOUCH "android.hardware.faketouch"} with a <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element. This way, your application will be available to the greatest number of device types,
 including those that provide only an emulated touchscreen input.</p>
     <p>All devices that include a touchscreen also support {@link
 android.content.pm.PackageManager#FEATURE_FAKETOUCH "android.hardware.faketouch"}, because
 touchscreen capabilities are a superset of faketouch capabilities. Thus, unless you actually require
 a touchscreen, you should add a <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element for faketouch.</p>
   </li>
 </ul>
@@ -889,14 +889,14 @@
   <li>{@link android.Manifest.permission#BIND_REMOTEVIEWS
 "android.permission.BIND_REMOTEVIEWS"}
   <p>This must be declared as a required permission in the <a
-href="{@docRoot}guide/topics/manifest/service-element.html">{@code &lt;service&gt;}</a> manifest
+href="{@docRoot}guide/topics/manifest/service-element.html">{@code <service>}</a> manifest
 element for an implementation of {@link android.widget.RemoteViewsService}. For example, when
 creating an App Widget that uses {@link android.widget.RemoteViewsService} to populate a
 collection view, the manifest entry may look like this:</p>
 <pre>
 &lt;service android:name=".widget.WidgetService"
     android:exported="false"
-    android:permission="android.permission.BIND_REMOTEVIEWS" />
+    android:permission="android.permission.BIND_REMOTEVIEWS" /&gt;
 </pre>
 </ul>
 
diff --git a/docs/html/about/versions/android-3.1.jd b/docs/html/about/versions/android-3.1.jd
index c22dfaa..cdcf51e 100644
--- a/docs/html/about/versions/android-3.1.jd
+++ b/docs/html/about/versions/android-3.1.jd
@@ -388,8 +388,8 @@
     android:previewImage="@drawable/preview"
     android:initialLayout="@layout/example_appwidget"
     android:configure="com.example.android.ExampleAppWidgetConfigure"
-    android:resizeMode="horizontal|vertical" >
-&lt;/appwidget-provider></pre>
+    android:resizeMode="horizontal|vertical" &gt;
+&lt;/appwidget-provider&gt;</pre>
 
 <p>For more information about Home screen widgets, see the <a
 href="{@docRoot}guide/topics/appwidgets/index.html">App Widgets</a>
@@ -809,7 +809,7 @@
 in this version of the platform. Developers declare these and other feature
 constants in <a
 href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code
-&lt;uses-feature&gt;}</a> manifest elements.
+<uses-feature>}</a> manifest elements.
 
 <ul>
   <li>{@link android.content.pm.PackageManager#FEATURE_USB_ACCESSORY
@@ -824,7 +824,7 @@
 
 <p>Google Play filters applications based on features declared in <a
 href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code
-&lt;uses-feature&gt;}</a> manifest elements. For more information about
+<uses-feature>}</a> manifest elements. For more information about
 declaring features in an application manifest, read <a
 href="{@docRoot}google/play/filters.html">Google Play
 Filters</a>.</p>
diff --git a/docs/html/about/versions/android-3.2.jd b/docs/html/about/versions/android-3.2.jd
index ef95337..887755c 100644
--- a/docs/html/about/versions/android-3.2.jd
+++ b/docs/html/about/versions/android-3.2.jd
@@ -481,7 +481,7 @@
 Play of required hardware and software capabilities. You declare these
 and other feature constants in <a
 href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code
-&lt;uses-feature&gt;}</a> manifest elements.
+<uses-feature>}</a> manifest elements.
 
 <p>Google Play filters applications based on their <code>&lt;uses-feature&gt;</code> attributes, to ensure that they are available only to devices on which their requirements are met. </p>
 
diff --git a/docs/html/about/versions/android-4.0.3.jd b/docs/html/about/versions/android-4.0.3.jd
index 4c2ccb9..fef9ce1 100644
--- a/docs/html/about/versions/android-4.0.3.jd
+++ b/docs/html/about/versions/android-4.0.3.jd
@@ -297,7 +297,7 @@
 application against an Android platform that supports API level {@sdkPlatformApiLevel} or
 higher. Depending on your needs, you might also need to add an
 <code>android:minSdkVersion="{@sdkPlatformApiLevel}"</code> attribute to the
-<a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk&gt;}</a>
+<a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a>
 element.</p>
 
 <p>For more information, see the <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#ApiLevels">API Levels</a>
diff --git a/docs/html/about/versions/android-4.0.jd b/docs/html/about/versions/android-4.0.jd
index cc1d1c7..1b103b7 100644
--- a/docs/html/about/versions/android-4.0.jd
+++ b/docs/html/about/versions/android-4.0.jd
@@ -909,9 +909,9 @@
 
 <p>Applications with a spell checker service must declare the {@link
 android.Manifest.permission#BIND_TEXT_SERVICE} permission as required by the service.
-The service must also declare an intent filter with {@code &lt;action
+The service must also declare an intent filter with {@code <action
 android:name="android.service.textservice.SpellCheckerService" />} as the intent’s action and should
-include a {@code &lt;meta-data&gt;} element that declares configuration information for the spell
+include a {@code <meta-data>} element that declares configuration information for the spell
 checker. </p>
 
 <p>See the sample <a href="{@docRoot}resources/samples/SpellChecker/SampleSpellCheckerService/index.html">
@@ -997,12 +997,12 @@
 action. For example:</p>
 
 <pre>
-&lt;activity android:name="DataPreferences" android:label="@string/title_preferences">
-    &lt;intent-filter>
-       &lt;action android:name="android.intent.action.MANAGE_NETWORK_USAGE" />
-       &lt;category android:name="android.intent.category.DEFAULT" />
-    &lt;/intent-filter>
-&lt;/activity>
+&lt;activity android:name="DataPreferences" android:label="@string/title_preferences"&gt;
+    &lt;intent-filter&gt;
+       &lt;action android:name="android.intent.action.MANAGE_NETWORK_USAGE" /&gt;
+       &lt;category android:name="android.intent.category.DEFAULT" /&gt;
+    &lt;/intent-filter&gt;
+&lt;/activity&gt;
 </pre>
 
 <p>This intent filter indicates to the system that this is the activity that controls your
@@ -1054,7 +1054,7 @@
 <p>Applications that manage the device restrictions can now disable the camera using {@link
 android.app.admin.DevicePolicyManager#setCameraDisabled setCameraDisabled()} and the {@link
 android.app.admin.DeviceAdminInfo#USES_POLICY_DISABLE_CAMERA} property (applied with a {@code
-&lt;disable-camera /&gt;} element in the policy configuration file).</p>
+<disable-camera />} element in the policy configuration file).</p>
 
 
 <h4>Certificate management</h4>
@@ -1120,10 +1120,10 @@
 allows you to enable “split action bar" so that more action items can appear on the screen in a
 separate bar at the bottom of the screen. To enable split action bar, add {@link
 android.R.attr#uiOptions android:uiOptions} with {@code "splitActionBarWhenNarrow"} to either your
-<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 tag or
 individual <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity&gt;}</a> tags
+<activity>}</a> tags
 in your manifest file. When enabled, the system will add an additional bar at the bottom of the
 screen for all action items when the screen is narrow (no action items will appear in the primary
 action bar).</p>
@@ -1166,7 +1166,7 @@
 
 <p>To declare an action provider for an action item, include the {@code android:actionProviderClass}
 attribute in the <a href="{@docRoot}guide/topics/resources/menu-resource.html#item-element">{@code
-&lt;item&gt;}</a> element for your activity’s options menu, with the class name of the action
+<item>}</a> element for your activity’s options menu, with the class name of the action
 provider as the value. For example:</p>
 
 <pre>
@@ -1208,7 +1208,7 @@
 <p>To declare that an action item that contains an action view be collapsible, include the {@code
 “collapseActionView"} flag in the {@code android:showAsAction} attribute for the <a
 href="{@docRoot}guide/topics/resources/menu-resource.html#item-element">{@code
-&lt;item&gt;}</a> element in the menu’s XML file.</p>
+<item>}</a> element in the menu’s XML file.</p>
 
 <p>To receive callbacks when an action view switches between expanded and collapsed, register an
 instance of {@link android.view.MenuItem.OnActionExpandListener} with the respective {@link
@@ -1560,8 +1560,8 @@
 <p>If necessary, you can manually disable hardware acceleration with the <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#hwaccel">{@code hardwareAccelerated}</a>
 attribute for individual <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity&gt;}</a> elements or the <a
-href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+<activity>}</a> elements or the <a
+href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 element. You can alternatively disable hardware acceleration for individual views by calling {@link
 android.view.View#setLayerType setLayerType(LAYER_TYPE_SOFTWARE)}.</p>
 
@@ -1759,7 +1759,7 @@
 href="http://android-developers.blogspot.com/2011/07/new-tools-for-managing-screen-sizes.html">
 New Tools for Managing Screen Sizes</a>.</li>
       <li>New constants for <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a> to
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> to
 declare landscape or portrait screen orientation requirements.</li>
       <li>The device "screen size" configuration now changes during a screen orientation
 change. If your app targets API level 13 or higher, you must handle the {@code "screenSize"}
@@ -1787,7 +1787,7 @@
 application against an Android platform that supports API level {@sdkPlatformApiLevel} or
 higher. Depending on your needs, you might also need to add an
 <code>android:minSdkVersion="{@sdkPlatformApiLevel}"</code> attribute to the
-<a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk&gt;}</a>
+<a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a>
 element.</p>
 
 <p>For more information, read <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#ApiLevels">What is API
diff --git a/docs/html/about/versions/android-4.1.jd b/docs/html/about/versions/android-4.1.jd
index f8770fa..4131c36 100644
--- a/docs/html/about/versions/android-4.1.jd
+++ b/docs/html/about/versions/android-4.1.jd
@@ -149,7 +149,7 @@
 <h3 id="Isolated">Isolated services</h3>
 
 <p>By specifying <a href="{@docRoot}guide/topics/manifest/service-element.html#isolated">{@code android:isolatedProcess="true"}</a> in the 
-<a href="{@docRoot}guide/topics/manifest/service-element.html">{@code &lt;service>}</a> tag, your {@link android.app.Service} will run under
+<a href="{@docRoot}guide/topics/manifest/service-element.html">{@code <service>}</a> tag, your {@link android.app.Service} will run under
 its own isolated user ID process that has no permissions of its own.</p>
 
 
@@ -196,7 +196,7 @@
 All you need to do is add the <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#parent">{@code
 android:parentActivityName}</a> to each <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a> element in
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element in
 your manifest file. The system uses this information to open the appropriate activity when the user
 presses the Up button in the action bar (while also finishing the current activity). So if you
 declare the <a href="{@docRoot}guide/topics/manifest/activity-element.html#parent">{@code
@@ -287,7 +287,7 @@
 adding <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#parent">{@code
 android:parentActivityName}</a> to each <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a> element.</p>
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element.</p>
 
 
 
@@ -889,13 +889,13 @@
 <p>Android 4.1 includes a new feature declaration for devices that are dedicated
 to displaying the user interface on a television screen: {@link
 android.content.pm.PackageManager#FEATURE_TELEVISION}. To declare that your app requires
-a television interface, declare this feature in your manifest file with the <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature>}</a> element:</p>
+a television interface, declare this feature in your manifest file with the <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> element:</p>
 <pre>
-&lt;manifest ... >
+&lt;manifest ... &gt;
     &lt;uses-feature android:name="android.hardware.type.television"
-                  android:required="true" />
+                  android:required="true" /&gt;
     ...
-&lt;/manifest>
+&lt;/manifest&gt;
 </pre>
 
 <p>This feature defines "television" to be a typical living room television experience: 
diff --git a/docs/html/about/versions/android-4.2.jd b/docs/html/about/versions/android-4.2.jd
index 76acb8a..f903156 100644
--- a/docs/html/about/versions/android-4.2.jd
+++ b/docs/html/about/versions/android-4.2.jd
@@ -166,18 +166,18 @@
 
 <p>To make your daydream available to the system, declare your {@link
 android.service.dreams.DreamService} with a <a
-href="{@docRoot}guide/topics/manifest/service-element.html">{@code &lt;service>}</a> element
+href="{@docRoot}guide/topics/manifest/service-element.html">{@code <service>}</a> element
 in your manifest file. You must then include an intent filter with the action {@code
 "android.service.dreams.DreamService"}. For example:</p>
 
 <pre>
 &lt;service android:name=".MyDream" android:exported="true"
-    android:icon="@drawable/dream_icon" android:label="@string/dream_label" >
-    &lt;intent-filter>
-        &lt;action android:name="android.service.dreams.DreamService" />
-        &lt;category android:name="android.intent.category.DEFAULT" />
-    &lt;/intent-filter>
-&lt;/service>
+    android:icon="@drawable/dream_icon" android:label="@string/dream_label" &gt;
+    &lt;intent-filter&gt;
+        &lt;action android:name="android.service.dreams.DreamService" /&gt;
+        &lt;category android:name="android.intent.category.DEFAULT" /&gt;
+    &lt;/intent-filter&gt;
+&lt;/service&gt;
 </pre>
 
 <p>There are some other useful methods in {@link android.service.dreams.DreamService}
@@ -255,7 +255,7 @@
 secondary screens, you can apply
 a different theme by specifying the {@link
 android.R.attr#presentationTheme android:presentationTheme} attribute in the <a
-href="{@docRoot}guide/topics/resources/style-resource.html">{@code &lt;style>}</a> that you’ve
+href="{@docRoot}guide/topics/resources/style-resource.html">{@code <style>}</a> that you’ve
 applied to your application or activity.</p>
 
 <p>Keep in mind that screens connected to the user’s device often have a larger screen size and
@@ -294,8 +294,8 @@
 <pre>
 &lt;appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
     ...
-    android:widgetCategory="keyguard|home_screen">
-&lt;/appwidget-provider>
+    android:widgetCategory="keyguard|home_screen"&gt;
+&lt;/appwidget-provider&gt;
 </pre>
 
 <p>You should also specify an initial layout for your app widget when on the lock screen with
@@ -399,7 +399,7 @@
 direction, such as Arabic and Hebrew.</p>
 
 <p>To begin supporting RTL layouts in your app, set the {@link android.R.attr#supportsRtl
-android:supportsRtl} attribute to the {@code &lt;application>} element in your manifest file
+android:supportsRtl} attribute to the {@code <application>} element in your manifest file
 and set it {@code “true"}. Once you enable this, the system will enable various RTL APIs to
 display your app with RTL layouts. For instance, the action bar will show the icon and title
 on the right side and action buttons on the left, and any layouts you’ve created with the
@@ -483,7 +483,7 @@
 fragment designs on Android 1.6 and higher.</p>
 
 <p><strong>Note:</strong> You cannot inflate a layout into a fragment when that layout
-includes a {@code &lt;fragment>}. Nested fragments are only supported when added to a
+includes a {@code <fragment>}. Nested fragments are only supported when added to a
 fragment dynamically.</p>
 
 
diff --git a/docs/html/about/versions/android-4.3.jd b/docs/html/about/versions/android-4.3.jd
index 2496854..547b2f8 100644
--- a/docs/html/about/versions/android-4.3.jd
+++ b/docs/html/about/versions/android-4.3.jd
@@ -204,7 +204,7 @@
 app depends on account information that's sensitive, specify the <a
 href="{@docRoot}guide/topics/manifest/application-element.html#requiredAccountType">{@code
 android:requiredAccountType}</a> attribute in your manifest's <a
-href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application>}</a>
+href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 element.</p>
 
 <p>If you’d like to allow restricted profiles to continue using your app even though they can’t
@@ -298,10 +298,10 @@
 
 <li><strong>Allow access to the owner’s accounts from a restricted profile.</strong>
 <p>To get access to an account from a restricted profile, you must add the <a href="{@docRoot}guide/topics/manifest/application-element.html#restrictedAccountType">{@code android:restrictedAccountType}</a> attribute to the <a
-href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application></a> tag:</p>
+href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a> tag:</p>
 <pre>
 &lt;application ...
-    android:restrictedAccountType="com.example.account.type" >
+    android:restrictedAccountType="com.example.account.type" &gt;
 </pre>
 
 <p class="caution"><strong>Caution:</strong> Enabling this attribute provides your
@@ -341,10 +341,10 @@
 currently cannot add new accounts), add
 the <a href="{@docRoot}guide/topics/manifest/application-element.html#requiredAccountType">{@code
 android:requiredAccountType}</a> attribute to the <a
-href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application></a> tag:</p>
+href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a> tag:</p>
 <pre>
 &lt;application ...
-    android:requiredAccountType="com.example.account.type" >
+    android:requiredAccountType="com.example.account.type" &gt;
 </pre>
 <p>For example, the Gmail app uses this attribute to disable itself for restricted profiles,
 because the owner's personal email should not be available to restricted profiles.</p>
@@ -363,10 +363,10 @@
 
 <p>Because Bluetooth LE is a hardware feature that is not available on all
 Android-powered devices, you must declare in your manifest file a <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature>}</a>
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element for {@code "android.hardware.bluetooth_le"}:</p>
 <pre>
-&lt;uses-feature android:name="android.hardware.bluetooth_le" android:required="true" />
+&lt;uses-feature android:name="android.hardware.bluetooth_le" android:required="true" /&gt;
 </pre>
 
 <p>If you're already familiar with Android's Classic Bluetooth APIs, notice that using the
@@ -592,13 +592,13 @@
 
 <p>The Java interface for OpenGL ES 3.0 on Android is provided with {@link android.opengl.GLES30}.
 When using OpenGL ES 3.0, be sure that you declare it in your manifest file with the
-<a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">&lt;uses-feature></a>
+<a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">&lt;uses-feature&gt;</a>
 tag and the {@code android:glEsVersion} attribute. For example:</p>
 <pre>
-&lt;manifest>
-    &lt;uses-feature android:glEsVersion="0x00030000" />
+&lt;manifest&gt;
+    &lt;uses-feature android:glEsVersion="0x00030000" /&gt;
     ...
-&lt;/manifest>
+&lt;/manifest&gt;
 </pre>
 
 <p>And remember to specify the OpenGL ES context by calling {@link
@@ -740,7 +740,7 @@
 <p style="clear:left">To align the views based on their optical bounds, set the {@code android:layoutMode} attribute to {@code "opticalBounds"} in one of the parent layouts. For example:</p>
 
 <pre>
-&lt;LinearLayout android:layoutMode="opticalBounds" ... >
+&lt;LinearLayout android:layoutMode="opticalBounds" ... &gt;
 </pre>
 
 
@@ -818,7 +818,7 @@
 <h3 id="Orientation">Screen orientation</h3>
 
 <p>The <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a>
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
 tag's <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#screen">{@code screenOrientation}</a>
 attribute now supports additional values to honor the user's preference for auto-rotation:</p>
@@ -1110,7 +1110,7 @@
 <h3 id="ManifestFeatures">Declarable required features</h3>
 
 <p>The following values are now supported in the <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature>}</a>
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element so you can ensure that your app is installed only on devices that provide the features
 your app needs.</p>
 
@@ -1120,7 +1120,7 @@
 include a Home screen or similar location where users can embed app widgets.
 Example:
 <pre>
-&lt;uses-feature android:name="android.software.app_widgets" android:required="true" />
+&lt;uses-feature android:name="android.software.app_widgets" android:required="true" /&gt;
 </pre>
 </dd>
 
@@ -1129,7 +1129,7 @@
 devices that support third-party Home screen apps.
 Example:
 <pre>
-&lt;uses-feature android:name="android.software.home_screen" android:required="true" />
+&lt;uses-feature android:name="android.software.home_screen" android:required="true" /&gt;
 </pre>
 </dd>
 
@@ -1139,7 +1139,7 @@
 support third-party input methods.
 Example:
 <pre>
-&lt;uses-feature android:name="android.software.input_methods" android:required="true" />
+&lt;uses-feature android:name="android.software.input_methods" android:required="true" /&gt;
 </pre>
 </dd>
 
@@ -1148,7 +1148,7 @@
 that are capable of communicating with other devices via Bluetooth Low Energy.
 Example:
 <pre>
-&lt;uses-feature android:name="android.software.bluetooth_le" android:required="true" />
+&lt;uses-feature android:name="android.software.bluetooth_le" android:required="true" /&gt;
 </pre>
 </dd>
 </dl>
@@ -1156,7 +1156,7 @@
 
 <h3 id="ManifestPermissions">User permissions</h3>
 <p>The following values are now supported in the <a
-href="{@docRoot}guide/topics/manifest/uses-permission-element.html">{@code &lt;uses-permission>}</a>
+href="{@docRoot}guide/topics/manifest/uses-permission-element.html">{@code <uses-permission>}</a>
 to declare the
 permissions your app requires in order to access certain APIs.</p>
 
diff --git a/docs/html/about/versions/android-4.4.jd b/docs/html/about/versions/android-4.4.jd
index 3de2acc..0d58a1d 100644
--- a/docs/html/about/versions/android-4.4.jd
+++ b/docs/html/about/versions/android-4.4.jd
@@ -257,7 +257,7 @@
 
 <p>When running on a device that includes an infrared (IR) transmitter, you can now transmit IR signals using the {@link android.hardware.ConsumerIrManager} APIs. To get an instance of {@link android.hardware.ConsumerIrManager}, call {@link android.content.Context#getSystemService getSystemService()} with {@link android.content.Context#CONSUMER_IR_SERVICE} as the argument. You can then query the device's supported IR frequencies with {@link android.hardware.ConsumerIrManager#getCarrierFrequencies()} and transmit signals by passing your desired frequency and signal pattern with {@link android.hardware.ConsumerIrManager#transmit transmit()}.</p>
 
-<p>You should always first check whether a device includes an IR transmitter by calling {@link android.hardware.ConsumerIrManager#hasIrEmitter()}, but if your app is compatible only with devices that do have one, you should include a <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature>}</a> element in your manifest for {@code "android.hardware.consumerir"} ({@link android.content.pm.PackageManager#FEATURE_CONSUMER_IR}).</p>
+<p>You should always first check whether a device includes an IR transmitter by calling {@link android.hardware.ConsumerIrManager#hasIrEmitter()}, but if your app is compatible only with devices that do have one, you should include a <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> element in your manifest for {@code "android.hardware.consumerir"} ({@link android.content.pm.PackageManager#FEATURE_CONSUMER_IR}).</p>
 
 
 
@@ -372,7 +372,7 @@
 
 <p>Alternatively, you don't need to create a {@link android.transition.Scene} object at all, but can instead call {@link android.transition.TransitionManager#beginDelayedTransition beginDelayedTransition()}, specifying a {@link android.view.ViewGroup} that contains the views you want to change. Then add, remove, or reconfigure the target views. After the system lays out the changes as necessary, a transition starts to animate all the affected views.</p>
 
-<p>For additional control, you can define sets of transitions that should occur between pre-defined scenes, using an XML file in your project {@code res/transition/} directory. Inside a {@code &lt;transitionManager>} element, specify one or more {@code &lt;transition>} tags that each specify a scene (a reference to a layout file) and the transition to apply when entering and/or exiting that scene. Then inflate this set of transitions using {@link android.transition.TransitionInflater#inflateTransitionManager inflateTransitionManager()}. Use the returned {@link android.transition.TransitionManager} to execute each transition with {@link android.transition.TransitionManager#transitionTo transitionTo()}, passing a {@link android.transition.Scene} that is represented by one of the {@code &lt;transition>} tags. You can also define sets of transitions programmatically with the {@link android.transition.TransitionManager} APIs.</p>
+<p>For additional control, you can define sets of transitions that should occur between pre-defined scenes, using an XML file in your project {@code res/transition/} directory. Inside a {@code <transitionManager>} element, specify one or more {@code <transition>} tags that each specify a scene (a reference to a layout file) and the transition to apply when entering and/or exiting that scene. Then inflate this set of transitions using {@link android.transition.TransitionInflater#inflateTransitionManager inflateTransitionManager()}. Use the returned {@link android.transition.TransitionManager} to execute each transition with {@link android.transition.TransitionManager#transitionTo transitionTo()}, passing a {@link android.transition.Scene} that is represented by one of the {@code <transition>} tags. You can also define sets of transitions programmatically with the {@link android.transition.TransitionManager} APIs.</p>
 
 <p>When specifying a transition, you can use several predefined types defined by subclasses of {@link android.transition.Transition}, such as {@link android.transition.Fade} and {@link android.transition.ChangeBounds}. If you don't specify a transition type, the system uses {@link android.transition.AutoTransition} by default, which automatically fades, moves, and resizes views as necessary. Additionally, you can create custom transitions by extending any of these classes to perform the animations however you'd like. A custom transition can track any property changes you'd like, and create any animation you want to based on those changes. For example, you could provide a subclass of {@link android.transition.Transition} that listens for changes to the "rotation" property of a view then animate any changes.</p>
 
@@ -531,7 +531,7 @@
 
 <h2 id="Permissions">App Permissions</h2>
 
-<p>The following are new permissions that your app must request with the <a href="{@docRoot}guide/topics/manifest/uses-permission-element.html">{@code &lt;uses-permission>}</a> tag to use certain new APIs:</p>
+<p>The following are new permissions that your app must request with the <a href="{@docRoot}guide/topics/manifest/uses-permission-element.html">{@code <uses-permission>}</a> tag to use certain new APIs:</p>
 
 <dl>
 <dt>{@link android.Manifest.permission#INSTALL_SHORTCUT}</dt>
@@ -550,7 +550,7 @@
 
 <h2 id="DeviceFeatures">Device Features</h2>
 
-<p>The following are new device features that you can declare with the <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature>}</a> tag to declare your app requirements and enable filtering on Google Play or check for at runtime:</p>
+<p>The following are new device features that you can declare with the <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> tag to declare your app requirements and enable filtering on Google Play or check for at runtime:</p>
 
 <dl>
 <dt>{@link android.content.pm.PackageManager#FEATURE_CONSUMER_IR}</dt>
diff --git a/docs/html/about/versions/android-5.0.jd b/docs/html/about/versions/android-5.0.jd
index 8956076..1bdd2d6 100644
--- a/docs/html/about/versions/android-5.0.jd
+++ b/docs/html/about/versions/android-5.0.jd
@@ -351,7 +351,7 @@
 <p>The Java interface for OpenGL ES 3.1 on Android is provided with
   {@link android.opengl.GLES31}. When using OpenGL ES 3.1, be sure that you
   declare it in your manifest file with the
-  <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a> tag and the {@code android:glEsVersion} attribute. For example:</p>
+  <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> tag and the {@code android:glEsVersion} attribute. For example:</p>
 
 <pre>
 &lt;manifest&gt;
@@ -942,7 +942,7 @@
 
 <h3 id="ManifestFeatures">Declarable required features</h3>
 <p>The following values are now supported in the
-<a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>
+<a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element, so you can ensure that your app is installed only on devices that
 provide the features your app needs.</p>
 
@@ -968,7 +968,7 @@
 <h3 id="Permissions">User permissions</h3>
 
 <p>The following permission is now supported in the
-<a href="{@docRoot}guide/topics/manifest/uses-permission-element.html">{@code &lt;uses-permission&gt;}</a>
+<a href="{@docRoot}guide/topics/manifest/uses-permission-element.html">{@code <uses-permission>}</a>
 element to declare the permissions your app requires to access certain APIs.</p>
 
 <ul>
diff --git a/docs/html/distribute/essentials/quality/tv.jd b/docs/html/distribute/essentials/quality/tv.jd
index c7f6fcb..18c7a32 100644
--- a/docs/html/distribute/essentials/quality/tv.jd
+++ b/docs/html/distribute/essentials/quality/tv.jd
@@ -321,7 +321,7 @@
     <p style="margin-bottom:.5em;">
       If the app uses a game controller as it's primary input method, it declares the appropriate
       requirement with the <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html"
-      >{@code &lt;uses-feature>}</a> manifest tag.
+      >{@code <uses-feature>}</a> manifest tag.
       (<a href="{@docRoot}training/tv/games/index.html#gamepad">Learn how</a>)
     </p>
   </td>
diff --git a/docs/html/google/play/billing/billing_integrate.jd b/docs/html/google/play/billing/billing_integrate.jd
index eb58af4..52973a8 100644
--- a/docs/html/google/play/billing/billing_integrate.jd
+++ b/docs/html/google/play/billing/billing_integrate.jd
@@ -70,7 +70,7 @@
 <li>Select <strong>Google Play Billing Library</strong>.</li>
 <li>Click <strong>Install packages</strong> to complete the download.</li>
 </ol>
-<p>The {@code IInAppBillingService.aidl} file will be installed to {@code &lt;sdk&gt;/extras/google/play_billing/}.</p>
+<p>The {@code IInAppBillingService.aidl} file will be installed to {@code <sdk>/extras/google/play_billing/}.</p>
 
 <p>To add the AIDL to your project:</p>
 <ol>
@@ -85,7 +85,7 @@
 Application</strong> wizard to create a new project in your workspace.</li>
 	<li>In the {@code /src} directory, click <strong>File</strong> &gt;
 <strong>New</strong> &gt; <strong>Package</strong>, then create a package named {@code com.android.vending.billing}.</li>
-	<li>Copy the {@code IInAppBillingService.aidl} file from {@code &lt;sdk&gt;/extras/google/play_billing/} and paste it into the {@code src/com.android.vending.billing/}
+	<li>Copy the {@code IInAppBillingService.aidl} file from {@code <sdk>/extras/google/play_billing/} and paste it into the {@code src/com.android.vending.billing/}
 folder in your workspace.</li>
      </ol>
   </li>
diff --git a/docs/html/google/play/expansion-files.jd b/docs/html/google/play/expansion-files.jd
index 601ea48..0c514b2 100644
--- a/docs/html/google/play/expansion-files.jd
+++ b/docs/html/google/play/expansion-files.jd
@@ -131,7 +131,7 @@
   <dt>{@code main} or {@code patch}</dt>
     <dd>Specifies whether the file is the main or patch expansion file. There can be
 only one main file and one patch file for each APK.</dd>
-  <dt>{@code &lt;expansion-version&gt;}</dt>
+  <dt>{@code <expansion-version>}</dt>
     <dd>This is an integer that matches the version code of the APK with which the expansion is
 <em>first</em> associated (it matches the application's <a
 href="{@docRoot}guide/topics/manifest/manifest-element.html#vcode">{@code android:versionCode}</a>
@@ -139,7 +139,7 @@
     <p>"First" is emphasized because although the Developer Console allows you to
 re-use an uploaded expansion file with a new APK, the expansion file's name does not change&mdash;it
 retains the version applied to it when you first uploaded the file.</p></dd>
-  <dt>{@code &lt;package-name&gt;}</dt>
+  <dt>{@code <package-name>}</dt>
     <dd>Your application's Java-style package name.</dd>
 </dl>
 
@@ -162,9 +162,9 @@
 </pre>
 
 <ul>
-  <li>{@code &lt;shared-storage&gt;} is the path to the shared storage space, available from
+  <li>{@code <shared-storage>} is the path to the shared storage space, available from
 {@link android.os.Environment#getExternalStorageDirectory()}.</li>
-  <li>{@code &lt;package-name&gt;} is your application's Java-style package name, available
+  <li>{@code <package-name>} is your application's Java-style package name, available
 from {@link android.content.Context#getPackageName()}.</li>
 </ul>
 
@@ -464,7 +464,7 @@
     <ol>
       <li>Begin a new Android project.</li>
       <li>Select <strong>Create project from existing
-source</strong> and choose the library from the {@code &lt;sdk&gt;/extras/google/} directory
+source</strong> and choose the library from the {@code <sdk>/extras/google/} directory
 ({@code market_licensing/} for the License Verification Library or {@code
 market_apk_expansion/downloader_library/} for the Downloader Library).</li>
       <li>Specify a <em>Project Name</em> such as "Google Play License Library" and "Google Play
@@ -717,7 +717,7 @@
   </li>
   <li>Start the download by calling the static method {@code
 DownloaderClientMarshaller.startDownloadServiceIfRequired(Context c, PendingIntent
-notificationClient, Class&lt;?> serviceClass)}.
+notificationClient, Class<?> serviceClass)}.
     <p>The method takes the following parameters:</p>
     <ul>
       <li><code>context</code>: Your application's {@link android.content.Context}.</li>
@@ -781,7 +781,7 @@
   </li>
   <li>When the {@code startDownloadServiceIfRequired()} method returns anything <em>other
 than</em> {@code NO_DOWNLOAD_REQUIRED}, create an instance of {@code IStub} by
-calling {@code DownloaderClientMarshaller.CreateStub(IDownloaderClient client, Class&lt;?>
+calling {@code DownloaderClientMarshaller.CreateStub(IDownloaderClient client, Class<?>
 downloaderService)}. The {@code IStub} provides a binding between your activity to the downloader
 service such that your activity receives callbacks about the download progress.
     <p>In order to instantiate your {@code IStub} by calling {@code CreateStub()}, you must pass it
@@ -957,7 +957,7 @@
 depends on the type of file you've used. As discussed in the <a href="#Overview">overview</a>, your
 expansion files can be any kind of file you
 want, but are renamed using a particular <a href="#Filename">file name format</a> and are saved to
-{@code &lt;shared-storage&gt;/Android/obb/&lt;package-name&gt;/}.</p>
+{@code <shared-storage>/Android/obb/<package-name>/}.</p>
 
 <p>Regardless of how you read your files, you should always first check that the external
 storage is available for reading. There's a chance that the user has the storage mounted to a
@@ -1060,7 +1060,7 @@
 
 <p>The Google Market Apk Expansion package includes a library called the APK
 Expansion Zip Library (located in {@code
-&lt;sdk>/extras/google/google_market_apk_expansion/zip_file/}). This is an optional library that
+<sdk>/extras/google/google_market_apk_expansion/zip_file/}). This is an optional library that
 helps you read your expansion
 files when they're saved as ZIP files. Using this library allows you to easily read resources from
 your ZIP expansion files as a virtual file system.</p>
diff --git a/docs/html/google/play/filters.jd b/docs/html/google/play/filters.jd
index 1ec68c6..50cc807 100644
--- a/docs/html/google/play/filters.jd
+++ b/docs/html/google/play/filters.jd
@@ -338,24 +338,24 @@
   <tr><th>Manifest Element</th><th>Summary</th></tr>
   <tr>
     <td><nobr><a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a></nobr></td>
+<compatible-screens>}</a></nobr></td>
     <td>
       <p>Google Play filters the application if the device screen size and density does not match
-any of the screen configurations (declared by a {@code &lt;screen&gt;} element) in the {@code
-&lt;compatible-screens&gt;} element.</p>
+any of the screen configurations (declared by a {@code <screen>} element) in the {@code
+<compatible-screens>} element.</p>
       <p class="caution"><strong>Caution:</strong> Normally, <strong>you should not use
 this manifest element</strong>. Using this element can dramatically
 reduce the potential user base for your application, by excluding all combinations of screen size
 and density that you have not listed. You should instead use the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> manifest element (described above in <a href="#table1">table
+<supports-screens>}</a> manifest element (described above in <a href="#table1">table
 1</a>) to enable screen compatibility mode for screen configurations you have not accounted for
 with alternative resources.</p>
     </td>
   </tr>
   <tr>
     <td><nobr><a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a></nobr></td>
+<supports-gl-texture>}</a></nobr></td>
     <td>
       <p>Google Play filters the application unless one or more of the GL texture compression
 formats supported by the application are also supported by the device. </p>
@@ -419,17 +419,17 @@
   <li>OpenGL texture compression formats
     <p>By using the <a
 href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a> element.</p>
+<supports-gl-texture>}</a> element.</p>
   </li>
   <li>Screen size (and, optionally, screen density)
     <p>By using the <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> or <a
+<supports-screens>}</a> or <a
 href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a> element.</p>
+<compatible-screens>}</a> element.</p>
   </li>
   <li>API level
     <p>By using the <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code
-&lt;uses-sdk&gt;}</a> element.</p>
+<uses-sdk>}</a> element.</p>
   </li>
   <li>CPU Architecture (ABI)
     <p>By including native libraries built with the <a href="{@docRoot}tools/sdk/ndk/index.html">Android
diff --git a/docs/html/google/play/licensing/setting-up.jd b/docs/html/google/play/licensing/setting-up.jd
index f43e4aba..1822337 100644
--- a/docs/html/google/play/licensing/setting-up.jd
+++ b/docs/html/google/play/licensing/setting-up.jd
@@ -180,12 +180,12 @@
 
 <ol>
   <li>Launch the Android SDK Manager (available under the Eclipse <strong>Window</strong>
-menu or by executing {@code &lt;sdk>/tools/android sdk}).</li>
+menu or by executing {@code <sdk>/tools/android sdk}).</li>
   <li>Select and download <strong>Google APIs</strong> for the Android version you'd like to target
 (must be Android 2.2 or higher).</li>
   <li>When the download is complete, open the AVD Manager (available under the Eclipse
 <strong>Window</strong>
-menu or by executing {@code &lt;sdk>/tools/android avd}).</li>
+menu or by executing {@code <sdk>/tools/android avd}).</li>
   <li>Click
 <strong>New</strong> and set the configuration details for the new AVD. </li>
   <li>In the dialog that appears, assign a descriptive name to the AVD and then
diff --git a/docs/html/google/play/publishing/multiple-apks.jd b/docs/html/google/play/publishing/multiple-apks.jd
index ab08e6f..71a7ae5 100644
--- a/docs/html/google/play/publishing/multiple-apks.jd
+++ b/docs/html/google/play/publishing/multiple-apks.jd
@@ -204,7 +204,7 @@
   <li><strong>OpenGL texture compression formats</strong>
     <p>This is based on your manifest file's <a
 href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a> element(s).</p>
+<supports-gl-texture>}</a> element(s).</p>
     <p>For example, when developing a game that uses OpenGL ES, you can provide one APK for
 devices that support ATI texture compression and a separate APK for devices
 that support PowerVR compression (among many others).</p>
@@ -214,11 +214,11 @@
   <li><strong>Screen size (and, optionally, screen density)</strong>
     <p>This is based on your manifest file's <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> <em>or</em> <a
+<supports-screens>}</a> <em>or</em> <a
 href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a> element. You should never use both elements and you should use only
+<compatible-screens>}</a> element. You should never use both elements and you should use only
 <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> when possible.</p>
+<supports-screens>}</a> when possible.</p>
     <p>For example, you can provide one APK that supports small and normal size screens and another
 APK that supports large and xlarge screens.</p>
 
@@ -230,7 +230,7 @@
 with a single APK.</p>
     <p class="caution"><strong>Caution:</strong> By default, all screen size attributes in the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element are "true" if you do not declare them otherwise. However,
+<supports-screens>}</a> element are "true" if you do not declare them otherwise. However,
 because the {@code android:xlargeScreens} attribute was added in Android 2.3 (API level
 9), Google Play will assume that it is "false" if your application does not set either <a
 href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">{@code
@@ -239,9 +239,9 @@
 android:targetSdkVersion}</a> to "9" or higher.</p>
     <p class="caution"><strong>Caution:</strong> You should not combine both <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> and <a
+<supports-screens>}</a> and <a
 href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens&gt;}</a> elements in your manifest file. Using both increases the chances
+<compatible-screens>}</a> elements in your manifest file. Using both increases the chances
 that you'll introduce an error due to conflicts between them. For help deciding which to use, read
 <a href="{@docRoot}guide/practices/screens-distribution.html">Distributing to Specific Screens</a>.
 If you can't avoid using both, be aware that for any conflicts in agreement between a given size,
@@ -251,7 +251,7 @@
 
   <li><strong>Device feature sets</strong>
     <p>This is based on your manifest file's <a 
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a> 
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element(s).</p>
     <p>For example, you can provide one APK for devices that support multitouch and another
 APK for devices that do not support multitouch. See 
@@ -262,7 +262,7 @@
 
   <li><strong>API level</strong>
     <p>This is based on your manifest file's <a
-href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk&gt;}</a> element.
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a> element.
 You
 can use both the <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">{@code
 android:minSdkVersion}</a> and <a
@@ -312,7 +312,7 @@
 based on other characteristics in the manifest or APK). For
 example, you cannot provide different APKs that differ purely on the <a
 href="{@docRoot}guide/topics/manifest/uses-configuration-element.html">{@code
-&lt;uses-configuration&gt;}</a> characteristics.</p>
+<uses-configuration>}</a> characteristics.</p>
 
 
 
diff --git a/docs/html/guide/components/activities.jd b/docs/html/guide/components/activities.jd
index 5e6917b..7eeaeeb 100644
--- a/docs/html/guide/components/activities.jd
+++ b/docs/html/guide/components/activities.jd
@@ -141,9 +141,9 @@
 
 <p>You must declare your activity in the manifest file in order for it to
 be accessible to the system. To declare your activity, open your manifest file and add an <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> element
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element
 as a child of the <a
-href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 element. For example:</p>
 
 <pre>
@@ -166,16 +166,16 @@
 That Cannot Change</a>).</p>
 
 <p>See the <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> element
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element
 reference for more information about declaring your activity in the manifest.</p>
 
 
 <h4>Using intent filters</h4>
 
 <p>An <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity&gt;}</a> element can also specify various intent filters&mdash;using the <a
+<activity>}</a> element can also specify various intent filters&mdash;using the <a
 href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a> element&mdash;in order to declare how other application components may
+<intent-filter>}</a> element&mdash;in order to declare how other application components may
 activate it.</p>
 
 <p>When you create a new application using the Android SDK tools, the stub activity
@@ -193,9 +193,9 @@
 </pre>
 
 <p>The <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
-&lt;action&gt;}</a> element specifies that this is the "main" entry point to the application. The <a
+<action>}</a> element specifies that this is the "main" entry point to the application. The <a
 href="{@docRoot}guide/topics/manifest/category-element.html">{@code
-&lt;category&gt;}</a> element specifies that this activity should be listed in the
+<category>}</a> element specifies that this activity should be listed in the
 system's application launcher (to allow users to launch this activity).</p>
 
 <p>If you intend for your application to be self-contained and not allow other applications to
@@ -208,13 +208,13 @@
 other applications (and your own), then you must define additional intent filters for your
 activity. For each type of intent to which you want to respond, you must include an <a
 href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a> that includes an
+<intent-filter>}</a> that includes an
 <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
-&lt;action&gt;}</a> element and, optionally, a <a
+<action>}</a> element and, optionally, a <a
 href="{@docRoot}guide/topics/manifest/category-element.html">{@code
-&lt;category&gt;}</a> element and/or a <a
+<category>}</a> element and/or a <a
 href="{@docRoot}guide/topics/manifest/data-element.html">{@code
-&lt;data&gt;}</a> element. These elements specify the type of intent to which your activity can
+<data>}</a> element. These elements specify the type of intent to which your activity can
 respond.</p>
 
 <p>For more information about how your activities can respond to intents, see the <a
diff --git a/docs/html/guide/components/aidl.jd b/docs/html/guide/components/aidl.jd
index 0be6e6f..e15e53f1 100644
--- a/docs/html/guide/components/aidl.jd
+++ b/docs/html/guide/components/aidl.jd
@@ -140,7 +140,7 @@
     <p>All elements in the {@link java.util.Map} must be one of the supported data types in this
 list or one of the other AIDL-generated interfaces or parcelables you've declared.  Generic maps,
 (such as those of the form
-{@code Map&lt;String,Integer&gt;} are not supported. The actual concrete class that the other side
+{@code Map<String,Integer>} are not supported. The actual concrete class that the other side
 receives is always a {@link java.util.HashMap}, although the method is generated to
 use the {@link java.util.Map} interface.</p>
   </li>
diff --git a/docs/html/guide/components/fragments.jd b/docs/html/guide/components/fragments.jd
index 0065397..3b7da87 100644
--- a/docs/html/guide/components/fragments.jd
+++ b/docs/html/guide/components/fragments.jd
@@ -68,7 +68,7 @@
 android.view.ViewGroup} inside the activity's view hierarchy and the fragment defines its own view
 layout.
 You can insert a fragment into your activity layout by declaring the fragment in the activity's
-layout file, as a {@code &lt;fragment&gt;} element, or from your application code by adding it to an
+layout file, as a {@code <fragment>} element, or from your application code by adding it to an
 existing {@link android.view.ViewGroup}. However, a fragment is not required to be a part of the
 activity layout; you may also use a fragment without its own UI as an invisible worker for the
 activity.</p>
@@ -290,13 +290,13 @@
             android:layout_height="match_parent" /&gt;
 &lt;/LinearLayout&gt;
 </pre>
-  <p>The {@code android:name} attribute in the {@code &lt;fragment&gt;} specifies the {@link
+  <p>The {@code android:name} attribute in the {@code <fragment>} specifies the {@link
 android.app.Fragment} class to instantiate in the layout.</p>
 
 <p>When the system creates this activity layout, it instantiates each fragment specified in the
 layout and calls the {@link android.app.Fragment#onCreateView onCreateView()} method for each one,
 to retrieve each fragment's layout. The system inserts the {@link android.view.View} returned by the
-fragment directly in place of the {@code &lt;fragment&gt;} element.</p>
+fragment directly in place of the {@code <fragment>} element.</p>
 
 <div class="note">
   <p><strong>Note:</strong> Each fragment requires a unique identifier that
diff --git a/docs/html/guide/components/fundamentals.jd b/docs/html/guide/components/fundamentals.jd
index fd1a7a8..1d45106 100644
--- a/docs/html/guide/components/fundamentals.jd
+++ b/docs/html/guide/components/fundamentals.jd
@@ -348,7 +348,7 @@
 intent filters that declare the capabilities of the activity so it can respond to intents
 from other apps. You can declare an intent filter for your component by
 adding an <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a> element as a child of the component's declaration element.</p>
+<intent-filter>}</a> element as a child of the component's declaration element.</p>
 
 <p>For example, if you've built an email app with an activity for composing a new email, you can
 declare an intent filter to respond to "send" intents (in order to send a new email) like this:</p>
diff --git a/docs/html/guide/components/intents-common.jd b/docs/html/guide/components/intents-common.jd
index 8aa5fa9..078ff53 100644
--- a/docs/html/guide/components/intents-common.jd
+++ b/docs/html/guide/components/intents-common.jd
@@ -881,7 +881,7 @@
 <dd>{@link android.content.Intent#ACTION_VIEW}</dd>
 
 <dt><b>Data URI Scheme</b></dt>
-<dd>{@code content:&lt;URI>}</dd>
+<dd>{@code content:<URI>}</dd>
 
 <dt><b>MIME Type</b></dt>
 <dd>None. The type is inferred from contact URI.
@@ -922,7 +922,7 @@
 <dd>{@link android.content.Intent#ACTION_EDIT}</dd>
 
 <dt><b>Data URI Scheme</b></dt>
-<dd>{@code content:&lt;URI>}</dd>
+<dd>{@code content:<URI>}</dd>
 
 <dt><b>MIME Type</b></dt>
 <dd>The type is inferred from contact URI.
@@ -1497,9 +1497,9 @@
 <dt><b>Data URI Scheme</b></dt>
 <dd>
   <dl>
-    <dt>{@code file:<em>&lt;URI></em>}
-    <dt>{@code content:<em>&lt;URI></em>}
-    <dt>{@code http:<em>&lt;URL></em>}
+    <dt><code>file:<em>&lt;URI&gt;</em></code>
+    <dt><code>content:<em>&lt;URI&gt;</em></code>
+    <dt><code>http:<em>&lt;URL&gt;</em></code>
   </dl>
 </dd>
 
@@ -1830,8 +1830,8 @@
 <dt><b>Data URI Scheme</b></dt>
 <dd>
 <ul>
-  <li>{@code tel:&lt;phone-number>}</li>
-  <li>{@code voicemail:&lt;phone-number>}</li>
+  <li>{@code tel:<phone-number>}</li>
+  <li>{@code voicemail:<phone-number>}</li>
 </ul>
 </dd>
 
@@ -2042,10 +2042,10 @@
 <dt><b>Data URI Scheme</b></dt>
 <dd>
   <dl>
-    <dt>{@code sms:<em>&lt;phone_number></em>}
-    <dt>{@code smsto:<em>&lt;phone_number></em>}
-    <dt>{@code mms:<em>&lt;phone_number></em>}
-    <dt>{@code mmsto:<em>&lt;phone_number></em>}
+    <dt><code>sms:<em>&lt;phone_number&gt;</em></code>
+    <dt><code>smsto:<em>&lt;phone_number&gt;</em></code>
+    <dt><code>mms:<em>&lt;phone_number&gt;</em></code>
+    <dt><code>mmsto:<em>&lt;phone_number&gt;</em></code>
   </dl>
   <p>Each of these schemes are handled the same.
 </dd>
@@ -2158,8 +2158,8 @@
   <dd>{@link android.content.Intent#ACTION_VIEW}<dd>
 
   <dt><b>Data URI Scheme</b></dt>
-  <dd>{@code http:<em>&lt;URL></em>}<br/>
-    {@code https:<em>&lt;URL></em>}</dd>
+  <dd><code>http:<em>&lt;URL&gt;</em></code><br/>
+    <code>https:<em>&lt;URL&gt;</em></code></dd>
 
   <dt><b>MIME Type</b></dt>
   <dd>
diff --git a/docs/html/guide/components/intents-filters.jd b/docs/html/guide/components/intents-filters.jd
index 0759088..abc67f2 100644
--- a/docs/html/guide/components/intents-filters.jd
+++ b/docs/html/guide/components/intents-filters.jd
@@ -455,7 +455,7 @@
 
 <p>To advertise which implicit intents your app can receive, declare one or more intent filters for
 each of your app components with an <a href=
-"{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a>
+"{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>
 element in your <a href="{@docRoot}guide/topics/manifest/manifest-intro.html">manifest file</a>.
 Each intent filter specifies the type of intents it accepts based on the intent's action,
 data, and category. The system will deliver an implicit intent to your app component only if the
@@ -471,23 +471,23 @@
 in the {@link android.content.Intent} (such as to show the editor controls or not).</p>
 
 <p>Each intent filter is defined by an <a
-href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter>}</a>
+href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>
 element in the app's manifest file, nested in the corresponding app component (such
-as an <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a>
+as an <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
 element). Inside the <a
-href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter>}</a>,
+href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>,
 you can specify the type of intents to accept using one or more
 of these three elements:</p>
 
 <dl>
-<dt><a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action>}</a></dt>
+<dt><a href="{@docRoot}guide/topics/manifest/action-element.html">{@code <action>}</a></dt>
   <dd>Declares the intent action accepted, in the {@code name} attribute. The value
   must be the literal string value of an action, not the class constant.</dd>
-<dt><a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a></dt>
+<dt><a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a></dt>
   <dd>Declares the type of data accepted, using one or more attributes that specify various
   aspects of the data URI (<code>scheme</code>, <code>host</code>, <code>port</code>,
   <code>path</code>, etc.) and MIME type.</dd>
-<dt><a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category>}</a></dt>
+<dt><a href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a></dt>
   <dd>Declares the intent category accepted, in the {@code name} attribute. The value
   must be the literal string value of an action, not the class constant.
 
@@ -516,9 +516,9 @@
 </pre>
 
 <p>It's okay to create a filter that includes more than one instance of
-<a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action>}</a>,
-<a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a>, or
-<a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category>}</a>.
+<a href="{@docRoot}guide/topics/manifest/action-element.html">{@code <action>}</a>,
+<a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a>, or
+<a href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a>.
 If you do, you simply need to be certain that the component can handle any and all combinations
 of those filter elements.</p>
 
@@ -607,9 +607,9 @@
   indicates this is the main entry point and does not expect any intent data.</li>
   <li>The {@link android.content.Intent#CATEGORY_LAUNCHER} category indicates that this activity's
   icon should be placed in the system's app launcher. If the <a
-  href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a> element
+  href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element
   does not specify an icon with {@code icon}, then the system uses the icon from the <a
-  href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application>}</a>
+  href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
   element.</li>
 </ul>
 <p>These two must be paired together in order for the activity to appear in the app launcher.</p>
@@ -715,7 +715,7 @@
 
 <p>To specify accepted intent actions, an intent filter can declare zero or more
 <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
-&lt;action&gt;}</a> elements.  For example:</p>
+<action>}</a> elements.  For example:</p>
 
 <pre>
 &lt;intent-filter&gt;
@@ -739,7 +739,7 @@
 
 <p>To specify accepted intent categories, an intent filter can declare zero or more
 <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
-&lt;category&gt;}</a> elements.  For example:</p>
+<category>}</a> elements.  For example:</p>
 
 <pre>
 &lt;intent-filter&gt;
@@ -762,7 +762,7 @@
 android.app.Activity#startActivityForResult startActivityForResult()}.
 So if you want your activity to receive implicit intents, it must
 include a category for {@code "android.intent.category.DEFAULT"} in its intent filters (as
-shown in the previous {@code &lt;intent-filter>} example.</p>
+shown in the previous {@code <intent-filter>} example.</p>
 
 
 
@@ -770,7 +770,7 @@
 
 <p>To specify accepted intent data, an intent filter can declare zero or more
 <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
-&lt;data&gt;}</a> elements.  For example:</p>
+<data>}</a> elements.  For example:</p>
 
 <pre>
 &lt;intent-filter&gt;
@@ -786,7 +786,7 @@
 and {@code path} &mdash; for each part of the URI:
 </p>
 
-<p style="margin-left: 2em">{@code &lt;scheme>://&lt;host>:&lt;port>/&lt;path>}</p>
+<p style="margin-left: 2em">{@code <scheme>://<host>:<port>/<path>}</p>
 
 <p>
 For example:
@@ -799,7 +799,7 @@
 </p>
 
 <p>Each of these attributes is optional in a <a
-href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a> element,
+href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a> element,
 but there are linear dependencies:</p>
 <ul>
   <li>If a scheme is not specified, the host is ignored.</li>
@@ -851,7 +851,7 @@
 Therefore, their filters can list just a data type and do not need to explicitly
 name the {@code content:} and {@code file:} schemes.
 This is a typical case.  A <a
-href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a> element
+href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a> element
 like the following, for example, tells Android that the component can get image data from a content
 provider and display it:
 </p>
@@ -870,7 +870,7 @@
 <p>
 Another common configuration is filters with a scheme and a data type.  For
 example, a <a
-href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a>
+href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a>
 element like the following tells Android that
 the component can retrieve video data from the network in order to perform the action:
 </p>
diff --git a/docs/html/guide/components/processes-and-threads.jd b/docs/html/guide/components/processes-and-threads.jd
index 10a6410..7bb3c65 100644
--- a/docs/html/guide/components/processes-and-threads.jd
+++ b/docs/html/guide/components/processes-and-threads.jd
@@ -45,10 +45,10 @@
 
 <p>The manifest entry for each type of component element&mdash;<a
 href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity&gt;}</a>, <a href="{@docRoot}guide/topics/manifest/service-element.html">{@code
-&lt;service&gt;}</a>, <a href="{@docRoot}guide/topics/manifest/receiver-element.html">{@code
-&lt;receiver&gt;}</a>, and <a href="{@docRoot}guide/topics/manifest/provider-element.html">{@code
-&lt;provider&gt;}</a>&mdash;supports an {@code android:process} attribute that can specify a
+<activity>}</a>, <a href="{@docRoot}guide/topics/manifest/service-element.html">{@code
+<service>}</a>, <a href="{@docRoot}guide/topics/manifest/receiver-element.html">{@code
+<receiver>}</a>, and <a href="{@docRoot}guide/topics/manifest/provider-element.html">{@code
+<provider>}</a>&mdash;supports an {@code android:process} attribute that can specify a
 process in which that component should run. You can set this attribute so that each component runs
 in its own process or so that some components share a process while others do not.  You can also set
 {@code android:process} so that components of different applications run in the same
@@ -56,7 +56,7 @@
 same certificates.</p>
 
 <p>The <a href="{@docRoot}guide/topics/manifest/application-element.html">{@code
-&lt;application&gt;}</a> element also supports an {@code android:process} attribute, to set a
+<application>}</a> element also supports an {@code android:process} attribute, to set a
 default value that applies to all components.</p>
 
 <p>Android might decide to shut down a process at some point, when memory is low and required by
diff --git a/docs/html/guide/components/services.jd b/docs/html/guide/components/services.jd
index b8c105d..8da1694 100644
--- a/docs/html/guide/components/services.jd
+++ b/docs/html/guide/components/services.jd
@@ -189,9 +189,9 @@
 manifest file.</p>
 
 <p>To declare your service, add a <a
-href="{@docRoot}guide/topics/manifest/service-element.html">{@code &lt;service&gt;}</a> element
+href="{@docRoot}guide/topics/manifest/service-element.html">{@code <service>}</a> element
 as a child of the <a
-href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 element. For example:</p>
 
 <pre>
@@ -205,11 +205,11 @@
 </pre>
 
 <p>See the <a
-href="{@docRoot}guide/topics/manifest/service-element.html">{@code &lt;service&gt;}</a> element
+href="{@docRoot}guide/topics/manifest/service-element.html">{@code <service>}</a> element
 reference for more information about declaring your service in the manifest.</p>
 
 <p>There are other attributes you can include in the <a
-href="{@docRoot}guide/topics/manifest/service-element.html">{@code &lt;service&gt;}</a> element to
+href="{@docRoot}guide/topics/manifest/service-element.html">{@code <service>}</a> element to
 define properties such as permissions required to start the service and the process in
 which the service should run. The <a
 href="{@docRoot}guide/topics/manifest/service-element.html#nm">{@code android:name}</a>
diff --git a/docs/html/guide/components/tasks-and-back-stack.jd b/docs/html/guide/components/tasks-and-back-stack.jd
index aaef10e..c77b545 100644
--- a/docs/html/guide/components/tasks-and-back-stack.jd
+++ b/docs/html/guide/components/tasks-and-back-stack.jd
@@ -30,7 +30,7 @@
   <li><a href="{@docRoot}design/patterns/navigation.html">Android Design:
 Navigation</a></li>
   <li><a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;} manifest
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>} manifest
 element</a></li>
   <li><a href="{@docRoot}guide/components/recents.html">Overview Screen</a></li>
 </ol>
@@ -221,12 +221,12 @@
 activities except for the root activity when the user leaves the task.</p>
 
 <p>You can do these things and more, with attributes in the
-<a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
+<a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
 manifest element and with flags in the intent that you pass to
 {@link android.app.Activity#startActivity startActivity()}.</p>
 
 <p>In this regard, the principal <a href="{@docRoot}guide/topics/manifest/activity-element.html">
-{@code &lt;activity&gt;}</a> attributes you can use are:</p>
+{@code <activity>}</a> attributes you can use are:</p>
 
 <ul class="nolist">
   <li><a href="{@docRoot}guide/topics/manifest/activity-element.html#aff">
@@ -295,7 +295,7 @@
 
 <p>When declaring an activity in your manifest file, you can specify how the activity should
 associate with a task using the <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
 element's <a href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">{@code
 launchMode}</a> attribute.</p>
 
@@ -351,7 +351,7 @@
 
 <p>As another example, the Android Browser application declares that the web browser activity should
 always open in its own task&mdash;by specifying the {@code singleTask} launch mode in the <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> element.
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element.
 This means that if your application issues an
 intent to open the Android Browser, its activity is <em>not</em> placed in the same
 task as your application. Instead, either a new task starts for the Browser or, if the Browser
@@ -440,14 +440,14 @@
 
 <p>You can modify the affinity for any given activity with the <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#aff">{@code taskAffinity}</a> attribute
-of the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
+of the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
 element.</p>
 
 <p>The <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#aff">{@code taskAffinity}</a>
 attribute takes a string value, which must be unique from the default package name
 declared in the <a href="{@docRoot}guide/topics/manifest/manifest-element.html">
-{@code &lt;manifest&gt;}
+{@code <manifest>}
 </a> element, because the system uses that name to identify the default task
 affinity for the application.</p>
 
diff --git a/docs/html/guide/practices/compatibility.jd b/docs/html/guide/practices/compatibility.jd
index db1642e..1bfc99d3 100644
--- a/docs/html/guide/practices/compatibility.jd
+++ b/docs/html/guide/practices/compatibility.jd
@@ -119,7 +119,7 @@
 
 <p>If necessary, you can prevent users from installing your app when their devices don't provide a
 given feature by declaring it with a <a href=
-"{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>
+"{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element in your app's <a href="{@docRoot}guide/topics/manifest/manifest-intro.html">manifest
 file</a>.</p>
 
@@ -169,7 +169,7 @@
 on this feature and make your app available to devices without Bluetooth by setting the <a href=
 "{@docRoot}guide/topics/manifest/uses-feature-element.html#required">{@code required}</a> attribute
 to {@code "false"} in the <a href=
-"{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a> tag.
+"{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> tag.
 For more information about implicitly required device features, read <a href=
 "{@docRoot}guide/topics/manifest/uses-feature-element.html#permissions">Permissions that Imply
 Feature Requirements</a>.</p>
@@ -191,7 +191,7 @@
 
 <p>The API level allows you to declare the minimum version with which your app is
 compatible, using the <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code
-&lt;uses-sdk>}</a> manifest tag and its <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">{@code minSdkVersion}</a> attribute.</p>
+<uses-sdk>}</a> manifest tag and its <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">{@code minSdkVersion}</a> attribute.</p>
 
 <p>For example, the <a href="{@docRoot}guide/topics/providers/calendar-provider.html">Calendar
 Provider</a> APIs were added in Android 4.0 (API level 14). If your app cannot function without
diff --git a/docs/html/guide/practices/optimizing-for-3.0.jd b/docs/html/guide/practices/optimizing-for-3.0.jd
index fea54af..4f3d0f2 100644
--- a/docs/html/guide/practices/optimizing-for-3.0.jd
+++ b/docs/html/guide/practices/optimizing-for-3.0.jd
@@ -188,7 +188,7 @@
   <li><b>Apply the new "holographic" theme to your application</b>
     <ol>
       <li>Open your manifest file and update the <a
-href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk&gt;}</a> element to
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a> element to
 set <a
 href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#target">{@code
 android:targetSdkVersion}</a> to {@code "11"}. For example:
@@ -383,9 +383,9 @@
 <p>Android 3.0 adds a hardware-accelerated OpenGL renderer that gives a performance boost to most 2D
 graphics operations. You can enable hardware-accelerated rendering in your application by setting
 {@code android:hardwareAccelerated="true"} in your manifest's <a
-href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 element or for individual <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity&gt;}</a> elements. Hardware acceleration results in smoother animations, smoother
+<activity>}</a> elements. Hardware acceleration results in smoother animations, smoother
 scrolling, and overall better performance and response to user interaction. When enabled, be sure
 that you thoroughly test your application on a device that supports hardware acceleration.</p>
 
@@ -500,7 +500,7 @@
 not fit a smaller screen or you've explicitly designed your application only for tablets and other
 large devices. In this case, you can manage the availability of your application to smaller screens
 by using the <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens>}</a> manifest element.</p>
+<supports-screens>}</a> manifest element.</p>
 
 <p>For example, if you want your application to be available only to extra large
 screens, you can declare the element in your manifest like this:</p>
@@ -523,7 +523,7 @@
 
 <p class="note"><strong>Note:</strong> If you use the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens>}</a> element for the reverse scenario (when your application is not compatible
+<supports-screens>}</a> element for the reverse scenario (when your application is not compatible
 with <em>larger</em> screens) and set the larger screen size attributes to {@code "false"}, then
 external services such as Google Play <strong>do not</strong> apply filtering. Your application
 will still be available to larger screens, but when it runs, it will not fill the screen&mdash;the
@@ -540,22 +540,22 @@
 that each deliver different features for different screen configurations, so you don't want
 larger devices to download the version designed for smaller screens. In such a case, you can
 use the <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens>}</a> element to manage the distribution of your application based on the
+<compatible-screens>}</a> element to manage the distribution of your application based on the
 combination of screen size and density. External services such as
 Google Play uses this information to apply filtering to your application, so that only devices
 that have a screen configuration with which you declare compatibility can download your
 application.</p>
 
 <p>The <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens>}</a> element must contain one or more {@code &lt;screen&gt;} elements,
+<compatible-screens>}</a> element must contain one or more {@code <screen>} elements,
 which each specify a screen configuration with which your application is compatible, using both
 the {@code android:screenSize} and {@code android:screenDensity} attributes. Each {@code
-&lt;screen&gt;} element <strong>must include both attributes</strong> to specify an individual
+<screen>} element <strong>must include both attributes</strong> to specify an individual
 screen configuration&mdash;if either attribute is missing, then the element is invalid
 (external services such as Google Play will ignore it).</p>
 
 <p>For example, if your application is compatible with only small and normal screens, regardless
-of screen density, then you must specify eight different {@code &lt;screen&gt;} elements,
+of screen density, then you must specify eight different {@code <screen>} elements,
 because each screen size has four density configurations. You must declare each one of
 these; any combination of size and density that you do <em>not</em> specify is considered a screen
 configuration with which your application is <em>not</em> compatible. Here's what the manifest
@@ -584,17 +584,17 @@
 
 <p class="note"><strong>Note:</strong> Although you can also use the <a
 href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens>}</a> element for the reverse scenario (when your application is not
+<compatible-screens>}</a> element for the reverse scenario (when your application is not
 compatible with smaller screens), it's easier if you instead use the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens>}</a> as discussed in the previous section, because it doesn't require you
+<supports-screens>}</a> as discussed in the previous section, because it doesn't require you
 to specify each screen density your application supports.</p>
 
 <p>Remember, you should strive to make your application available to as many devices as possible by
 applying all necessary techniques for <a
 href="{@docRoot}guide/practices/screens_support.html">supporting multiple screens</a>. You should
 then use the <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens>}</a> element to filter your application from certain devices only when you
+<compatible-screens>}</a> element to filter your application from certain devices only when you
 cannot offer compatibility on all screen configurations or you have decided to provide
 multiple versions of your application, each for a different set of screen configurations.</p>
 
@@ -650,7 +650,7 @@
 <p>In the worst-case scenario, however, you can avoid orientation changes by using the <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#screen">{@code
 android:screenOrientation}</a> attribute in the <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
 element. Instead of locking the orientation in landscape or portrait, however, you should
 specify a value of {@code "nosensor"}. This way, your activity uses whatever orientation the
 device specifies as its natural orientation and the screen will not rotate. You should still
@@ -676,7 +676,7 @@
 traditional phone calls or handle SMS. Some devices might also omit
 other hardware features, such as Bluetooth. If your application uses these features, then your
 manifest file probably already includes (or should include) a declaration of the feature with the <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element. Doing so prevents devices that do not declare support for the feature from downloading
 your applications. For example:</p>
 
diff --git a/docs/html/guide/practices/screen-compat-mode.jd b/docs/html/guide/practices/screen-compat-mode.jd
index e3160c39..34580ba 100644
--- a/docs/html/guide/practices/screen-compat-mode.jd
+++ b/docs/html/guide/practices/screen-compat-mode.jd
@@ -18,7 +18,7 @@
 <ol>
   <li><a href="{@docRoot}guide/practices/screens_support.html">Supporting Multiple Screens</a></li>
   <li><a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a></li>
+<supports-screens>}</a></li>
 </ol>
 </div>
 </div>
@@ -123,7 +123,7 @@
 android:targetSdkVersion}</a> to {@code "10"} or lower and <strong>does not explicitly
 declare support</strong> for large screens using the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element.</li>
+<supports-screens>}</a> element.</li>
 
   <li>Your application has set either <a
 href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">{@code android:minSdkVersion}</a>
@@ -131,7 +131,7 @@
 android:targetSdkVersion}</a> to {@code "11"} or higher and <strong>explicitly declares that it does
 not support</strong> large screens, using the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element.</li>
+<supports-screens>}</a> element.</li>
 </ul>
 
 <p>To completely disable the user option for screen compatibility mode and remove the icon in the
@@ -141,7 +141,7 @@
   <li><strong>Easiest:</strong>
     <p>In your manifest file, add the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element and specify the <a
+<supports-screens>}</a> element and specify the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html#xlarge">{@code
 android:xlargeScreens}</a> attribute to {@code "true"}:</p>
 <pre>
@@ -150,13 +150,13 @@
   <p>That's it. This declares that your application supports all larger screen sizes, so the
 system will always resize your layout to fit the screen. This works regardless of what values
 you've set in the <a
-href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk&gt;}</a>
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a>
 attributes.</p> 
   </li>
   
   <li><strong>Easy but has other effects:</strong>
     <p>In your manifest's <a
-href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk&gt;}</a>
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a>
 element, set <a
 href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#target">{@code
 android:targetSdkVersion}</a> to {@code "11"} or higher:</p>
@@ -171,10 +171,10 @@
 Options Menu button in the system bar.</p>
   <p>If screen compatibility mode is still enabled after you change this, check your manifest's <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> and be sure that there are no attributes set {@code "false"}. The best
+<supports-screens>}</a> and be sure that there are no attributes set {@code "false"}. The best
 practice is to always explicitly declare your support for different screen sizes using the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element, so you should use this element anyway.</p>
+<supports-screens>}</a> element, so you should use this element anyway.</p>
   <p>For more information about updating your application to target Android 3.0 devices, read <a
 href="{@docRoot}guide/practices/optimizing-for-3.0.html">Optimizing Apps for Android
 3.0</a>.</p>
@@ -183,7 +183,7 @@
   <li><strong>Most control</strong> (but you must compile against Android 3.2 or higher):
     <p>In your manifest file, add the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element and specify the {@code android:compatibleWidthLimitDp}
+<supports-screens>}</a> element and specify the {@code android:compatibleWidthLimitDp}
 attribute to any value <em>higher than</em> {@code "320"}:</p>
 <pre>
 &lt;supports-screens android:compatibleWidthLimitDp="720" /&gt;
@@ -206,7 +206,7 @@
 <p>When your application is targeting Android 3.2 (API level 13) or higher, you can affect
 whether compatibility mode is enabled for certain screens by using the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens>}</a> element.</p>
+<supports-screens>}</a> element.</p>
 
 <p class="note"><strong>Note:</strong> Screen compatibility mode is <strong>not</strong> a mode in
 which you should want your application to run&mdash;it causes pixelation and blurring in your UI,
@@ -227,7 +227,7 @@
 <ul>
   <li>In your manifest file, add the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element and specify the <a
+<supports-screens>}</a> element and specify the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html#compatibleWidth">{@code
 android:compatibleWidthLimitDp}</a> attribute to {@code "320"}:</p>
 <pre>
diff --git a/docs/html/guide/practices/screens-distribution.jd b/docs/html/guide/practices/screens-distribution.jd
index 99eb04e..92416e0 100644
--- a/docs/html/guide/practices/screens-distribution.jd
+++ b/docs/html/guide/practices/screens-distribution.jd
@@ -58,21 +58,21 @@
 might discover that your application can't scale up well or perhaps you've decided to publish two
 versions of your application for different screen configurations. In such a case, you can use the <a
 href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens>}</a> element to manage the distribution of your application based on
+<compatible-screens>}</a> element to manage the distribution of your application based on
 combinations of screen size and density. External services such as Google Play use this
 information to apply filtering to your application, so that only devices that have a screen
 configuration with which you declare compatibility can download your application.</p>
 
 <p>The <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens>}</a> element must contain one or more {@code &lt;screen&gt;} elements. Each
-{@code &lt;screen&gt;} element specifies a screen configuration with which your application is
+<compatible-screens>}</a> element must contain one or more {@code <screen>} elements. Each
+{@code <screen>} element specifies a screen configuration with which your application is
 compatible, using both the {@code android:screenSize} and {@code android:screenDensity} attributes.
-Each {@code &lt;screen&gt;} element <strong>must include both attributes</strong> to specify an
+Each {@code <screen>} element <strong>must include both attributes</strong> to specify an
 individual screen configuration&mdash;if either attribute is missing, then the element is invalid
 (external services such as Google Play will ignore it).</p>
 
 <p>For example, if your application is compatible with only small and normal size screens,
-regardless of screen density, you must specify eight different {@code &lt;screen&gt;} elements,
+regardless of screen density, you must specify eight different {@code <screen>} elements,
 because each screen size has four density configurations. You must declare each one of
 these; any combination of size and density that you do <em>not</em> specify is considered a screen
 configuration with which your application is <em>not</em> compatible. Here's what the manifest
@@ -101,10 +101,10 @@
 
 <p class="note"><strong>Note:</strong> Although you can also use the <a
 href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens>}</a> element for the reverse scenario (when your application is not
+<compatible-screens>}</a> element for the reverse scenario (when your application is not
 compatible with smaller screens), it's easier if you instead use the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens>}</a> as discussed in the next section, because it doesn't require you
+<supports-screens>}</a> as discussed in the next section, because it doesn't require you
 to specify each screen density your application supports.</p>
 
 
@@ -116,7 +116,7 @@
 large screen) or you need time to optimize it for smaller screens, you can prevent small-screen
 devices from downloading your app by using the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens>}</a> manifest element.</p>
+<supports-screens>}</a> manifest element.</p>
 
 <p>For example, if you want your application to be available only to tablet devices, you can declare
 the element in your manifest like this:</p>
@@ -172,7 +172,7 @@
 
 <p class="caution"><strong>Caution:</strong> If you use the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens>}</a> element for the reverse scenario (when your application is not compatible
+<supports-screens>}</a> element for the reverse scenario (when your application is not compatible
 with <em>larger</em> screens) and set the larger screen size attributes to {@code "false"}, then
 external services such as Google Play <strong>do not</strong> apply filtering. Your application
 will still be available to larger screens, but when it runs, it will not resize to fit the screen.
@@ -181,16 +181,16 @@
 information). If you want
 to prevent your application from being downloaded on larger screens, use <a
 href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens>}</a>, as discussed in the previous section about <a
+<compatible-screens>}</a>, as discussed in the previous section about <a
 href="#FilteringHandsetApps">Declaring an App is Only for Handsets</a>.</p>
 
 <p>Remember, you should strive to make your application available to as many devices as possible by
 applying all necessary techniques for <a
 href="{@docRoot}guide/practices/screens_support.html">supporting multiple screens</a>. You should
 use <a href="{@docRoot}guide/topics/manifest/compatible-screens-element.html">{@code
-&lt;compatible-screens>}</a> or <a
+<compatible-screens>}</a> or <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens>}</a> only when you cannot provide compatibility on all screen configurations
+<supports-screens>}</a> only when you cannot provide compatibility on all screen configurations
 or you have decided to provide different versions of your application for different sets of screen
 configurations.</p>
 
diff --git a/docs/html/guide/practices/screens-support-1.5.jd b/docs/html/guide/practices/screens-support-1.5.jd
index ad680d9..1676674 100644
--- a/docs/html/guide/practices/screens-support-1.5.jd
+++ b/docs/html/guide/practices/screens-support-1.5.jd
@@ -38,7 +38,7 @@
 screens, using alternative resources for different screen configurations.</p>
 
 <p>If your manifest file includes the <a
-href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk&gt;}</a> element,
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a> element,
 with the <a
 href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">{@code android:minSdkVersion}</a>
 attribute set to {@code "3"} or lower, and does <em>not</em> include the <a
@@ -87,7 +87,7 @@
   <li>Extend compatibility for Android 1.6 (and higher) devices by adding <a
 href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#target">{@code
 android:targetSdkVersion}</a> to the <a
-href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk&gt;}</a> element.
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a> element.
 Set the value of <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#target">{@code
 android:targetSdkVersion}</a> to <code>"4"</code>. This allows your application to "inherit" the
 platform's multiple screens support, even though it is technically using an earlier version of the
diff --git a/docs/html/guide/practices/screens_support.jd b/docs/html/guide/practices/screens_support.jd
index b6f1c49..1335790 100644
--- a/docs/html/guide/practices/screens_support.jd
+++ b/docs/html/guide/practices/screens_support.jd
@@ -315,7 +315,7 @@
 href="{@docRoot}guide/practices/screen-compat-mode.html">screen compatibility mode</a>.</p>
     <p>To declare the screen sizes your application supports, you should include the
 <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element in your manifest file.</p>
+<supports-screens>}</a> element in your manifest file.</p>
   </li>
 
   <li><strong>Provide different layouts for different screen sizes</strong>
@@ -328,7 +328,7 @@
 <code>small</code>, <code>normal</code>, <code>large</code>, and <code>xlarge</code>. For
 example, layouts for an extra-large screen should go in {@code layout-xlarge/}.</p>
     <p>Beginning with Android 3.2 (API level 13), the above size groups are deprecated and you
-should instead use the {@code sw&lt;N&gt;dp} configuration qualifier to define the smallest
+should instead use the {@code sw<N>dp} configuration qualifier to define the smallest
 available width required by your layout resources. For example, if your multi-pane tablet layout
 requires at least 600dp of screen width, you should place it in {@code layout-sw600dp/}. Using the
 new techniques for declaring layout resources is discussed further in the section about <a
@@ -429,15 +429,15 @@
 <p>To use a configuration qualifier:</p>
 <ol>
   <li>Create a new directory in your project's {@code res/} directory and name it using the
-format: <nobr>{@code &lt;resources_name&gt;-&lt;qualifier&gt;}</nobr>
+format: <nobr>{@code <resources_name>-<qualifier>}</nobr>
     <ul>
-      <li>{@code &lt;resources_name&gt;} is the standard resource name (such as {@code drawable} or
+      <li>{@code <resources_name>} is the standard resource name (such as {@code drawable} or
 {@code layout}).</li>
-      <li>{@code &lt;qualifier&gt;} is a configuration qualifier from table 1, below, specifying the
+      <li>{@code <qualifier>} is a configuration qualifier from table 1, below, specifying the
 screen configuration for which these resources are to be used (such as {@code hdpi} or {@code
 xlarge}).</li>
     </ul>
-    <p>You can use more than one {@code &lt;qualifier&gt;} at a time&mdash;simply separate each
+    <p>You can use more than one {@code <qualifier>} at a time&mdash;simply separate each
 qualifier with a dash.</p>
   </li>
   <li>Save the appropriate configuration-specific resources in this new directory. The resource
@@ -759,7 +759,7 @@
 screen area. Specifically, the device's smallestWidth is the shortest of the screen's available
 height and width (you may also think of it as the "smallest possible width" for the screen). You can
 use this qualifier to ensure that, regardless of the screen's current orientation, your
-application's has at least {@code &lt;N&gt;} dps of width available for its UI.</p>
+application's has at least {@code <N>} dps of width available for its UI.</p>
         <p>For example, if your layout requires that its smallest dimension of screen area be at
 least 600 dp at all times, then you can use this qualifier to create the layout resources, {@code
 res/layout-sw600dp/}. The system will use these resources only when the smallest dimension of
@@ -868,8 +868,8 @@
 </pre>
 
 <p>Notice that the previous two sets of example resources use the "smallest width" qualifier, {@code
-sw&lt;N&gt;dp}, which specifies the smallest of the screen's two sides, regardless of the
-device's current orientation. Thus, using {@code sw&lt;N&gt;dp} is a simple way to specify the
+sw<N>dp}, which specifies the smallest of the screen's two sides, regardless of the
+device's current orientation. Thus, using {@code sw<N>dp} is a simple way to specify the
 overall screen size available for your layout by ignoring the screen's orientation.</p>
 
 <p>However, in some cases, what might be
@@ -883,13 +883,13 @@
 res/layout-w600dp/main_activity.xml  # Multi-pane (any screen with 600dp available width or more)
 </pre>
 
-<p>Notice that the second set is using the "available width" qualifier, {@code w&lt;N&gt;dp}. This
+<p>Notice that the second set is using the "available width" qualifier, {@code w<N>dp}. This
 way, one device may actually use both layouts, depending on the orientation of the screen (if
 the available width is at least 600dp in one orientation and less than 600dp in the other
 orientation).</p>
 
 <p>If the available height is a concern for you, then you can do the same using the {@code
-h&lt;N&gt;dp} qualifier. Or, even combine the {@code w&lt;N&gt;dp} and {@code h&lt;N&gt;dp}
+h<N>dp} qualifier. Or, even combine the {@code w<N>dp} and {@code h<N>dp}
 qualifiers if you need to be really specific.</p>
 
 
@@ -1287,7 +1287,7 @@
 
 <p>To launch the Android SDK Manager, execute the {@code
 SDK Manager.exe} from your Android SDK directory (on Windows only) or execute {@code android} from
-the {@code &lt;sdk&gt;/tools/} directory (on all platforms). Figure 6 shows the AVD
+the {@code <sdk>/tools/} directory (on all platforms). Figure 6 shows the AVD
 Manager with a selection of AVDs, for testing various screen configurations.</p>
 
 <p>Table 3 shows the various emulator skins that are available in the Android SDK, which you can use
diff --git a/docs/html/guide/practices/tablets-and-handsets.jd b/docs/html/guide/practices/tablets-and-handsets.jd
index a63a368..85327b6 100644
--- a/docs/html/guide/practices/tablets-and-handsets.jd
+++ b/docs/html/guide/practices/tablets-and-handsets.jd
@@ -424,8 +424,8 @@
 at the top.</p>
 
 <p>To enable split action bar, simply add {@code uiOptions="splitActionBarWhenNarrow"} to your
-<a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> or
-<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+<a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> or
+<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 manifest element.</p>
 
 
diff --git a/docs/html/guide/topics/connectivity/bluetooth-le.jd b/docs/html/guide/topics/connectivity/bluetooth-le.jd
index 5c32e56..3d60686 100644
--- a/docs/html/guide/topics/connectivity/bluetooth-le.jd
+++ b/docs/html/guide/topics/connectivity/bluetooth-le.jd
@@ -186,7 +186,7 @@
 
 <p>Before your application can communicate over BLE, you need
 to verify that BLE is supported on the device, and if so, ensure that it is enabled.
-Note that this check is only necessary if {@code &lt;uses-feature.../&gt;}
+Note that this check is only necessary if {@code <uses-feature.../>}
 is set to false.</p>
 
 <p>If BLE is not supported, then you should gracefully disable any
diff --git a/docs/html/guide/topics/connectivity/nfc/hce.jd b/docs/html/guide/topics/connectivity/nfc/hce.jd
index 9ec1a8d..900d8ac 100644
--- a/docs/html/guide/topics/connectivity/nfc/hce.jd
+++ b/docs/html/guide/topics/connectivity/nfc/hce.jd
@@ -184,7 +184,7 @@
 
 <p>Your application can check whether a device supports HCE by checking for the
 {@link android.content.pm.PackageManager#FEATURE_NFC_HOST_CARD_EMULATION} feature. You should use the
-<a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a> tag in the manifest of your application to declare that your app
+<a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> tag in the manifest of your application to declare that your app
 uses the HCE feature, and whether it is required for the app to function or not.</p>
 
 <h3 id="ServiceImplementation">Service implementation</h3>
diff --git a/docs/html/guide/topics/data/backup.jd b/docs/html/guide/topics/data/backup.jd
index 5710a47..9554835 100644
--- a/docs/html/guide/topics/data/backup.jd
+++ b/docs/html/guide/topics/data/backup.jd
@@ -160,7 +160,7 @@
 href="{@docRoot}guide/topics/manifest/application-element.html#agent">{@code
 android:backupAgent}</a> attribute in the <a
 href="{@docRoot}guide/topics/manifest/application-element.html">{@code
-&lt;application&gt;}</a> tag.</p>
+<application>}</a> tag.</p>
 
 <p>For example:</p>
 
@@ -205,8 +205,8 @@
 <p>To get your Backup Service Key, <a
 href="http://code.google.com/android/backup/signup.html">register for Android Backup Service</a>.
 When you register, you will be provided a Backup Service Key and the appropriate {@code
-&lt;meta-data&gt;} XML code for your Android manifest file, which you must include as a child of the
-{@code &lt;application&gt;} element. For example:</p>
+<meta-data>} XML code for your Android manifest file, which you must include as a child of the
+{@code <application>} element. For example:</p>
 
 <pre>
 &lt;application android:label="MyApplication"
@@ -231,7 +231,7 @@
 your application to know what transport is used on the device. However, if you implement backup for
 your application, you should always include a Backup Service Key for Android Backup Service so
 your application can perform backup when the device uses the Android Backup Service transport. If
-the device does not use Android Backup Service, then the {@code &lt;meta-data&gt;} element with the
+the device does not use Android Backup Service, then the {@code <meta-data>} element with the
 Backup Service Key is ignored.</p>
 
 
diff --git a/docs/html/guide/topics/data/data-storage.jd b/docs/html/guide/topics/data/data-storage.jd
index 24e7f54..46db371 100644
--- a/docs/html/guide/topics/data/data-storage.jd
+++ b/docs/html/guide/topics/data/data-storage.jd
@@ -190,8 +190,8 @@
 
 <p class="note"><strong>Tip:</strong> If you want to save a static file in your application at
 compile time, save the file in your project <code>res/raw/</code> directory. You can open it with
-{@link android.content.res.Resources#openRawResource(int) openRawResource()}, passing the {@code
-R.raw.<em>&lt;filename&gt;</em>} resource ID. This method returns an {@link java.io.InputStream}
+{@link android.content.res.Resources#openRawResource(int) openRawResource()}, passing the
+<code>R.raw.<em>&lt;filename&gt;</em></code> resource ID. This method returns an {@link java.io.InputStream}
 that you can use to read the file (but you cannot write to the original file).
 </p>
 
diff --git a/docs/html/guide/topics/graphics/opengl.jd b/docs/html/guide/topics/graphics/opengl.jd
index 3e3d569..80b3c2b 100644
--- a/docs/html/guide/topics/graphics/opengl.jd
+++ b/docs/html/guide/topics/graphics/opengl.jd
@@ -242,7 +242,7 @@
   <li><strong>Texture compression requirements</strong> - If your application uses texture
 compression formats, you must declare the formats your application supports in your manifest file
 using <a href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html">{@code
-&lt;supports-gl-texture&gt;}</a>. For more information about available texture compression
+<supports-gl-texture>}</a>. For more information about available texture compression
 formats, see <a href="#textures">Texture compression support</a>.
 
 <p>Declaring texture compression requirements in your manifest hides your application from users
@@ -250,7 +250,7 @@
 information on how Google Play filtering works for texture compressions, see the <a
 href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html#market-texture-filtering">
 Google Play and texture compression filtering</a> section of the {@code
-&lt;supports-gl-texture&gt;} documentation.</p>
+<supports-gl-texture>} documentation.</p>
   </li>
 </ul>
 
@@ -503,9 +503,9 @@
 reducing memory requirements and making more efficient use of memory bandwidth. The Android
 framework provides support for the ETC1 compression format as a standard feature, including a {@link
 android.opengl.ETC1Util} utility class and the {@code etc1tool} compression tool (located in the
-Android SDK at {@code &lt;sdk&gt;/tools/}). For an example of an Android application that uses
+Android SDK at {@code <sdk>/tools/}). For an example of an Android application that uses
 texture compression, see the {@code CompressedTextureActivity} code sample in Android SDK
-({@code &lt;sdk&gt;/samples/&lt;version&gt;/ApiDemos/src/com/example/android/apis/graphics/}).</p>
+({@code <sdk>/samples/<version>/ApiDemos/src/com/example/android/apis/graphics/}).</p>
 
 <p class="caution"><strong>Caution:</strong> The ETC1 format is supported by most Android devices,
 but it not guaranteed to be available. To check if the ETC1 format is supported on a device, call
diff --git a/docs/html/guide/topics/manifest/action-element.jd b/docs/html/guide/topics/manifest/action-element.jd
index 54ee6ae..fc6ce44 100644
--- a/docs/html/guide/topics/manifest/action-element.jd
+++ b/docs/html/guide/topics/manifest/action-element.jd
@@ -14,7 +14,7 @@
 <dt>description:</dt>
 <dd itemprop="description">Adds an action to an intent filter.
 An <code><a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">&lt;intent-filter&gt;</a></code> element must contain 
-one or more {@code &lt;action&gt;} elements.  If it doesn't contain any, no
+one or more {@code <action>} elements.  If it doesn't contain any, no
 Intent objects will get through the filter.  See 
 <a href="{@docRoot}guide/components/intents-filters.html">Intents and 
 Intent Filters</a> for details on intent filters and the role of action
@@ -26,9 +26,9 @@
 <dt><a name="nm"></a>{@code android:name}</dt>
 <dd>The name of the action.  Some standard actions are defined in the
 {@link android.content.Intent#ACTION_CHOOSER Intent} class as 
-{@code ACTION_<i>string</i>} constants.  To assign one of these actions to 
+<code>ACTION_<i>string</i></code> constants.  To assign one of these actions to
 this attribute, prepend "{@code android.intent.action.}" to the 
-{@code <i>string</i>} that follows {@code ACTION_}.
+<code><i>string</i></code> that follows {@code ACTION_}.
 For example, for {@code ACTION_MAIN}, use "{@code android.intent.action.MAIN}"
 and for {@code ACTION_WEB_SEARCH}, use "{@code android.intent.action.WEB_SEARCH}".
 
diff --git a/docs/html/guide/topics/manifest/activity-alias-element.jd b/docs/html/guide/topics/manifest/activity-alias-element.jd
index 343b02e..1427b55 100644
--- a/docs/html/guide/topics/manifest/activity-alias-element.jd
+++ b/docs/html/guide/topics/manifest/activity-alias-element.jd
@@ -42,7 +42,7 @@
 </p>
 
 <p>
-With the exception of {@code targetActivity}, {@code &lt;activity-alias&gt;} 
+With the exception of {@code targetActivity}, {@code <activity-alias>}
 attributes are a subset of <code><a href="{@docRoot}guide/topics/manifest/activity-element.html">&lt;activity&gt;</a></code> attributes.  
 For attributes in the subset, none of the values set for the target carry over
 to the alias.  However, for attributes not in the subset, the values set for 
@@ -60,7 +60,7 @@
 The <code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code> element has its own 
 <code><a href="{@docRoot}guide/topics/manifest/application-element.html#enabled">enabled</a></code> attribute that applies to all 
 application components, including activity aliases.  The 
-<code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code> and {@code &lt;activity-alias&gt;} 
+<code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code> and {@code <activity-alias>}
 attributes must both be "{@code true}" for the system to be able to instantiate 
 the target activity through the alias.  If either is "{@code false}", the alias 
 does not work.
diff --git a/docs/html/guide/topics/manifest/activity-element.jd b/docs/html/guide/topics/manifest/activity-element.jd
index 99e64d9..fd1729c 100644
--- a/docs/html/guide/topics/manifest/activity-element.jd
+++ b/docs/html/guide/topics/manifest/activity-element.jd
@@ -64,7 +64,7 @@
 <dt>description:</dt>
 <dd itemprop="description">Declares an activity (an {@link android.app.Activity} subclass) that
 implements part of the application's visual user interface.  All activities
-must be represented by {@code &lt;activity&gt;}
+must be represented by {@code <activity>}
 elements in the manifest file.  Any that are not declared there will not be seen
 by the system and will never be run.
 
@@ -158,7 +158,7 @@
 <dt><a name="banner"></a>{@code android:banner}</dt>
 <dd>A <a href="{@docRoot}guide/topics/resources/drawable-resource.html">drawable resource</a>
 providing an extended graphical banner for its associated item. Use with the
-{@code &lt;activity&gt;} tag to supply a default banner for a specific activity, or with the
+{@code <activity>} tag to supply a default banner for a specific activity, or with the
 <a href="{@docRoot}guide/topics/manifest/application-element.html"><code>&lt;application&gt;</code></a>
 tag to supply a banner for all application activities.
 
@@ -168,7 +168,7 @@
 {@link android.content.Intent#CATEGORY_LEANBACK_LAUNCHER} intent.</p>
 
 <p>This attribute must be set as a reference to a drawable resource containing
-the image (for example {@code "&#64;drawable/banner"}). There is no default banner.
+the image (for example {@code "@drawable/banner"}). There is no default banner.
 </p>
 
 <p>
@@ -373,7 +373,7 @@
 <a href="{@docRoot}guide/topics/manifest/application-element.html#enabled">enabled</a></code>
 attribute that applies to all application components, including activities.  The
 <code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code>
-and {@code &lt;activity&gt;} attributes must both be "{@code true}" (as they both
+and {@code <activity>} attributes must both be "{@code true}" (as they both
 are by default) for the system to be able to instantiate the activity.  If either
 is "{@code false}", it cannot be instantiated.
 </p></dd>
@@ -700,7 +700,7 @@
 <!-- api level 16 -->
 <dt><a name="parent"></a>{@code android:parentActivityName}</dt>
 <dd>The class name of the logical parent of the activity. The name here must match the class
-  name given to the corresponding {@code &lt;activity>} element's
+  name given to the corresponding {@code <activity>} element's
   <a href="#nm"><code>android:name</code></a> attribute.
 
 <p>The system reads this attribute to determine which activity should be started when
@@ -708,7 +708,7 @@
   synthesize a back stack of activities with {@link android.app.TaskStackBuilder}.</p>
 
 <p>To support API levels 4 - 16, you can also declare the parent activity with a {@code
-&lt;meta-data>} element that specifies a value for {@code "android.support.PARENT_ACTIVITY"}.
+<meta-data>} element that specifies a value for {@code "android.support.PARENT_ACTIVITY"}.
 For example:</p>
 <pre>
 &lt;activity
@@ -888,7 +888,7 @@
 {@code "sensorLandscape"}, then your application will be available only to devices that support
 landscape orientation. However, you should also explicitly declare that
 your application requires either portrait or landscape orientation with the <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element. For example, <code>&lt;uses-feature
 android:name="android.hardware.screen.portrait"/></code>. This is purely a filtering behavior
 provided by Google Play (and other services that support it) and the platform itself does not
diff --git a/docs/html/guide/topics/manifest/application-element.jd b/docs/html/guide/topics/manifest/application-element.jd
index e63ba71..5600b5c 100644
--- a/docs/html/guide/topics/manifest/application-element.jd
+++ b/docs/html/guide/topics/manifest/application-element.jd
@@ -109,7 +109,7 @@
 <dt><a name="banner"></a>{@code android:banner}</dt>
 <dd>A <a href="{@docRoot}guide/topics/resources/drawable-resource.html">drawable resource</a>
 providing an extended graphical banner for its associated item. Use with the
-{@code &lt;application&gt;} tag to supply a default banner for all application activities, or with the
+{@code <application>} tag to supply a default banner for all application activities, or with the
 <a href="{@docRoot}guide/topics/manifest/activity-element.html"><code>&lt;activity&gt;</code></a>
 tag to supply a banner for a specific activity.
 
@@ -119,7 +119,7 @@
 {@link android.content.Intent#CATEGORY_LEANBACK_LAUNCHER} intent.</p>
 
 <p>This attribute must be set as a reference to a drawable resource containing
-the image (for example {@code "&#64;drawable/banner"}). There is no default banner.
+the image (for example <code>"@drawable/banner"</code>). There is no default banner.
 </p>
 
 <p>
@@ -197,7 +197,7 @@
 
 <p>
 This attribute must be set as a reference to a drawable resource containing
-the image (for example {@code "&#64;drawable/icon"}). There is no default icon.
+the image (for example <code>"@drawable/icon"</code>). There is no default icon.
 </p></dd>
 
 <dt><a name="isGame"></a>{@code android:isGame}</dt>
@@ -252,7 +252,7 @@
 <dt><a name="logo"></a>{@code android:logo}</dt>
 <dd>A logo for the application as whole, and the default logo for activities.
 <p>This attribute must be set as a reference to a drawable resource containing
-the image (for example {@code "&#64;drawable/logo"}).  There is no default logo.</p></dd>
+the image (for example <code>"@drawable/logo"</code>).  There is no default logo.</p></dd>
 
 <dt><a name="space"></a>{@code android:manageSpaceActivity}</dt>
 <dd>The fully qualified name of an Activity subclass that the system
diff --git a/docs/html/guide/topics/manifest/category-element.jd b/docs/html/guide/topics/manifest/category-element.jd
index 563ed10..0034119 100644
--- a/docs/html/guide/topics/manifest/category-element.jd
+++ b/docs/html/guide/topics/manifest/category-element.jd
@@ -20,10 +20,10 @@
 <dd><dl class="attr">
 <dt><a name="nm"></a>{@code android:name}</dt>
 <dd>The name of the category.  Standard categories are defined in the 
-{@link android.content.Intent} class as {@code CATEGORY_<i>name</i>} 
+{@link android.content.Intent} class as <code>CATEGORY_<i>name</i></code>
 constants.  The name assigned here can be derived from those constants 
 by prefixing "{@code android.intent.category.}" to the 
-{@code <i>name</i>} that follows {@code CATEGORY_}.  For example,
+<code><i>name</i></code> that follows {@code CATEGORY_}.  For example,
 the string value for {@code CATEGORY_LAUNCHER} is 
 "{@code android.intent.category.LAUNCHER}".
 
diff --git a/docs/html/guide/topics/manifest/compatible-screens-element.jd b/docs/html/guide/topics/manifest/compatible-screens-element.jd
index de921d2..9c7f036 100644
--- a/docs/html/guide/topics/manifest/compatible-screens-element.jd
+++ b/docs/html/guide/topics/manifest/compatible-screens-element.jd
@@ -21,11 +21,11 @@
 
 <dt>description:</dt>
 <dd itemprop="description">Specifies each screen configuration with which the application is compatible. Only one instance
-of the {@code &lt;compatible-screens&gt;} element is allowed in the manifest, but it can
+of the <code>&lt;compatible-screens&gt;</code> element is allowed in the manifest, but it can
 contain multiple <code>&lt;screen&gt;</code> elements. Each <code>&lt;screen&gt;</code> element
 specifies a specific screen size-density combination with which the application is compatible.
 
-  <p>The Android system <em>does not</em> read the {@code &lt;compatible-screens&gt;} manifest
+  <p>The Android system <em>does not</em> read the {@code <compatible-screens>} manifest
 element (neither at install-time nor at runtime). This element is informational only and may be used
 by external services (such as Google Play) to better understand the application's compatibility
 with specific screen configurations and enable filtering for users. Any screen configuration that is
@@ -45,14 +45,14 @@
 
   <p>If you want to set only a minimum screen <em>size</em> for your your application, then you
 should use the <a href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element. For example, if you want your application to be available
+<supports-screens>}</a> element. For example, if you want your application to be available
 only for <em>large</em> and <em>xlarge</em> screen devices, the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element allows you to declare that your application does not
+<supports-screens>}</a> element allows you to declare that your application does not
 support <em>small</em> and <em>normal</em> screen sizes. External services (such as Google
 Play) will filter your application accordingly. You can also use the <a
 href="{@docRoot}guide/topics/manifest/supports-screens-element.html">{@code
-&lt;supports-screens&gt;}</a> element to declare whether the system should resize your
+<supports-screens>}</a> element to declare whether the system should resize your
 application for different screen sizes.</p>
 
   <p>Also see the <a href="{@docRoot}google/play/filters.html">Filters on Google Play</a>
@@ -65,10 +65,10 @@
 <dd>
   <dl class="tag-list">
 
-    <dt id="screen">{@code &lt;screen&gt;}</dt>
+    <dt id="screen">{@code <screen>}</dt>
     <dd>Specifies a single screen configuration with which the application is compatible.
       <p>At least one instance of this element must be placed inside the {@code
-&lt;compatible-screens&gt;} element. This element <em>must include both</em> the {@code
+<compatible-screens>} element. This element <em>must include both</em> the {@code
 android:screenSize} and {@code android:screenDensity} attributes (if you do not declare both
 attributes, then the element is ignored).</p>
 
@@ -108,7 +108,7 @@
 <dt>example</dt>
 <dd>
 <p>If your application is compatible with only small and normal screens, regardless
-of screen density, then you must specify twelve different {@code &lt;screen&gt;} elements,
+of screen density, then you must specify twelve different {@code <screen>} elements,
 because each screen size has six different density configurations. You must declare each one of
 these; any combination of size and density that you do <em>not</em> specify is considered a screen
 configuration with which your application is <em>not</em> compatible. Here's what the manifest
diff --git a/docs/html/guide/topics/manifest/data-element.jd b/docs/html/guide/topics/manifest/data-element.jd
index 77f16dd..30020ad 100644
--- a/docs/html/guide/topics/manifest/data-element.jd
+++ b/docs/html/guide/topics/manifest/data-element.jd
@@ -24,7 +24,7 @@
 attributes for each of its parts:
 
 <p style="margin-left: 2em">
-{@code &lt;scheme>://&lt;host>:&lt;port>[&lt;path>|&lt;pathPrefix>|&lt;pathPattern>]}</p>
+{@code <scheme>://<host>:<port>[<path>|<pathPrefix>|<pathPattern>]}</p>
 
 <p>
 These attributes that specify the URL format are optional, but also mutually dependent:
@@ -36,7 +36,7 @@
 </ul>
 
 <p>
-All the {@code &lt;data&gt;} elements contained within the same
+All the {@code <data>} elements contained within the same
 <code><a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">&lt;intent-filter&gt;</a></code> element contribute to
 the same filter.  So, for example, the following filter specification,
 </p>
@@ -55,7 +55,7 @@
 &lt;/intent-filter&gt;</pre>
 
 <p>
-You can place any number of {@code &lt;data&gt;} elements inside an
+You can place any number of {@code <data>} elements inside an
 <code><a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">&lt;intent-filter&gt;</a></code> to give it multiple data
 options.  None of its attributes have default values.
 </p>
@@ -157,7 +157,7 @@
 The subtype can be the asterisk wildcard ({@code *}) to indicate that any
 subtype matches.
 
-<p>It's common for an intent filter to declare a {@code &lt;data>} that includes
+<p>It's common for an intent filter to declare a {@code <data>} that includes
 only the {@code android:mimeType} attribute.</p>
 
 
diff --git a/docs/html/guide/topics/manifest/grant-uri-permission-element.jd b/docs/html/guide/topics/manifest/grant-uri-permission-element.jd
index 2179359..b2d9bb7 100644
--- a/docs/html/guide/topics/manifest/grant-uri-permission-element.jd
+++ b/docs/html/guide/topics/manifest/grant-uri-permission-element.jd
@@ -26,7 +26,7 @@
 attribute is "{@code true}", permission can be granted for any the data under 
 the provider's purview.  However, if that attribute is "{@code false}", permission 
 can be granted only to data subsets that are specified by this element.  
-A provider can contain any number of {@code &lt;grant-uri-permission&gt;} elements.  
+A provider can contain any number of {@code <grant-uri-permission>} elements.
 Each one can specify only one path (only one of the three possible attributes).
 </p>
 
diff --git a/docs/html/guide/topics/manifest/manifest-intro.jd b/docs/html/guide/topics/manifest/manifest-intro.jd
index d2a9308..c8d68f5 100644
--- a/docs/html/guide/topics/manifest/manifest-intro.jd
+++ b/docs/html/guide/topics/manifest/manifest-intro.jd
@@ -279,7 +279,7 @@
 should be localized and therefore set from a resource or theme.  Resource 
 values are expressed in the following format,</p>
 
-<p style="margin-left: 2em">{@code @[<i>package</i>:]<i>type</i>:<i>name</i>}</p>
+<p style="margin-left: 2em"><code>@[<i>package</i>:]<i>type</i>:<i>name</i></code></p>
 
 <p>
 where the <i>package</i> name can be omitted if the resource is in the same package 
@@ -295,7 +295,7 @@
 rather than '{@code @}':
 </p>
 
-<p style="margin-left: 2em">{@code ?[<i>package</i>:]<i>type</i>:<i>name</i>}
+<p style="margin-left: 2em"><code>?[<i>package</i>:]<i>type</i>:<i>name</i></code>
 </p></dd>
 
 <dt><b>String values</b></dt>
diff --git a/docs/html/guide/topics/manifest/meta-data-element.jd b/docs/html/guide/topics/manifest/meta-data-element.jd
index 241153b..d3b41c3 100644
--- a/docs/html/guide/topics/manifest/meta-data-element.jd
+++ b/docs/html/guide/topics/manifest/meta-data-element.jd
@@ -20,7 +20,7 @@
 <dt>description:</dt>
 <dd itemprop="description">A name-value pair for an item of additional, arbitrary data that can
 be supplied to the parent component.  A component element can contain any 
-number of {@code &lt;meta-data&gt;} subelements.  The values from all of
+number of {@code <meta-data>} subelements.  The values from all of
 them are collected in a single {@link android.os.Bundle} object and made 
 available to the component as the 
 {@link android.content.pm.PackageItemInfo#metaData 
@@ -45,7 +45,7 @@
 
 <p>
 It is highly recommended that you avoid supplying related data as 
-multiple separate {@code &lt;meta-data&gt;} entries. Instead, if you 
+multiple separate {@code <meta-data>} entries. Instead, if you
 have complex data to associate with a component, store it as a resource and 
 use the {@code resource} attribute to inform the component of its ID.
 </p></dd>
diff --git a/docs/html/guide/topics/manifest/provider-element.jd b/docs/html/guide/topics/manifest/provider-element.jd
index f3ffd58..4b5c0c3 100644
--- a/docs/html/guide/topics/manifest/provider-element.jd
+++ b/docs/html/guide/topics/manifest/provider-element.jd
@@ -40,7 +40,7 @@
     Declares a content provider component. A content provider is a subclass of 
     {@link android.content.ContentProvider} that supplies structured access to data managed by the 
     application.  All content providers in your application must be defined in a 
-    {@code &lt;provider&gt;} element in the manifest file; otherwise, the system is unaware of them 
+    {@code <provider>} element in the manifest file; otherwise, the system is unaware of them
     and doesn't run them.
     <p>
         You only declare content providers that are part of your application. Content providers in
@@ -100,7 +100,7 @@
 The <code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code> element has its own 
 <code><a href="{@docRoot}guide/topics/manifest/application-element.html#enabled">enabled</a></code> attribute that applies to all 
 application components, including content providers.  The 
-<code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code> and {@code &lt;provider&gt;} 
+<code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code> and {@code <provider>}
 attributes must both be "{@code true}" (as they both
 are by default) for the content provider to be enabled.  If either is 
 "{@code false}", the provider is disabled; it cannot be instantiated.
diff --git a/docs/html/guide/topics/manifest/receiver-element.jd b/docs/html/guide/topics/manifest/receiver-element.jd
index df2437e..081a191 100644
--- a/docs/html/guide/topics/manifest/receiver-element.jd
+++ b/docs/html/guide/topics/manifest/receiver-element.jd
@@ -49,7 +49,7 @@
 <code><a href="{@docRoot}guide/topics/manifest/application-element.html#enabled">enabled</a></code> attribute that applies to all 
 application components, including broadcast receivers.  The 
 <code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code> and
-{@code &lt;receiver&gt;} attributes must both be "{@code true}" for 
+{@code <receiver>} attributes must both be "{@code true}" for
 the broadcast receiver to be enabled.  If either is "{@code false}", it is
 disabled; it cannot be instantiated.
 </p></dd>
diff --git a/docs/html/guide/topics/manifest/service-element.jd b/docs/html/guide/topics/manifest/service-element.jd
index e26f263..fca85f5 100644
--- a/docs/html/guide/topics/manifest/service-element.jd
+++ b/docs/html/guide/topics/manifest/service-element.jd
@@ -31,7 +31,7 @@
 applications.
 
 <p>
-All services must be represented by {@code &lt;service&gt;} elements in 
+All services must be represented by {@code <service>} elements in
 the manifest file.  Any that are not declared there will not be seen 
 by the system and will never be run.
 </p></dd>
@@ -47,7 +47,7 @@
 The <code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code> element has its own 
 <code><a href="{@docRoot}guide/topics/manifest/application-element.html#enabled">enabled</a></code> attribute that applies to all 
 application components, including services.  The 
-<code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code> and {@code &lt;service&gt;} 
+<code><a href="{@docRoot}guide/topics/manifest/application-element.html">&lt;application&gt;</a></code> and {@code <service>}
 attributes must both be "{@code true}" (as they both
 are by default) for the service to be enabled.  If either is 
 "{@code false}", the service is disabled; it cannot be instantiated.
diff --git a/docs/html/guide/topics/manifest/supports-screens-element.jd b/docs/html/guide/topics/manifest/supports-screens-element.jd
index bbeceb7..a4546fa 100644
--- a/docs/html/guide/topics/manifest/supports-screens-element.jd
+++ b/docs/html/guide/topics/manifest/supports-screens-element.jd
@@ -38,7 +38,7 @@
 when it is on a tablet compared to when running on a handset device.</p>
 
 <p>However, if your application does not work well when resized to fit different screen sizes, you
-can use the attributes of the {@code &lt;supports-screens&gt;} element to control whether your
+can use the attributes of the {@code <supports-screens>} element to control whether your
 application should be distributed to smaller screens or have its UI scaled up ("zoomed") to fit
 larger screens using the system's <a
 href="{@docRoot}guide/practices/screen-compat-mode.html">screen compatibility mode</a>. When you
@@ -152,7 +152,7 @@
 not need to use this attribute. Otherwise, you should use a value for this attribute that
 matches the smallest value used by your application for the <a
 href="{@docRoot}guide/topics/resources/providing-resources.html#SmallestScreenWidthQualifier">
-smallest screen width qualifier</a> ({@code sw&lt;N&gt;dp}).</p>
+smallest screen width qualifier</a> ({@code sw<N>dp}).</p>
 
   <p class="caution"><strong>Caution:</strong> The Android system does not pay attention to this
 attribute, so it does not affect how your application behaves at runtime. Instead, it is used
diff --git a/docs/html/guide/topics/manifest/uses-configuration-element.jd b/docs/html/guide/topics/manifest/uses-configuration-element.jd
index 15fd49c1..f551672 100644
--- a/docs/html/guide/topics/manifest/uses-configuration-element.jd
+++ b/docs/html/guide/topics/manifest/uses-configuration-element.jd
@@ -38,7 +38,7 @@
 information about how to support d-pad input in your app, read <a href=
 "{@docRoot}guide/topics/ui/accessibility/apps.html#focus-nav">Enabling Focus Navigation</a>. If
 your app absolutely cannot function without a touchscreen, then instead use the <a href=
-"{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a> tag to
+"{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a> tag to
 declare the required touchscreen type, ranging from {@code "android.hardware.faketouch"} for basic
 touch-style events to more advanced touch types such as {@code
 "android.hardware.touchscreen.multitouch.jazzhand"} for distinct input from multiple fingers.</p>
@@ -160,7 +160,7 @@
       <p class="note"><strong>Note:</strong> If some type of touch input is required for your app,
       you should instead use the
       <a href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code
-      &lt;uses-feature>}</a> tag to declare the required touchscreen
+      <uses-feature>}</a> tag to declare the required touchscreen
       type, beginning with {@code "android.hardware.faketouch"} for basic touch-style events.</p>
    </td>
 </tr>
diff --git a/docs/html/guide/topics/manifest/uses-feature-element.jd b/docs/html/guide/topics/manifest/uses-feature-element.jd
index 21e3057..e746a67 100644
--- a/docs/html/guide/topics/manifest/uses-feature-element.jd
+++ b/docs/html/guide/topics/manifest/uses-feature-element.jd
@@ -719,10 +719,10 @@
 android:screenOrientation}</a> with either {@code "landscape"}, {@code "reverseLandscape"}, or
 {@code "sensorLandscape"}, then your application will be available only to devices that support
 landscape orientation. As a best practice, you should still declare your requirement for this
-orientation using a {@code &lt;uses-feature&gt;} element. If you declare an orientation for your
+orientation using a {@code <uses-feature>} element. If you declare an orientation for your
 activity using <a href="{@docRoot}guide/topics/manifest/activity-element.html#screen">{@code
 android:screenOrientation}</a>, but don't actually <em>require</em> it, you can disable the
-requirement by declaring the orientation with a {@code &lt;uses-feature&gt;} element and include
+requirement by declaring the orientation with a {@code <uses-feature>} element and include
 {@code android:required="false"}.</p>
     <p>For backwards compatibility, any device running a platform version that supports only API
 level 12 or lower is assumed to support both landscape and portrait.</p>
@@ -780,9 +780,9 @@
   <p class="note"><strong>Note:</strong> Because applications require the {@code
 android.hardware.touchscreen} feature by default, if you want your application to be available to
 devices that provide a fake touch interface, you must also explicitly declare that a touch screen is
-<em>not</em> required by declaring {@code &lt;uses-feature
+<em>not</em> required by declaring <code>&lt;uses-feature
 android:name="android.hardware.touchscreen" <strong>android:required="false"</strong>
-/&gt;}</p></td>
+/&gt;</code></p></td>
 </tr>
 
 <tr>
diff --git a/docs/html/guide/topics/media/mediarouter.jd b/docs/html/guide/topics/media/mediarouter.jd
index e0bf889..54d52a6 100644
--- a/docs/html/guide/topics/media/mediarouter.jd
+++ b/docs/html/guide/topics/media/mediarouter.jd
@@ -95,7 +95,7 @@
   {@link android.support.v7.media.MediaRouteProvider} and distributing it as an application.
   For more information on implementing a media route provider, see the {@link
   android.support.v7.media.MediaRouteProvider} reference documentation and the v7-mediarouter
-  support library sample {@code &lt;sdk&gt;/extras/android/compatibility/v7/mediarouter}.
+  support library sample {@code <sdk>/extras/android/compatibility/v7/mediarouter}.
 </p>
 
 
@@ -540,7 +540,7 @@
   multiple media items for playback and management of the media queue. For a comprehensive sample
   implementation of these features, see {@code SampleMediaRouterActivity} and its associated
   classes in the v7 mediarouter support library sample
-  {@code &lt;sdk&gt;/extras/android/compatibility/v7/mediarouter}.
+  {@code <sdk>/extras/android/compatibility/v7/mediarouter}.
 </p>
 
 <p>
diff --git a/docs/html/guide/topics/providers/document-provider.jd b/docs/html/guide/topics/providers/document-provider.jd
index 8ea08bd..9d03616 100644
--- a/docs/html/guide/topics/providers/document-provider.jd
+++ b/docs/html/guide/topics/providers/document-provider.jd
@@ -282,7 +282,7 @@
 <li>Adding the category {@link android.content.Intent#CATEGORY_OPENABLE} to the
 intent filters the results to display only documents that can be opened, such as image files.</li>
 
-<li>The statement {@code intent.setType(&quot;image/*&quot;)} further filters to
+<li>The statement <code>intent.setType(&quot;image/*&quot;)</code> further filters to
 display only documents that have the image MIME data type.</li>
 </ul>
 
@@ -580,7 +580,7 @@
 
 <li>The {@code android:enabled} attribute set to a boolean value defined in a resource
 file. The purpose of this attribute is to disable the provider on devices running Android 4.3 or lower.
-For example, {@code android:enabled=&quot;&#64;bool/atLeastKitKat&quot;}. In
+For example, <code>android:enabled=&quot;&#64;bool/atLeastKitKat&quot;</code>. In
 addition to including this attribute in the manifest, you need to do the following:
 <ul>
 <li>In your {@code bool.xml} resources file under {@code res/values/}, add
diff --git a/docs/html/guide/topics/resources/accessing-resources.jd b/docs/html/guide/topics/resources/accessing-resources.jd
index 8f99653..b971238 100644
--- a/docs/html/guide/topics/resources/accessing-resources.jd
+++ b/docs/html/guide/topics/resources/accessing-resources.jd
@@ -9,8 +9,8 @@
   <ul>
     <li>Resources can be referenced from code using integers from {@code R.java}, such as
 {@code R.drawable.myimage}</li>
-    <li>Resources can be referenced from resources using a special XML syntax, such as {@code
-&#64;drawable/myimage}</li>
+    <li>Resources can be referenced from resources using a special XML syntax, such as
+<code>@drawable/myimage</code></li>
     <li>You can also access your app resources with methods in
 {@link android.content.res.Resources}</li>
   </ul>
@@ -129,10 +129,10 @@
 </pre>
 
 <ul>
-  <li><em>{@code &lt;package_name&gt;}</em> is the name of the package in which the resource is located (not
+  <li><em>{@code <package_name>}</em> is the name of the package in which the resource is located (not
 required when referencing resources from your own package).</li>
-  <li><em>{@code &lt;resource_type&gt;}</em> is the {@code R} subclass for the resource type.</li>
-  <li><em>{@code &lt;resource_name&gt;}</em> is either the resource filename
+  <li><em>{@code <resource_type>}</em> is the {@code R} subclass for the resource type.</li>
+  <li><em>{@code <resource_name>}</em> is either the resource filename
 without the extension or the {@code android:name} attribute value in the XML element (for simple
 values).</li>
 </ul>
@@ -210,11 +210,11 @@
 </pre>
 
 <ul>
-  <li>{@code &lt;package_name&gt;} is the name of the package in which the resource is located (not
+  <li>{@code <package_name>} is the name of the package in which the resource is located (not
 required when referencing resources from the same package)</li>
-  <li>{@code &lt;resource_type&gt;} is the
+  <li>{@code <resource_type>} is the
 {@code R} subclass for the resource type</li>
-  <li>{@code &lt;resource_name&gt;} is either the resource filename
+  <li>{@code <resource_name>} is either the resource filename
 without the extension or the {@code android:name} attribute value in the XML element (for simple
 values).</li>
 </ul>
@@ -295,7 +295,7 @@
 essentially says, "use the style that is defined by this attribute, in the current theme."</p>
 
 <p>To reference a style attribute, the name syntax is almost identical to the normal resource
-format, but instead of the at-symbol ({@code &#64;}), use a question-mark ({@code ?}), and the
+format, but instead of the at-symbol (<code>&#64;</code>), use a question-mark ({@code ?}), and the
 resource type portion is optional. For instance:</p>
 
 <pre class="classic">
diff --git a/docs/html/guide/topics/resources/color-list-resource.jd b/docs/html/guide/topics/resources/color-list-resource.jd
index b20915c..61f6665 100644
--- a/docs/html/guide/topics/resources/color-list-resource.jd
+++ b/docs/html/guide/topics/resources/color-list-resource.jd
@@ -20,7 +20,7 @@
 or niether) and, using a color state list, you can provide a different color during each state.</p>
 
 <p>You can describe the state list in an XML file. Each color is defined in an {@code
-&lt;item>} element inside a single {@code &lt;selector>} element. Each {@code &lt;item>}
+<item>} element inside a single {@code <selector>} element. Each {@code <item>}
 uses various attributes to describe the state in which it should be used.</p>
 
 <p>During each state change, the state list is traversed top to bottom and the first item that
@@ -69,7 +69,7 @@
 
   <dt id="selector-element"><code>&lt;selector&gt;</code></dt>
     <dd><strong>Required.</strong> This must be the root element. Contains one or more {@code
-&lt;item>} elements.
+<item>} elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
         <dt><code>xmlns:android</code></dt>
diff --git a/docs/html/guide/topics/resources/drawable-resource.jd b/docs/html/guide/topics/resources/drawable-resource.jd
index 06bd2d0..dd2c4c2 100644
--- a/docs/html/guide/topics/resources/drawable-resource.jd
+++ b/docs/html/guide/topics/resources/drawable-resource.jd
@@ -139,11 +139,11 @@
 <p>An XML bitmap is a resource defined in XML that points to a bitmap file. The effect is an alias for a
 raw bitmap file. The XML can specify additional properties for the bitmap such as dithering and tiling.</p>
 
-<p class="note"><strong>Note:</strong> You can use a {@code &lt;bitmap&gt;} element as a child of
-an {@code &lt;item&gt;} element. For
+<p class="note"><strong>Note:</strong> You can use a {@code <bitmap>} element as a child of
+an {@code <item>} element. For
 example, when creating a <a href="#StateList">state list</a> or <a href="#LayerList">layer list</a>,
 you can exclude the {@code android:drawable}
-attribute from an {@code &lt;item&gt;} element and nest a {@code &lt;bitmap&gt;} inside it
+attribute from an {@code <item>} element and nest a {@code <bitmap>} inside it
 that defines the drawable item.</p>
 
 <dl class="xml">
@@ -448,8 +448,8 @@
 that manages an array of other drawables. Each drawable in the list is drawn in the order of the
 list&mdash;the last drawable in the list is drawn on top.</p>
 
-<p>Each drawable is represented by an {@code &lt;item&gt;} element inside a single {@code
-&lt;layer-list&gt;} element.</p>
+<p>Each drawable is represented by an {@code <item>} element inside a single {@code
+<layer-list>} element.</p>
 
 <dl class="xml">
 
@@ -492,7 +492,7 @@
 
   <dt id="layerlist-element"><code>&lt;layer-list&gt;</code></dt>
     <dd><strong>Required.</strong> This must be the root element. Contains one or more {@code
-&lt;item>} elements.
+<item>} elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
         <dt><code>xmlns:android</code></dt>
@@ -502,7 +502,7 @@
     </dd>
   <dt id="layerlist-item-element"><code>&lt;item&gt;</code></dt>
     <dd>Defines a drawable to place in the layer drawable, in a position defined by its attributes.
-Must be a child of a <code>&lt;selector&gt;</code> element. Accepts child {@code &lt;bitmap&gt;}
+Must be a child of a <code>&lt;selector&gt;</code> element. Accepts child {@code <bitmap>}
 elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
@@ -528,15 +528,15 @@
       <p>All drawable items are scaled to fit the size of the containing View, by default. Thus,
 placing your images in a layer list at different positions might increase the size of the View and
 some images scale as appropriate. To avoid
-scaling items in the list, use a {@code &lt;bitmap&gt;} element inside the {@code
-&lt;item&gt;} element to specify the drawable and define the gravity to something that does not
-scale, such as {@code "center"}. For example, the following {@code &lt;item&gt;} defines an item
+scaling items in the list, use a {@code <bitmap>} element inside the {@code
+<item>} element to specify the drawable and define the gravity to something that does not
+scale, such as {@code "center"}. For example, the following {@code <item>} defines an item
 that scales to fit its container View:</p>
 <pre>
 &lt;item android:drawable="@drawable/image" /&gt;
 </pre>
 
-<p>To avoid scaling, the following example uses a {@code &lt;bitmap&gt;} element with centered
+<p>To avoid scaling, the following example uses a {@code <bitmap>} element with centered
 gravity:</p>
 <pre>
 &lt;item&gt;
@@ -569,7 +569,7 @@
     &lt;/item&gt;
 &lt;/layer-list&gt;
 </pre>
-<p>Notice that this example uses a nested {@code &lt;bitmap&gt;} element to define the drawable
+<p>Notice that this example uses a nested {@code <bitmap>} element to define the drawable
 resource for each item with a "center" gravity. This ensures that none of the images are scaled to
 fit the size of the container, due to resizing caused by the offset images.</p>
 
@@ -611,7 +611,7 @@
 state.</p>
 
 <p>You can describe the state list in an XML file. Each graphic is represented by an {@code
-&lt;item>} element inside a single {@code &lt;selector>} element. Each {@code &lt;item>}
+<item>} element inside a single {@code <selector>} element. Each {@code <item>}
 uses various attributes to describe the state in which it should be used as the graphic for the
 drawable.</p>
 
@@ -666,7 +666,7 @@
 
   <dt id="selector-element"><code>&lt;selector&gt;</code></dt>
     <dd><strong>Required.</strong> This must be the root element. Contains one or more {@code
-&lt;item>} elements.
+<item>} elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
         <dt><code>xmlns:android</code></dt>
@@ -828,7 +828,7 @@
 <dl class="tag-list">
 
   <dt id="levellist-element"><code>&lt;level-list&gt;</code></dt>
-  <dd>This must be the root element. Contains one or more {@code &lt;item&gt;} elements.
+  <dd>This must be the root element. Contains one or more {@code <item>} elements.
     <p class="caps">attributes:</p>
     <dl class="atn-list">
       <dt><code>xmlns:android</code></dt>
@@ -895,8 +895,8 @@
 <p>A {@link android.graphics.drawable.TransitionDrawable} is a drawable object
 that can cross-fade between the two drawable resources.</p>
 
-<p>Each drawable is represented by an {@code &lt;item&gt;} element inside a single {@code
-&lt;transition&gt;} element. No more than two items are supported. To transition forward, call
+<p>Each drawable is represented by an {@code <item>} element inside a single {@code
+<transition>} element. No more than two items are supported. To transition forward, call
 {@link android.graphics.drawable.TransitionDrawable#startTransition(int) startTransition()}. To
 transition backward, call {@link android.graphics.drawable.TransitionDrawable#reverseTransition(int)
 reverseTransition()}.</p>
@@ -942,7 +942,7 @@
 
   <dt id="transition-element"><code>&lt;transition&gt;</code></dt>
     <dd><strong>Required.</strong> This must be the root element. Contains one or more {@code
-&lt;item>} elements.
+<item>} elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
         <dt><code>xmlns:android</code></dt>
@@ -952,7 +952,7 @@
     </dd>
   <dt id="transition-item-element"><code>&lt;item&gt;</code></dt>
     <dd>Defines a drawable to use as part of the drawable transition.
-Must be a child of a <code>&lt;transition&gt;</code> element. Accepts child {@code &lt;bitmap&gt;}
+Must be a child of a <code>&lt;transition&gt;</code> element. Accepts child {@code <bitmap>}
 elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
@@ -1516,7 +1516,7 @@
                 <td>An oval shape that fits the dimensions of the containing View.</td></tr>
             <tr><td>{@code "line"}</td>
                 <td>A horizontal line that spans the width of the containing View. This
-                shape requires the {@code &lt;stroke>} element to define the width of the
+                shape requires the {@code <stroke>} element to define the width of the
                 line.</td></tr>
             <tr><td>{@code "ring"}</td>
                 <td>A ring shape.</td></tr>
diff --git a/docs/html/guide/topics/resources/layout-resource.jd b/docs/html/guide/topics/resources/layout-resource.jd
index 366ddc8..8c5708a 100644
--- a/docs/html/guide/topics/resources/layout-resource.jd
+++ b/docs/html/guide/topics/resources/layout-resource.jd
@@ -54,7 +54,7 @@
 </pre>
 <p class="note"><strong>Note:</strong> The root element can be either a
 {@link android.view.ViewGroup}, a {@link android.view.View}, or a <a
-href="#merge-element">{@code &lt;merge&gt;}</a> element, but there must be only
+href="#merge-element">{@code <merge>}</a> element, but there must be only
 one root element and it must contain the {@code xmlns:android} attribute with the {@code android}
 namespace as shown.</p>
 </dd>
diff --git a/docs/html/guide/topics/resources/more-resources.jd b/docs/html/guide/topics/resources/more-resources.jd
index b5f449a..1afbf70 100644
--- a/docs/html/guide/topics/resources/more-resources.jd
+++ b/docs/html/guide/topics/resources/more-resources.jd
@@ -34,13 +34,13 @@
 <p class="note"><strong>Note:</strong> A bool is a simple resource that is referenced
 using the value provided in the {@code name} attribute (not the name of the XML file). As
 such, you can combine bool resources with other simple resources in the one XML file,
-under one {@code &lt;resources>} element.</p>
+under one {@code <resources>} element.</p>
 
 <dl class="xml">
 
 <dt>file location:</dt>
 <dd><code>res/values/<em>filename</em>.xml</code><br/>
-The filename is arbitrary. The {@code &lt;bool>} element's {@code name} will be used as the resource
+The filename is arbitrary. The {@code <bool>} element's {@code name} will be used as the resource
 ID.</dd>
 
 <dt>resource reference:</dt>
@@ -130,13 +130,13 @@
 <p class="note"><strong>Note:</strong> A color is a simple resource that is referenced
 using the value provided in the {@code name} attribute (not the name of the XML file). As
 such, you can combine color resources with other simple resources in the one XML file,
-under one {@code &lt;resources>} element.</p>
+under one {@code <resources>} element.</p>
 
 <dl class="xml">
 
 <dt>file location:</dt>
 <dd><code>res/values/colors.xml</code><br/>
-The filename is arbitrary. The {@code &lt;color>} element's {@code name} will be used as the
+The filename is arbitrary. The {@code <color>} element's {@code name} will be used as the
 resource ID.</dd>
 
 <dt>resource reference:</dt>
@@ -244,13 +244,13 @@
 <p class="note"><strong>Note:</strong> A dimension is a simple resource that is referenced
 using the value provided in the {@code name} attribute (not the name of the XML file). As
 such, you can combine dimension resources with other simple resources in the one XML file,
-under one {@code &lt;resources>} element.</p>
+under one {@code <resources>} element.</p>
 
 <dl class="xml">
 
 <dt>file location:</dt>
 <dd><code>res/values/<em>filename</em>.xml</code><br/>
-The filename is arbitrary. The {@code &lt;dimen>} element's {@code name} will be used as the
+The filename is arbitrary. The {@code <dimen>} element's {@code name} will be used as the
 resource ID.</dd>
 
 <dt>resource reference:</dt>
@@ -329,7 +329,7 @@
 
 <h2 id="Id">ID</h2>
 
-<p>A unique resource ID defined in XML. Using the name you provide in the {@code &lt;item&gt;}
+<p>A unique resource ID defined in XML. Using the name you provide in the {@code <item>}
 element, the Android developer tools create a unique integer in your project's {@code
 R.java} class, which you can use as an
 identifier for an application resources (for example, a {@link android.view.View} in your UI layout)
@@ -339,7 +339,7 @@
 <p class="note"><strong>Note:</strong> An ID is a simple resource that is referenced
 using the value provided in the {@code name} attribute (not the name of the XML file). As
 such, you can combine ID resources with other simple resources in the one XML file,
-under one {@code &lt;resources&gt;} element. Also, remember that an ID resources does not reference
+under one {@code <resources>} element. Also, remember that an ID resources does not reference
 an actual resource item; it is simply a unique ID that you can attach to other resources or use
 as a unique integer in your application.</p>
 
@@ -446,13 +446,13 @@
 <p class="note"><strong>Note:</strong> An integer is a simple resource that is referenced
 using the value provided in the {@code name} attribute (not the name of the XML file). As
 such, you can combine integer resources with other simple resources in the one XML file,
-under one {@code &lt;resources>} element.</p>
+under one {@code <resources>} element.</p>
 
 <dl class="xml">
 
 <dt>file location:</dt>
 <dd><code>res/values/<em>filename.xml</em></code><br/>
-The filename is arbitrary. The {@code &lt;integer>} element's {@code name} will be used as the
+The filename is arbitrary. The {@code <integer>} element's {@code name} will be used as the
 resource ID.</dd>
 
 <dt>resource reference:</dt>
@@ -525,14 +525,14 @@
 <p class="note"><strong>Note:</strong> An integer array is a simple resource that is referenced
 using the value provided in the {@code name} attribute (not the name of the XML file). As
 such, you can combine integer array resources with other simple resources in the one XML file,
-under one {@code &lt;resources>} element.</p>
+under one {@code <resources>} element.</p>
 
 
 <dl class="xml">
 
 <dt>file location:</dt>
 <dd><code>res/values/<em>filename</em>.xml</code><br/>
-The filename is arbitrary. The {@code &lt;integer-array>} element's {@code name} will be used as the
+The filename is arbitrary. The {@code <integer-array>} element's {@code name} will be used as the
 resource ID.</dd>
 
 <dt>compiled resource datatype:</dt>
@@ -566,7 +566,7 @@
       <p>No attributes.</p>
     </dd>
   <dt id="integer-array-element"><code>&lt;integer-array&gt;</code></dt>
-    <dd>Defines an array of integers. Contains one or more child {@code &lt;item>} elements.
+    <dd>Defines an array of integers. Contains one or more child {@code <item>} elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
         <dt><code>android:name</code></dt>
@@ -576,7 +576,7 @@
     </dd>
   <dt id="integer-array-item-element"><code>&lt;item&gt;</code></dt>
     <dd>An integer. The value can be a reference to another
-integer resource. Must be a child of a {@code &lt;integer-array&gt;} element.
+integer resource. Must be a child of a {@code <integer-array>} element.
       <p>No attributes.</p>
     </dd>
 </dl>
@@ -620,14 +620,14 @@
 <p class="note"><strong>Note:</strong> A typed array is a simple resource that is referenced
 using the value provided in the {@code name} attribute (not the name of the XML file). As
 such, you can combine typed array resources with other simple resources in the one XML file,
-under one {@code &lt;resources&gt;} element.</p>
+under one {@code <resources>} element.</p>
 
 
 <dl class="xml">
 
 <dt>file location:</dt>
 <dd><code>res/values/<em>filename</em>.xml</code><br/>
-The filename is arbitrary. The {@code &lt;array>} element's {@code name} will be used as the
+The filename is arbitrary. The {@code <array>} element's {@code name} will be used as the
 resource ID.</dd>
 
 <dt>compiled resource datatype:</dt>
@@ -660,7 +660,7 @@
       <p>No attributes.</p>
     </dd>
   <dt id="array-element"><code>&lt;array&gt;</code></dt>
-    <dd>Defines an array. Contains one or more child {@code &lt;item>} elements.
+    <dd>Defines an array. Contains one or more child {@code <item>} elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
         <dt><code>android:name</code></dt>
@@ -670,7 +670,7 @@
     </dd>
   <dt id="array-item-element"><code>&lt;item&gt;</code></dt>
     <dd>A generic resource. The value can be a reference to a resource or a simple data type.
-Must be a child of an {@code &lt;array&gt;} element.
+Must be a child of an {@code <array>} element.
       <p>No attributes.</p>
     </dd>
 </dl>
diff --git a/docs/html/guide/topics/resources/providing-resources.jd b/docs/html/guide/topics/resources/providing-resources.jd
index c179a2e..c919ed5 100644
--- a/docs/html/guide/topics/resources/providing-resources.jd
+++ b/docs/html/guide/topics/resources/providing-resources.jd
@@ -148,7 +148,7 @@
     <td><code>raw/</code></td>
     <td><p>Arbitrary files to save in their raw form. To open these resources with a raw
 {@link java.io.InputStream}, call {@link android.content.res.Resources#openRawResource(int)
-Resources.openRawResource()} with the resource ID, which is {@code R.raw.<em>filename</em>}.</p>
+Resources.openRawResource()} with the resource ID, which is <code>R.raw.<em>filename</em></code>.</p>
       <p>However, if you need access to original file names and file hierarchy, you might consider
 saving some resources in the {@code
 assets/} directory (instead of {@code res/raw/}). Files in {@code assets/} are not given a
@@ -160,9 +160,9 @@
     <td><p>XML files that contain simple values, such as strings, integers, and colors.</p>
       <p>Whereas XML resource files in other {@code res/} subdirectories define a single resource
 based on the XML filename, files in the {@code values/} directory describe multiple resources.
-For a file in this directory, each child of the {@code &lt;resources&gt;} element defines a single
-resource. For example, a {@code &lt;string&gt;} element creates an
-{@code R.string} resource and a  {@code &lt;color&gt;} element creates an {@code R.color}
+For a file in this directory, each child of the {@code <resources>} element defines a single
+resource. For example, a {@code <string>} element creates an
+{@code R.string} resource and a  {@code <color>} element creates an {@code R.color}
 resource.</p>
       <p>Because each resource is defined with its own XML element, you can name the file
 whatever you want and place different resource types in one file. However, for clarity, you might
@@ -229,15 +229,15 @@
 
 <p>To specify configuration-specific alternatives for a set of resources:</p>
 <ol>
-  <li>Create a new directory in {@code res/} named in the form {@code
-<em>&lt;resources_name&gt;</em>-<em>&lt;config_qualifier&gt;</em>}.
+  <li>Create a new directory in {@code res/} named in the form
+  <code><em>&lt;resources_name&gt;</em>-<em>&lt;config_qualifier&gt;</em></code>.
     <ul>
-      <li><em>{@code &lt;resources_name&gt;}</em> is the directory name of the corresponding default
+      <li><em>{@code <resources_name>}</em> is the directory name of the corresponding default
 resources (defined in table 1).</li>
-      <li><em>{@code &lt;qualifier&gt;}</em> is a name that specifies an individual configuration
+      <li><em>{@code <qualifier>}</em> is a name that specifies an individual configuration
 for which these resources are to be used (defined in table 2).</li>
     </ul>
-    <p>You can append more than one <em>{@code &lt;qualifier&gt;}</em>. Separate each
+    <p>You can append more than one <em>{@code <qualifier>}</em>. Separate each
 one with a dash.</p>
     <p class="caution"><strong>Caution:</strong> When appending multiple qualifiers, you must
 place them in the same order in which they are listed in table 2. If the qualifiers are ordered
@@ -384,7 +384,7 @@
 screen area. Specifically, the device's smallestWidth is the shortest of the screen's available
 height and width (you may also think of it as the "smallest possible width" for the screen). You can
 use this qualifier to ensure that, regardless of the screen's current orientation, your
-application has at least {@code &lt;N&gt;} dps of width available for its UI.</p>
+application has at least {@code <N>} dps of width available for its UI.</p>
         <p>For example, if your layout requires that its smallest dimension of screen area be at
 least 600 dp at all times, then you can use this qualifer to create the layout resources, {@code
 res/layout-sw600dp/}. The system will use these resources only when the smallest dimension of
@@ -899,13 +899,13 @@
 name other than {@code icon.png}) and put
 it in the default {@code res/drawable/} directory. Then create an {@code icon.xml} file in {@code
 res/drawable-en-rCA/} and {@code res/drawable-fr-rCA/} that refers to the {@code icon_ca.png}
-resource using the {@code &lt;bitmap&gt;} element. This allows you to store just one version of the
+resource using the {@code <bitmap>} element. This allows you to store just one version of the
 PNG file and two small XML files that point to it. (An example XML file is shown below.)</p>
 
 
 <h4>Drawable</h4>
 
-<p>To create an alias to an existing drawable, use the {@code &lt;bitmap&gt;} element.
+<p>To create an alias to an existing drawable, use the {@code <bitmap>} element.
 For example:</p>
 
 <pre>
@@ -922,8 +922,8 @@
 
 <h4>Layout</h4>
 
-<p>To create an alias to an existing layout, use the {@code &lt;include&gt;}
-element, wrapped in a {@code &lt;merge&gt;}. For example:</p>
+<p>To create an alias to an existing layout, use the {@code <include>}
+element, wrapped in a {@code <merge>}. For example:</p>
 
 <pre>
 &lt;?xml version="1.0" encoding="utf-8"?>
diff --git a/docs/html/guide/topics/resources/runtime-changes.jd b/docs/html/guide/topics/resources/runtime-changes.jd
index 0e03fe0..8781d20 100644
--- a/docs/html/guide/topics/resources/runtime-changes.jd
+++ b/docs/html/guide/topics/resources/runtime-changes.jd
@@ -190,7 +190,7 @@
 configuration change and is not recommended for most applications.</p>
 
 <p>To declare that your activity handles a configuration change, edit the appropriate <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> element in
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element in
 your manifest file to include the <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#config">{@code
 android:configChanges}</a> attribute with a value that represents the configuration you want to
diff --git a/docs/html/guide/topics/resources/string-resource.jd b/docs/html/guide/topics/resources/string-resource.jd
index 743e692..9adf6de 100644
--- a/docs/html/guide/topics/resources/string-resource.jd
+++ b/docs/html/guide/topics/resources/string-resource.jd
@@ -28,13 +28,13 @@
 <p class="note"><strong>Note:</strong> A string is a simple resource that is referenced
 using the value provided in the {@code name} attribute (not the name of the XML file). So, you can
 combine string resources with other simple resources in the one XML file,
-under one {@code &lt;resources>} element.</p>
+under one {@code <resources>} element.</p>
 
 <dl class="xml">
 
 <dt>file location:</dt>
 <dd><code>res/values/<em>filename</em>.xml</code><br/>
-The filename is arbitrary. The {@code &lt;string>} element's {@code name} will be used as the
+The filename is arbitrary. The {@code <string>} element's {@code name} will be used as the
 resource ID.</dd>
 
 <dt>compiled resource datatype:</dt>
@@ -125,13 +125,13 @@
 <p class="note"><strong>Note:</strong> A string array is a simple resource that is referenced
 using the value provided in the {@code name} attribute (not the name of the XML file). As
 such, you can combine string array resources with other simple resources in the one XML file,
-under one {@code &lt;resources>} element.</p>
+under one {@code <resources>} element.</p>
 
 <dl class="xml">
 
 <dt>file location:</dt>
 <dd><code>res/values/<em>filename</em>.xml</code><br/>
-The filename is arbitrary. The {@code &lt;string-array>} element's {@code name} will be used as the
+The filename is arbitrary. The {@code <string-array>} element's {@code name} will be used as the
 resource ID.</dd>
 
 <dt>compiled resource datatype:</dt>
@@ -164,7 +164,7 @@
       <p>No attributes.</p>
     </dd>
   <dt id="string-array-element"><code>&lt;string-array&gt;</code></dt>
-    <dd>Defines an array of strings. Contains one or more {@code &lt;item>} elements.
+    <dd>Defines an array of strings. Contains one or more {@code <item>} elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
         <dt><code>name</code></dt>
@@ -175,7 +175,7 @@
     </dd>
   <dt id="string-array-item-element"><code>&lt;item&gt;</code></dt>
     <dd>A string, which can include styling tags. The value can be a reference to another
-string resource. Must be a child of a {@code &lt;string-array&gt;} element. Beware that you
+string resource. Must be a child of a {@code <string-array>} element. Beware that you
 must escape apostrophes and
 quotation marks. See <a href="#FormattingAndStyling">Formatting and Styling</a>, below, for
 information about to properly style and format your strings.
@@ -252,13 +252,13 @@
 <p class="note"><strong>Note:</strong> A plurals collection is a simple resource that is
 referenced using the value provided in the {@code name} attribute (not the name of the XML
 file). As such, you can combine plurals resources with other simple resources in the one
-XML file, under one {@code &lt;resources>} element.</p>
+XML file, under one {@code <resources>} element.</p>
 
 <dl class="xml">
 
 <dt>file location:</dt>
 <dd><code>res/values/<em>filename</em>.xml</code><br/>
-The filename is arbitrary. The {@code &lt;plurals>} element's {@code name} will be used as the
+The filename is arbitrary. The {@code <plurals>} element's {@code name} will be used as the
 resource ID.</dd>
 
 <dt>resource reference:</dt>
@@ -291,7 +291,7 @@
     </dd>
   <dt id="plurals-element"><code>&lt;plurals&gt;</code></dt>
     <dd>A collection of strings, of which, one string is provided depending on the amount of
-something. Contains one or more {@code &lt;item>} elements.
+something. Contains one or more {@code <item>} elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
         <dt><code>name</code></dt>
@@ -302,7 +302,7 @@
     </dd>
   <dt id="plurals-item-element"><code>&lt;item&gt;</code></dt>
     <dd>A plural or singular string. The value can be a reference to another
-string resource. Must be a child of a {@code &lt;plurals&gt;} element. Beware that you must
+string resource. Must be a child of a {@code <plurals>} element. Beware that you must
 escape apostrophes and quotation marks. See <a href="#FormattingAndStyling">Formatting and
 Styling</a>, below, for information about to properly style and format your strings.
       <p class="caps">attributes:</p>
@@ -465,9 +465,9 @@
 </pre>
 <p>Supported HTML elements include:</p>
 <ul>
-  <li>{@code &lt;b>} for <b>bold</b> text.</li>
-  <li>{@code &lt;i>} for <i>italic</i> text.</li>
-  <li>{@code &lt;u>} for <u>underline</u> text.</li>
+  <li>{@code <b>} for <b>bold</b> text.</li>
+  <li>{@code <i>} for <i>italic</i> text.</li>
+  <li>{@code <u>} for <u>underline</u> text.</li>
 </ul>
 
 <p>Sometimes you may want to create a styled text resource that is also used as a format
@@ -486,8 +486,8 @@
   &lt;string name="welcome_messages"&gt;Hello, %1$s! You have &amp;lt;b>%2$d new messages&amp;lt;/b>.&lt;/string>
 &lt;/resources&gt;
 </pre>
-<p>In this formatted string, a {@code &lt;b>} element is added. Notice that the opening bracket is
-HTML-escaped, using the {@code &amp;lt;} notation.</p>
+<p>In this formatted string, a {@code <b>} element is added. Notice that the opening bracket is
+HTML-escaped, using the {@code &lt;} notation.</p>
   </li>
   <li>Then format the string as usual, but also call {@link android.text.Html#fromHtml} to
 convert the HTML text into styled text:
diff --git a/docs/html/guide/topics/resources/style-resource.jd b/docs/html/guide/topics/resources/style-resource.jd
index f6252dba..dc3d23f 100644
--- a/docs/html/guide/topics/resources/style-resource.jd
+++ b/docs/html/guide/topics/resources/style-resource.jd
@@ -23,7 +23,7 @@
 <p class="note"><strong>Note:</strong> A style is a simple resource that is referenced
 using the value provided in the {@code name} attribute (not the name of the XML file). As
 such, you can combine style resources with other simple resources in the one XML file,
-under one {@code &lt;resources>} element.</p>
+under one {@code <resources>} element.</p>
 
 <dl class="xml">
 
@@ -61,7 +61,7 @@
       <p>No attributes.</p>
     </dd>
   <dt id="style-element"><code>&lt;style&gt;</code></dt>
-    <dd>Defines a single style. Contains {@code &lt;item&gt;} elements.
+    <dd>Defines a single style. Contains {@code <item>} elements.
       <p class="caps">attributes:</p>
       <dl class="atn-list">
         <dt><code>name</code></dt>
diff --git a/docs/html/guide/topics/search/adding-custom-suggestions.jd b/docs/html/guide/topics/search/adding-custom-suggestions.jd
index 6ebef08..a251ce1 100644
--- a/docs/html/guide/topics/search/adding-custom-suggestions.jd
+++ b/docs/html/guide/topics/search/adding-custom-suggestions.jd
@@ -128,7 +128,7 @@
 <h2 id="CustomSearchableConfiguration">Modifying the searchable configuration</h2>
 
 <p>To add support for custom suggestions, add the {@code android:searchSuggestAuthority} attribute
-to the {@code &lt;searchable&gt;} element in your searchable configuration file. For example:</p>
+to the {@code <searchable>} element in your searchable configuration file. For example:</p>
 
 <pre>
 &lt;?xml version="1.0" encoding="utf-8"?&gt;
@@ -608,7 +608,7 @@
 
 <p>The only scenario in which additional work is necessary is when your content provider demands a
 read permission. In which case, you need to add a special
-{@code &lt;path-permission&gt;} element for the provider to grant Quick Search Box read access to
+{@code <path-permission>} element for the provider to grant Quick Search Box read access to
 your content provider. For example:</p>
 
 <pre>
@@ -622,7 +622,7 @@
 </pre>
 
 <p>In this example, the provider restricts read and write access to the content. The
-{@code &lt;path-permission>} element amends the restriction by granting read access to content
+{@code <path-permission>} element amends the restriction by granting read access to content
 inside the {@code "/search_suggest_query"} path prefix when the {@code
 "android.permission.GLOBAL_SEARCH"} permission exists. This grants access to Quick Search Box
 so that it may query your content provider for suggestions.</p>
diff --git a/docs/html/guide/topics/search/adding-recent-query-suggestions.jd b/docs/html/guide/topics/search/adding-recent-query-suggestions.jd
index e1020dd..8bd180e 100644
--- a/docs/html/guide/topics/search/adding-recent-query-suggestions.jd
+++ b/docs/html/guide/topics/search/adding-recent-query-suggestions.jd
@@ -154,7 +154,7 @@
 
 <p>To configure the system to use your suggestions provider, you need to add
 the {@code android:searchSuggestAuthority} and {@code android:searchSuggestSelection} attributes to
-the {@code &lt;searchable&gt;} element in your searchable configuration file. For example:</p>
+the {@code <searchable>} element in your searchable configuration file. For example:</p>
 
 <pre>
 &lt;?xml version="1.0" encoding="utf-8"?>
diff --git a/docs/html/guide/topics/search/search-dialog.jd b/docs/html/guide/topics/search/search-dialog.jd
index fcaaed36..1af3e5d 100644
--- a/docs/html/guide/topics/search/search-dialog.jd
+++ b/docs/html/guide/topics/search/search-dialog.jd
@@ -158,7 +158,7 @@
 
 <p>The searchable configuration file must include the <a
 href="{@docRoot}guide/topics/search/searchable-config.html#searchable-element">{@code
-&lt;searchable&gt;}</a> element as the root node and specify one
+<searchable>}</a> element as the root node and specify one
 or more attributes. For example:</p>
 
 <pre>
@@ -186,7 +186,7 @@
 
 <p>The <a
 href="{@docRoot}guide/topics/search/searchable-config.html#searchable-element">{@code
-&lt;searchable&gt;}</a> element accepts several other attributes. However, you don't need
+<searchable>}</a> element accepts several other attributes. However, you don't need
 most attributes until you add features such as <a href="#SearchSuggestions">search suggestions</a>
 and <a href="#VoiceSearch">voice search</a>. For detailed information about the searchable
 configuration file, see the <a
@@ -216,15 +216,15 @@
 <p>If you don't have one already, create an {@link android.app.Activity} that will perform
 searches and present results. You don't need to implement the search functionality yet&mdash;just
 create an activity that you can declare in the manifest. Inside the manifest's <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
 element:</p>
 <ol>
   <li>Declare the activity to accept the {@link android.content.Intent#ACTION_SEARCH} intent, in an
 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a>
+<intent-filter>}</a>
 element.</li>
   <li>Specify the searchable configuration to use, in a <a
-href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data&gt;}</a>
+href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a>
 element.</li>
 </ol>
 
@@ -243,17 +243,17 @@
 &lt;/application>
 </pre>
 
-<p>The {@code &lt;meta-data&gt;} element must include the {@code android:name} attribute with a
+<p>The {@code <meta-data>} element must include the {@code android:name} attribute with a
 value of {@code "android.app.searchable"} and the {@code android:resource} attribute with a
 reference to the searchable configuration file (in this example, it
 refers to the {@code res/xml/searchable.xml} file).</p>
 
 <p class="note"><strong>Note:</strong> The <a
 href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter&gt;}</a> does not need a <a
-href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category&gt;}</a> with the
+<intent-filter>}</a> does not need a <a
+href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a> with the
 {@code DEFAULT} value (which you usually see in <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> elements),
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> elements),
 because the system delivers the {@link android.content.Intent#ACTION_SEARCH} intent explicitly to
 your searchable activity, using its component name.</p>
 
@@ -416,10 +416,10 @@
 searchable activity to use for the search dialog in {@code OtherActivity}.</p>
 
 <p>To declare the searchable activity for an activity's search dialog,
-add a <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data&gt;}</a>
+add a <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a>
 element inside the respective activity's <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a> element.
-The <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data&gt;}</a>
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element.
+The <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a>
 element must include the {@code android:value} attribute that specifies the searchable activity's
 class name and the {@code android:name} attribute with a value of {@code
 "android.app.default_searchable"}.</p>
@@ -452,7 +452,7 @@
 </pre>
 
 <p>Because the {@code OtherActivity} now includes a <a
-href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data&gt;}</a>
+href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a>
 element to declare which searchable activity to use for searches, the activity has enabled the
 search dialog.
 While the user is in this activity, the {@link
@@ -464,15 +464,15 @@
 by default, so you don't need to add this declaration to {@code SearchableActivity}.</p>
 
 <p>If you want every activity in your application to provide the search dialog, insert the above <a
-href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data&gt;}</a>
+href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a>
 element as a child of the <a
-href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 element, instead of each <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>. This
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>. This
 way, every activity inherits the value, provides the search dialog, and delivers searches to
 the same searchable activity. (If you have multiple searchable activities, you can override the
 default searchable activity by placing a different <a
-href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data&gt;}</a>
+href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a>
 declaration inside individual activities.)</p>
 
 <p>With the search dialog now enabled for your activities, your application is ready to perform
diff --git a/docs/html/guide/topics/search/searchable-config.jd b/docs/html/guide/topics/search/searchable-config.jd
index 4874bb4..e6c1a0d 100644
--- a/docs/html/guide/topics/search/searchable-config.jd
+++ b/docs/html/guide/topics/search/searchable-config.jd
@@ -72,9 +72,9 @@
       <dt><a name="label"></a><code>android:label</code></dt>
       <dd><em>String resource</em>. (Required.) The name of your application.
 It should be the same as the name applied to the {@code android:label} attribute of your <a
-href="{@docRoot}guide/topics/manifest/activity-element.html#label">{@code &lt;activity&gt;}</a> or
+href="{@docRoot}guide/topics/manifest/activity-element.html#label">{@code <activity>}</a> or
 <a href="{@docRoot}guide/topics/manifest/application-element.html#label">{@code
-&lt;application&gt;}</a> manifest element. This label is only visible to the user when you set
+<application>}</a> manifest element. This label is only visible to the user when you set
 <code>android:includeInGlobalSearch</code> to "true", in which case, this label is used to identify
 your application as a searchable item in the system's search settings.</dd>
 
@@ -136,13 +136,13 @@
     <p>If you have defined a content provider to generate search suggestions, you need to
     define additional attributes that configure communications with the content
     provider. When providing search suggestions, you need some of the following
-    {@code &lt;searchable>} attributes:</p><br/>
+    {@code <searchable>} attributes:</p><br/>
 
       <dl class="atn-list">
       <dt><a name="searchSuggestAuthority"></a><code>android:searchSuggestAuthority</code></dt>
         <dd><em>String</em>. (Required to provide search suggestions.)
         This value must match the authority string provided in the {@code android:authorities}
-attribute of the Android manifest {@code &lt;provider>} element.</dd>
+attribute of the Android manifest {@code <provider>} element.</dd>
 
       <dt><a name="searchSuggestPath"></a><code>android:searchSuggestPath</code></dt>
         <dd><em>String</em>. This path is used as a portion of the suggestions
@@ -189,7 +189,7 @@
     <h4>Quick Search Box attributes</h4>
 
     <p>To make your custom search suggestions available to Quick Search Box, you need some of the
-    following {@code &lt;searchable>} attributes:</p><br/>
+    following {@code <searchable>} attributes:</p><br/>
 
       <dl class="atn-list">
       <dt><a name="includeInGlobalSearch"></a><code>android:includeInGlobalSearch</code></dt>
@@ -219,7 +219,7 @@
     <h4>Voice search attributes</h4>
 
     <p>To enable voice search, you'll need some of the
-    following {@code &lt;searchable>} attributes:</p><br/>
+    following {@code <searchable>} attributes:</p><br/>
 
       <dl class="atn-list">
         <dt><a name="voiceSearchMode"></a><code>android:voiceSearchMode</code></dt>
diff --git a/docs/html/guide/topics/security/permissions.jd b/docs/html/guide/topics/security/permissions.jd
index cfab3c9..6158e40 100644
--- a/docs/html/guide/topics/security/permissions.jd
+++ b/docs/html/guide/topics/security/permissions.jd
@@ -452,7 +452,7 @@
     <dd>Information about how requesting some permissions will implicitly restrict your app
     to devices that include the corresponding hardware or software feature.</dd>
     <dt><a href="{@docRoot}guide/topics/manifest/uses-permission-element.html">{@code
-    &lt;uses-permission>}</a></dt>
+    <uses-permission>}</a></dt>
     <dd>API reference for the manifest tag that declare's your app's required system permissions.
     </dd>
     <dt>{@link android.Manifest.permission}</dt>
diff --git a/docs/html/guide/topics/ui/accessibility/apps.jd b/docs/html/guide/topics/ui/accessibility/apps.jd
index da24d03..567dc5b 100644
--- a/docs/html/guide/topics/ui/accessibility/apps.jd
+++ b/docs/html/guide/topics/ui/accessibility/apps.jd
@@ -357,7 +357,7 @@
 ViewCompat.setAccessibilityDelegate()} method to implement the accessibility methods
 above. For an example of this approach, see the Android Support Library (revision 5 or higher)
 sample {@code AccessibilityDelegateSupportActivity} in
-({@code &lt;sdk&gt;/extras/android/support/v4/samples/Support4Demos/})
+({@code <sdk>/extras/android/support/v4/samples/Support4Demos/})
   </li>
 </ul>
 
@@ -536,7 +536,7 @@
 directly in your custom view class. For another example of this approach, see the Android
 <a href="{@docRoot}tools/support-library/index.html">Support Library</a> (revision 5 or higher)
 sample {@code AccessibilityDelegateSupportActivity} in
-({@code &lt;sdk&gt;/extras/android/support/v4/samples/Support4Demos/}).</p>
+({@code <sdk>/extras/android/support/v4/samples/Support4Demos/}).</p>
 
 <p class="note"><strong>Note:</strong> You may find information on implementing accessibility for
 custom views written prior to Android 4.0 that describes the use of the
diff --git a/docs/html/guide/topics/ui/accessibility/services.jd b/docs/html/guide/topics/ui/accessibility/services.jd
index d69af9f..3ccdbc4 100644
--- a/docs/html/guide/topics/ui/accessibility/services.jd
+++ b/docs/html/guide/topics/ui/accessibility/services.jd
@@ -111,7 +111,7 @@
 android.accessibilityservice.AccessibilityService#setServiceInfo setServiceInfo()} at runtime.
 However, not all configuration options are available using this method.</p>
 
-<p>Beginning with Android 4.0, you can include a {@code &lt;meta-data&gt;} element in your manifest
+<p>Beginning with Android 4.0, you can include a {@code <meta-data>} element in your manifest
 with a reference to a configuration file, which allows you to set the full range of options for
 your accessibility service, as shown in the following example:</p>
 
@@ -125,7 +125,7 @@
 </pre>
 
 <p>This meta-data element refers to an XML file that you create in your application’s resource
-directory ({@code &lt;project_dir&gt;/res/xml/accessibility_service_config.xml}). The following code
+directory ({@code <project_dir>/res/xml/accessibility_service_config.xml}). The following code
 shows example contents for the service configuration file:</p>
 
 <pre>
@@ -445,7 +445,7 @@
 
 <p>The API Demo project contains two samples which can be used as a starting point for generating
 accessibility services
-({@code &lt;sdk&gt;/samples/&lt;platform&gt;/ApiDemos/src/com/example/android/apis/accessibility}):
+({@code <sdk>/samples/<platform>/ApiDemos/src/com/example/android/apis/accessibility}):
 </p>
 
 <ul>
diff --git a/docs/html/guide/topics/ui/actionbar.jd b/docs/html/guide/topics/ui/actionbar.jd
index b2f98ad..c21671f 100644
--- a/docs/html/guide/topics/ui/actionbar.jd
+++ b/docs/html/guide/topics/ui/actionbar.jd
@@ -184,9 +184,9 @@
 <p>By default, the system uses your application icon in the action bar, as specified by the <a
 href="{@docRoot}guide/topics/manifest/application-element.html#icon">{@code icon}</a>
 attribute in the <a href="{@docRoot}guide/topics/manifest/application-element.html">{@code
-&lt;application&gt;}</a> or <a
+<application>}</a> or <a
 href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity&gt;}</a> element. However, if you also specify the <a
+<activity>}</a> element. However, if you also specify the <a
 href="{@docRoot}guide/topics/manifest/application-element.html#logo">{@code logo}</a>
 attribute, then the action bar uses the logo image instead of the icon.</p>
 
@@ -249,7 +249,7 @@
 
 <p>To request that an item appear directly in the action bar
 as an action button, include {@code
-showAsAction="ifRoom"} in the {@code &lt;item&gt;} tag. For example:</p>
+showAsAction="ifRoom"} in the {@code <item>} tag. For example:</p>
 
 <pre>
 &lt;menu xmlns:android="http://schemas.android.com/apk/res/android"
@@ -269,7 +269,7 @@
 <div class="note" id="XmlAttributes">
 <p><strong>Using XML attributes from the support library</strong></p>
 Notice that the {@code showAsAction} attribute above uses a custom namespace defined in the
-{@code &lt;menu>} tag. This is necessary when using any XML attributes defined by the support
+{@code <menu>} tag. This is necessary when using any XML attributes defined by the support
 library, because these attributes do not exist in the Android framework on older devices.
 So you must use your own namespace as a prefix for all attributes defined by the support library.
 </p>
@@ -319,7 +319,7 @@
 <p>When the user presses an action, the system calls your activity's {@link
 android.app.Activity#onOptionsItemSelected(MenuItem) onOptionsItemSelected()} method. Using the
 {@link android.view.MenuItem} passed to this method, you can identify the action by calling {@link
-android.view.MenuItem#getItemId()}. This returns the unique ID provided by the {@code &lt;item&gt;}
+android.view.MenuItem#getItemId()}. This returns the unique ID provided by the {@code <item>}
 tag's {@code id} attribute so you can perform the appropriate action. For example:</p>
 
 <pre>
@@ -373,15 +373,15 @@
 <p>To enable split action bar when using the support library, you must do two things:</p>
 <ol>
   <li>Add {@code uiOptions="splitActionBarWhenNarrow"} to each
-<a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
+<a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
 element or to the
-<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 element. This attribute is understood only by API level 14 and higher (it is ignored
 by older versions).</li>
   <li>To support older versions, add a <a
-  href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data>}</a>
+  href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a>
   element as a child of each
-  <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
+  <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
   element that declares the same value for {@code "android.support.UI_OPTIONS"}.</li>
 </ol>
 
@@ -460,10 +460,10 @@
     <p>Beginning in Android 4.1 (API level 16), you can declare the parent with the <a href=
 "{@docRoot}guide/topics/manifest/activity-element.html#parent">{@code parentActivityName}</a>
 attribute in the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity&gt;}</a> element.</p>
+<activity>}</a> element.</p>
     <p>To support older devices with the support library, also
 include a <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code
-&lt;meta-data&gt;}</a> element that specifies
+<meta-data>}</a> element that specifies
 the parent activity as the value for {@code android.support.PARENT_ACTIVITY}. For example:</p>
 <pre>
 &lt;application ... >
@@ -681,7 +681,7 @@
 and an action provider can display a submenu when pressed.</p>
 
 <p>To declare an action provider, supply the {@code actionViewClass} attribute in the
-menu {@code &lt;item>} tag with a fully-qualified class name for an
+menu {@code <item>} tag with a fully-qualified class name for an
 {@link android.support.v4.view.ActionProvider}.</p>
 
 <p>You can build your own action provider by extending the {@link
@@ -709,7 +709,7 @@
 <h3 id="ShareActionProvider">Using the ShareActionProvider</h3>
 
 <p>To add a "share" action with {@link android.support.v7.widget.ShareActionProvider},
-define the {@code actionProviderClass} for an {@code &lt;item&gt;} tag with
+define the {@code actionProviderClass} for an {@code <item>} tag with
 the {@link android.support.v7.widget.ShareActionProvider} class. For example:</p>
 
 <pre>
@@ -1489,7 +1489,7 @@
 
 
 <p class="caution"><strong>Caution:</strong> Be certain that each theme and style declares a parent
-theme in the {@code &lt;style&gt;} tag, from which it inherits all styles not explicitly declared
+theme in the {@code <style>} tag, from which it inherits all styles not explicitly declared
 by your theme. When modifying the action bar, using a parent theme is important so that you can
 simply override the action bar styles you want to change without re-implementing the styles you
 want to leave alone (such as text size or padding in action items).</p>
diff --git a/docs/html/guide/topics/ui/controls/button.jd b/docs/html/guide/topics/ui/controls/button.jd
index b52c3e9..295044f 100644
--- a/docs/html/guide/topics/ui/controls/button.jd
+++ b/docs/html/guide/topics/ui/controls/button.jd
@@ -73,7 +73,7 @@
 an on-click event.</p>
 
 <p>To define the click event handler for a button, add the {@link
-android.R.attr#onClick android:onClick} attribute to the {@code &lt;Button&gt;} element in your XML
+android.R.attr#onClick android:onClick} attribute to the {@code <Button>} element in your XML
 layout. The value for this attribute must be the name of the method you want to call in response
 to a click event. The {@link android.app.Activity} hosting the layout must then implement the
 corresponding method.</p>
@@ -140,7 +140,7 @@
 <p>You can control exactly how your controls are styled using a theme that you apply to your
 entire application. For instance, to ensure that all devices running Android 4.0 and higher use
 the Holo theme in your app, declare {@code android:theme="@android:style/Theme.Holo"} in your
-manifest's {@code &lt;application&gt;} element. Also read the blog post, <a
+manifest's {@code <application>} element. Also read the blog post, <a
 href="http://android-developers.blogspot.com/2012/01/holo-everywhere.html">Holo Everywhere</a>
 for information about using the Holo theme while supporting older devices.</p>
 
diff --git a/docs/html/guide/topics/ui/controls/spinner.jd b/docs/html/guide/topics/ui/controls/spinner.jd
index d2db7a4..3b8aaad 100644
--- a/docs/html/guide/topics/ui/controls/spinner.jd
+++ b/docs/html/guide/topics/ui/controls/spinner.jd
@@ -27,7 +27,7 @@
 <img src="{@docRoot}images/ui/spinner.png" alt="" />
 
 <p>You can add a spinner to your layout with the {@link android.widget.Spinner} object. You
-should usually do so in your XML layout with a {@code &lt;Spinner&gt;} element. For example:</p>
+should usually do so in your XML layout with a {@code <Spinner>} element. For example:</p>
 
 <pre>
 &lt;Spinner
diff --git a/docs/html/guide/topics/ui/controls/text.jd b/docs/html/guide/topics/ui/controls/text.jd
index c11dc32..f4d72b2a 100644
--- a/docs/html/guide/topics/ui/controls/text.jd
+++ b/docs/html/guide/topics/ui/controls/text.jd
@@ -36,7 +36,7 @@
 (cut, copy, paste) and data look-up via auto-completion.</p>
 
 <p>You can add a text field to you layout with the {@link android.widget.EditText} object. You
-should usually do so in your XML layout with a {@code &lt;EditText&gt;} element.</p>
+should usually do so in your XML layout with a {@code <EditText>} element.</p>
 
 <img src="{@docRoot}images/ui/edittext-noextract.png" alt="" />
 
diff --git a/docs/html/guide/topics/ui/dialogs.jd b/docs/html/guide/topics/ui/dialogs.jd
index 0c6ec84..e4469ea 100644
--- a/docs/html/guide/topics/ui/dialogs.jd
+++ b/docs/html/guide/topics/ui/dialogs.jd
@@ -484,7 +484,7 @@
 instead of using the {@link android.app.Dialog} APIs. Simply create an activity and set its theme to
 {@link android.R.style#Theme_Holo_Dialog Theme.Holo.Dialog}
 in the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity&gt;}</a> manifest element:</p>
+<activity>}</a> manifest element:</p>
 
 <pre>
 &lt;activity android:theme="&#64;android:style/Theme.Holo.Dialog" >
@@ -754,7 +754,7 @@
 <p>To show an activity as a dialog only when on large screens,
 apply the {@link android.R.style#Theme_Holo_DialogWhenLarge Theme.Holo.DialogWhenLarge}
 theme to the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity&gt;}</a> manifest element:</p>
+<activity>}</a> manifest element:</p>
 
 <pre>
 &lt;activity android:theme="&#64;android:style/Theme.Holo.DialogWhenLarge" >
diff --git a/docs/html/guide/topics/ui/menus.jd b/docs/html/guide/topics/ui/menus.jd
index dfcea52..2c6d0b2 100644
--- a/docs/html/guide/topics/ui/menus.jd
+++ b/docs/html/guide/topics/ui/menus.jd
@@ -141,7 +141,7 @@
 element may contain a nested <code>&lt;menu></code> element in order to create a submenu.</dd>
     
   <dt><code>&lt;group></code></dt>
-    <dd>An optional, invisible container for {@code &lt;item&gt;} elements. It allows you to
+    <dd>An optional, invisible container for {@code <item>} elements. It allows you to
 categorize menu items so they share properties such as active state and visibility. For more
 information, see the section about <a href="#groups">Creating Menu Groups</a>.</dd>
 </dl>
@@ -181,8 +181,8 @@
 For information about all the supported attributes, see the <a
 href="{@docRoot}guide/topics/resources/menu-resource.html">Menu Resource</a> document.</p>
 
-<p>You can add a submenu to an item in any menu (except a submenu) by adding a {@code &lt;menu&gt;}
-element as the child of an {@code &lt;item&gt;}. Submenus are useful when your application has a lot
+<p>You can add a submenu to an item in any menu (except a submenu) by adding a {@code <menu>}
+element as the child of an {@code <item>}. Submenus are useful when your application has a lot
 of functions that can be organized into topics, like items in a PC application's menu bar (File,
 Edit, View, etc.). For example:</p>
 
@@ -239,7 +239,7 @@
 the right side of the action bar (or by pressing the device <em>Menu</em> button, if available). To
 enable
 quick access to important actions, you can promote a few items to appear in the action bar by adding
-{@code android:showAsAction="ifRoom"} to the corresponding {@code &lt;item&gt;} elements (see figure
+{@code android:showAsAction="ifRoom"} to the corresponding {@code <item>} elements (see figure
 2). <p>For more information about action items and other action bar behaviors, see the <a
 href="{@docRoot}guide/topics/ui/actionbar.html">Action Bar</a> guide. </p>
 <p class="note"><strong>Note:</strong> Even if you're <em>not</em> developing for Android 3.0 or
@@ -260,7 +260,7 @@
 declare items for the options menu, they are combined in the UI. The activity's items appear
 first, followed by those of each fragment in the order in which each fragment is added to the
 activity. If necessary, you can re-order the menu items with the {@code android:orderInCategory}
-attribute in each {@code &lt;item&gt;} you need to move.</p>
+attribute in each {@code <item>} you need to move.</p>
 
 <p>To specify the options menu for an activity, override {@link
 android.app.Activity#onCreateOptionsMenu(Menu) onCreateOptionsMenu()} (fragments provide their
@@ -833,7 +833,7 @@
 android.view.Menu#setGroupCheckable(int,boolean,boolean) setGroupCheckable()}</li>
 </ul>
 
-<p>You can create a group by nesting {@code &lt;item&gt;} elements inside a {@code &lt;group&gt;}
+<p>You can create a group by nesting {@code <item>} elements inside a {@code <group>}
 element in your menu resource or by specifying a group ID with the {@link
 android.view.Menu#add(int,int,int,int) add()} method.</p>
 
@@ -882,8 +882,8 @@
 each time the state changes.</p>
 
 <p>You can define the checkable behavior for individual menu items using the {@code
-android:checkable} attribute in the {@code &lt;item&gt;} element, or for an entire group with
-the {@code android:checkableBehavior} attribute in the {@code &lt;group&gt;} element. For
+android:checkable} attribute in the {@code <item>} element, or for an entire group with
+the {@code android:checkableBehavior} attribute in the {@code <group>} element. For
 example, all items in this menu group are checkable with a radio button:</p>
 
 <pre>
@@ -909,7 +909,7 @@
 </dl>
 
 <p>You can apply a default checked state to an item using the {@code android:checked} attribute in
-the {@code &lt;item&gt;} element and change it in code with the {@link
+the {@code <item>} element and change it in code with the {@link
 android.view.MenuItem#setChecked(boolean) setChecked()} method.</p>
 
 <p>When a checkable item is selected, the system calls your respective item-selected callback method
diff --git a/docs/html/guide/topics/ui/settings.jd b/docs/html/guide/topics/ui/settings.jd
index 02f1255..89960bb 100644
--- a/docs/html/guide/topics/ui/settings.jd
+++ b/docs/html/guide/topics/ui/settings.jd
@@ -186,7 +186,7 @@
 generally pre-determined, although you can still modify the collection at runtime.</p>
 
 <p>Each {@link android.preference.Preference} subclass can be declared with an XML element that
-matches the class name, such as {@code &lt;CheckBoxPreference>}.</p>
+matches the class name, such as {@code <CheckBoxPreference>}.</p>
 
 <p>You must save the XML file in the {@code res/xml/} directory. Although you can name the file
 anything you want, it's traditionally named {@code preferences.xml}. You usually need only one file,
@@ -197,7 +197,7 @@
 settings, then you need separate XML files for each fragment.</p>
 
 <p>The root node for the XML file must be a {@link android.preference.PreferenceScreen
-&lt;PreferenceScreen&gt;} element. Within this element is where you add each {@link
+<PreferenceScreen>} element. Within this element is where you add each {@link
 android.preference.Preference}. Each child you add within the
 {@link android.preference.PreferenceScreen &lt;PreferenceScreen&gt;} element appears as a single
 item in the list of settings.</p>
@@ -234,7 +234,7 @@
   <p>The only instances in which this attribute is <em>not required</em> is when the preference is a
 {@link android.preference.PreferenceCategory} or {@link android.preference.PreferenceScreen}, or the
 preference specifies an {@link android.content.Intent} to invoke (with an <a
-href="#Intents">{@code &lt;intent&gt;}</a> element) or a {@link android.app.Fragment} to display (with an <a
+href="#Intents">{@code <intent>}</a> element) or a {@link android.app.Fragment} to display (with an <a
 href="{@docRoot}reference/android/preference/Preference.html#attr_android:fragment">{@code
 android:fragment}</a> attribute).</p>
   </dd>
@@ -323,7 +323,7 @@
 
 <img src="{@docRoot}images/ui/settings/settings-subscreen.png" alt="" />
 <p class="img-caption"><strong>Figure 3.</strong> Setting subscreens. The {@code
-&lt;PreferenceScreen>} element
+<PreferenceScreen>} element
 creates an item that, when selected, opens a separate list to display the nested settings.</p>
 
 <p>For example:</p>
@@ -360,8 +360,8 @@
 
 <p>In some cases, you might want a preference item to open a different activity instead of a
 settings screen, such as a web browser to view a web page. To invoke an {@link
-android.content.Intent} when the user selects a preference item, add an {@code &lt;intent&gt;}
-element as a child of the corresponding {@code &lt;Preference&gt;} element.</p>
+android.content.Intent} when the user selects a preference item, add an {@code <intent>}
+element as a child of the corresponding {@code <Preference>} element.</p>
 
 <p>For example, here's how you can use a preference item to open a web page:</p>
 
@@ -577,7 +577,7 @@
 <img src="{@docRoot}images/ui/settings/settings-headers-tablet.png" alt="" />
 <p class="img-caption"><strong>Figure 4.</strong> Two-pane layout with headers. <br/><b>1.</b> The
 headers are defined with an XML headers file. <br/><b>2.</b> Each group of settings is defined by a
-{@link android.preference.PreferenceFragment} that's specified by a {@code &lt;header>} element in
+{@link android.preference.PreferenceFragment} that's specified by a {@code <header>} element in
 the headers file.</p>
 
 <img src="{@docRoot}images/ui/settings/settings-headers-handset.png" alt="" />
@@ -588,8 +588,8 @@
 
 <h3 id="CreateHeaders" style="clear:left">Creating the headers file</h3>
 
-<p>Each group of settings in your list of headers is specified by a single {@code &lt;header>}
-element inside a root {@code &lt;preference-headers>} element. For example:</p>
+<p>Each group of settings in your list of headers is specified by a single {@code <header>}
+element inside a root {@code <preference-headers>} element. For example:</p>
 
 <pre>
 &lt;?xml version="1.0" encoding="utf-8"?>
@@ -611,7 +611,7 @@
 <p>With the {@code android:fragment} attribute, each header declares an instance of {@link
 android.preference.PreferenceFragment} that should open when the user selects the header.</p>
 
-<p>The {@code &lt;extras>} element allows you to pass key-value pairs to the fragment in a {@link
+<p>The {@code <extras>} element allows you to pass key-value pairs to the fragment in a {@link
 android.os.Bundle}. The fragment can retrieve the arguments by calling {@link
 android.app.Fragment#getArguments()}. You might pass arguments to the fragment for a variety of
 reasons, but one good reason is to reuse the same subclass of {@link
@@ -619,7 +619,7 @@
 preferences XML file the fragment should load.</p>
 
 <p>For example, here's a fragment that can be reused for multiple settings groups, when each
-header defines an {@code &lt;extra>} argument with the {@code "settings"} key:</p>
+header defines an {@code <extra>} argument with the {@code "settings"} key:</p>
 
 <pre>
 public static class SettingsFragment extends PreferenceFragment {
@@ -717,7 +717,7 @@
 &lt;/PreferenceScreen>
 </pre>
 
-<p>Because support for {@code &lt;preference-headers>} was added in Android 3.0, the system calls
+<p>Because support for {@code <preference-headers>} was added in Android 3.0, the system calls
 {@link android.preference.PreferenceActivity#onBuildHeaders onBuildHeaders()} in your {@link
 android.preference.PreferenceActivity} only when running on Androd 3.0 or higher. In order to load
 the "legacy" headers file ({@code preference_headers_legacy.xml}), you must check the Android
@@ -747,7 +747,7 @@
 
 <p>The only thing left to do is handle the {@link android.content.Intent} that's passed into the
 activity to identify which preference file to load. So retrieve the intent's action and compare it
-to known action strings that you've used in the preference XML's {@code &lt;intent>} tags:</p>
+to known action strings that you've used in the preference XML's {@code <intent>} tags:</p>
 
 <pre>
 final static String ACTION_PREFS_ONE = "com.example.prefs.PREFS_ONE";
diff --git a/docs/html/guide/topics/ui/themes.jd b/docs/html/guide/topics/ui/themes.jd
index bc1c4f0..f932dbd 100644
--- a/docs/html/guide/topics/ui/themes.jd
+++ b/docs/html/guide/topics/ui/themes.jd
@@ -77,13 +77,13 @@
 directory of your project. The name of the XML file is arbitrary, but it must use the
 {@code .xml} extension and be saved in the {@code res/values/} folder.</p>
 
-<p>The root node of the XML file must be {@code &lt;resources&gt;}.</p>
+<p>The root node of the XML file must be {@code <resources>}.</p>
 
-<p>For each style you want to create, add a {@code &lt;style>} element to the file
+<p>For each style you want to create, add a {@code <style>} element to the file
 with a {@code name} that uniquely identifies the style (this attribute is required).
-Then add an {@code &lt;item>} element for each property of that style, with a
+Then add an {@code <item>} element for each property of that style, with a
 {@code name} that declares the style property and a value to go with it (this attribute
-is required). The value for the {@code &lt;item>} can
+is required). The value for the {@code <item>} can
 be a keyword string, a hex color, a reference to another resource type, or other value
 depending on the style property.
 Here's an example file with a single style:</p>
@@ -100,12 +100,12 @@
 &lt;/resources&gt;
 </pre>
 
-<p>Each child of the {@code &lt;resources>} element is converted into an application resource
-object at compile-time, which can be referenced by the value in the {@code &lt;style>} element's
+<p>Each child of the {@code <resources>} element is converted into an application resource
+object at compile-time, which can be referenced by the value in the {@code <style>} element's
 {@code name} attribute. This example style can be referenced from an XML layout as
 {@code @style/CodeFont} (as demonstrated in the introduction above).</p>
 
-<p>The <code>parent</code> attribute in the {@code &lt;style>} element is optional and
+<p>The <code>parent</code> attribute in the {@code <style>} element is optional and
 specifies the resource ID of another style from which this style should inherit
 properties. You can then override the inherited style properties if you want to.</p>
 
@@ -117,7 +117,7 @@
 
 <h3 id="Inheritance">Inheritance</h3>
 
-<p>The {@code parent} attribute in the {@code &lt;style>} element lets you specify a style
+<p>The {@code parent} attribute in the {@code <style>} element lets you specify a style
 from which your style should inherit properties.
 You can use this to inherit properties from an existing style and
 then define only the properties that you want to change or add. You can
@@ -144,7 +144,7 @@
     &lt;/style&gt;
 </pre>
 
-<p>Notice that there is no {@code parent} attribute in the {@code &lt;style&gt;} tag, but because
+<p>Notice that there is no {@code parent} attribute in the {@code <style>} tag, but because
 the {@code name} attribute begins with the {@code CodeFont} style name (which
 is a style that you have created), this style inherits all style properties from that style. This
 style then overrides the {@code android:textColor} property to make the text red. You can
@@ -170,7 +170,7 @@
 <h3 id="Properties">Style Properties</h3>
 
 <p>Now that you understand how a style is defined, you need to learn what kind
-of style properties&mdash;defined by the {@code &lt;item>} element&mdash;are available.
+of style properties&mdash;defined by the {@code <item>} element&mdash;are available.
 You're probably familiar with some already, such as {@link android.R.attr#layout_width} and
 {@link android.R.attr#textColor}. Of course, there are many more style properties you can use.</p>
 
@@ -184,7 +184,7 @@
 android:inputType}</a>, so where you might normally place the <a
 href="{@docRoot}reference/android/widget/TextView.html#attr_android:inputType">{@code
 android:inputType}</a>
-attribute in an {@code &lt;EditText>} element, like this:</p>
+attribute in an {@code <EditText>} element, like this:</p>
 <pre>
 &lt;EditText
     android:inputType="number"
@@ -226,8 +226,8 @@
 style as a theme.</p>
 
 <p class="note"><strong>Note:</strong> Don't forget to prefix the property names in each
-{@code &lt;item&gt;} element with the <code>android:</code> namespace. For example:
-{@code &lt;item name="android:inputType">}.</p>
+{@code <item>} element with the <code>android:</code> namespace. For example:
+{@code <item name="android:inputType">}.</p>
 
 
 
diff --git a/docs/html/guide/webapps/best-practices.jd b/docs/html/guide/webapps/best-practices.jd
index a13c69da..9e070c6 100644
--- a/docs/html/guide/webapps/best-practices.jd
+++ b/docs/html/guide/webapps/best-practices.jd
@@ -72,7 +72,7 @@
 
 
 <li>Use viewport meta data to properly resize your web page
-  <p>In your document {@code &lt;head&gt;}, you should provide meta data that specifies how you
+  <p>In your document {@code <head>}, you should provide meta data that specifies how you
 want the browser's viewport to render your web page. For example, your viewport meta data can
 specify the height and width for the browser's viewport, the initial web page scale and even the
 target screen density.</p>
@@ -89,7 +89,7 @@
   <p>Because mobile devices typically have a connection speed far slower than a desktop
 computer, you should make your web pages load as fast as possible. One way to speed it up is to
 avoid loading extra files such as stylesheets and script files in the {@code
-&lt;head&gt;}. Instead, provide your CSS and JavaScript directly in the &lt;head&gt; (or
+<head>}. Instead, provide your CSS and JavaScript directly in the &lt;head&gt; (or
 at the end of the &lt;body&gt;, for scripts that you don't need until the page is loaded).
 Alternatively, you should optimize the size and speed of your files by compressing them with tools
 like <a href="http://code.google.com/p/minify/">Minify</a>.</p>
diff --git a/docs/html/guide/webapps/targeting.jd b/docs/html/guide/webapps/targeting.jd
index 7e02340..4a2ea17 100644
--- a/docs/html/guide/webapps/targeting.jd
+++ b/docs/html/guide/webapps/targeting.jd
@@ -78,8 +78,8 @@
 with {@link android.webkit.WebSettings#setUseWideViewPort setUseWideViewPort()}.</p>
 
 <p>You can define properties of the viewport for your web page, such as the width and initial zoom
-level, using the {@code &lt;meta name="viewport" ...>} tag in your document
-{@code &lt;head&gt;}.</p>
+level, using the {@code <meta name="viewport" ...>} tag in your document
+{@code <head>}.</p>
 
 <p>The following syntax shows all of the
 supported viewport properties and the types of values accepted by each one:</p>
@@ -96,7 +96,7 @@
           " /&gt;
 </pre>
 
-<p>For example, the following {@code &lt;meta&gt;} tag specifies that the viewport width
+<p>For example, the following {@code <meta>} tag specifies that the viewport width
 should exactly match the device screen's width and that the ability to zoom should be disabled:</p>
 
 <pre>
diff --git a/docs/html/guide/webapps/webview.jd b/docs/html/guide/webapps/webview.jd
index 9b46b5b..f133b57 100644
--- a/docs/html/guide/webapps/webview.jd
+++ b/docs/html/guide/webapps/webview.jd
@@ -68,7 +68,7 @@
 <h2 id="AddingWebView">Adding a WebView to Your Application</h2>
 
 <p>To add a {@link android.webkit.WebView} to your Application, simply include the {@code
-&lt;WebView&gt;} element in your activity layout. For example, here's a layout file in which the
+<WebView>} element in your activity layout. For example, here's a layout file in which the
 {@link android.webkit.WebView} fills the screen:</p>
 
 <pre>
@@ -171,7 +171,7 @@
 <p class="caution"><strong>Caution:</strong> If you've set your <a
 href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#target">{@code targetSdkVersion}</a>
 to 17 or higher, <strong>you
-must add the {@code &#64;JavascriptInterface} annotation</strong> to any method that you want
+must add the <code>&#64;JavascriptInterface</code> annotation</strong> to any method that you want
 available to your JavaScript (the method must also be public). If you do not provide the
 annotation, the method is not accessible by your web page when running on Android 4.2 or
 higher.</p>
diff --git a/docs/html/ndk/downloads/revision_history.jd b/docs/html/ndk/downloads/revision_history.jd
index a32b814..95bfe7c 100644
--- a/docs/html/ndk/downloads/revision_history.jd
+++ b/docs/html/ndk/downloads/revision_history.jd
@@ -1218,7 +1218,7 @@
                 (<a href="https://android-review.googlesource.com/#/c/46821">Change 46821</a>)</li>
               <li>Modified {@code wchar.h} to not redefine {@code WCHAR_MAX} and
                 {@code WCHAR_MIN}</li>
-              <li>Fixed {@code &lt;inttypes.h&gt;} declaration for pointer-related {@code PRI} and
+              <li>Fixed {@code <inttypes.h>} declaration for pointer-related {@code PRI} and
                 {@code SCN} macros. (<a href="http://b.android.com/57218">Issue 57218</a>)</li>
               <li>Changed the {@code sys/cdefs.h} header so that {@code __WCHAR_TYPE__} is 32-bit
                 for API levels less than 9, which means that {@code wchat_t} is 32-bit for all
@@ -1367,7 +1367,7 @@
             (<a href="http://b.android.com/52909">Issue 52909</a>)</li>
           <li>Fixed a GCC 4.7 segfault.
             (<a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=55245">GCC Issue</a>)</li>
-          <li>Fixed {@code &lt;chrono&gt;} clock resolution and enabled {@code steady_clock}.
+          <li>Fixed {@code <chrono>} clock resolution and enabled {@code steady_clock}.
             (<a href="http://b.android.com/39680">Issue 39680</a>)</li>
           <li>Fixed toolchain to enable {@code _GLIBCXX_HAS_GTHREADS} for GCC 4.7 libstdc++.
             (<a href="http://b.android.com/41770">Issue 41770</a>,
@@ -1387,7 +1387,7 @@
             (<a href="https://android-review.googlesource.com/#/c/52134">Change 52134</a>)</li>
           <li>Fixed Clang 3.1 internal compiler error when using Eigen library.
             (<a href="http://b.android.com/41246">Issue 41246</a>)</li>
-          <li>Fixed Clang 3.1 internal compiler error including {@code &lt;chrono&gt;} in C++11
+          <li>Fixed Clang 3.1 internal compiler error including {@code <chrono>} in C++11
 mode.
             (<a href="http://b.android.com/39600">Issue 39600</a>)</li>
           <li>Fixed Clang 3.1 internal compiler error when generating object code for a method
@@ -1484,7 +1484,7 @@
             (<a href="http://b.android.com/52805">Issue 52805</a>)</li>
           <li>Enabled {@code FUTEX} system call in GNU libstdc++.</li>
           <li>Updated {@code ndk-build} so that it  no longer copies prebuilt static library to
-            a project's {@code obj/local/&lt;abi&gt;/} directory.
+            a project's {@code obj/local/<abi>/} directory.
             (<a href="http://b.android.com/40302">Issue 40302</a>)</li>
           <li>Removed {@code __ARM_ARCH_5*__} from ARM {@code toolchains/*/setup.mk} script.
             (<a href="http://b.android.com/21132">Issue 21132</a>)</li>
@@ -1723,8 +1723,8 @@
                 add this environment variable setting to {@code Application.mk}.</li>
               <li>For standalone builds, add {@code --llvm-version=3.1} to
                 {@code make-standalone-toolchain.sh} and replace {@code CC} and {@code CXX} in your
-                makefile with {@code &lt;tool-path&gt;/bin/clang} and
-                {@code &lt;tool-path&gt;/bin/clang++}. See {@code STANDALONE-TOOLCHAIN.html} for
+                makefile with {@code <tool-path>/bin/clang} and
+                {@code <tool-path>/bin/clang++}. See {@code STANDALONE-TOOLCHAIN.html} for
                 details.</li>
             </ul>
             <p class="note"><strong>Note:</strong> This feature is experimental. Please try it and
@@ -1915,12 +1915,12 @@
               <li>Removed unimplemented functions in {@code malloc.h}.</li>
               <li>Fixed {@code stdint.h} defintion of {@code uint64_t} for ANSI compilers.
               (<a href="http://b.android.com/1952">Issue 1952</a>)</li>
-              <li>Fixed preprocessor macros in {@code &lt;arch&gt;/include/machine/*}.</li>
+              <li>Fixed preprocessor macros in {@code <arch>/include/machine/*}.</li>
               <li>Replaced {@code link.h} for MIPS with new version supporting all platforms.</li>
               <li>Removed {@code linux-unistd.h}</li>
               <li>Move GLibc-specific macros {@code LONG_LONG_MIN}, {@code LONG_LONG_MAX} and
-              {@code ULONG_LONG_MAX} from {@code &lt;pthread.h&gt;} to {@code
-&lt;limits.h&gt;}.</li>
+              {@code ULONG_LONG_MAX} from {@code <pthread.h>} to {@code
+<limits.h>}.</li>
             </ul>
           </li>
           <li>Fixed a buffer overflow in {@code ndk-stack-parser}.</li>
@@ -2177,8 +2177,8 @@
           <li>Changed locations of binaries:
             <ul>
               <li>Moved {@code gdbserver} from
-{@code toolchain/&lt;arch-os-ver&gt;/prebuilt/gdbserver} to
-{@code prebuilt/android-&lt;arch&gt;/gdbserver/gdbserver}.</li>
+{@code toolchain/<arch-os-ver>/prebuilt/gdbserver} to
+{@code prebuilt/android-<arch>/gdbserver/gdbserver}.</li>
               <li>Renamed x86 toolchain prefix from {@code i686-android-linux-} to
 {@code i686-linux-android-}.</li>
               <li>Moved {@code sources/cxx-stl/gnu-libstdc++/include} and {@code lib} to
@@ -2262,7 +2262,7 @@
       <dd>
         <ul>
           <li>Fixed a typo in GAbi++ implementation where the result of {@code
-          dynamic_cast&lt;D&gt;(b)} of base class object {@code b} to derived class {@code D} is
+          dynamic_cast<D>(b)} of base class object {@code b} to derived class {@code D} is
           incorrectly adjusted in the opposite direction from the base class.
           (<a href="http://b.android.com/28721">Issue 28721</a>)
           </li>
diff --git a/docs/html/ndk/guides/abis.jd b/docs/html/ndk/guides/abis.jd
index f4819b2..7b1a7ad 100644
--- a/docs/html/ndk/guides/abis.jd
+++ b/docs/html/ndk/guides/abis.jd
@@ -418,8 +418,8 @@
 /lib/&lt;abi&gt;/lib&lt;name&gt;.so
 </pre>
 
-<p>Here, {@code &lt;abi&gt;} is one of the ABI names listed under <a href="#sa">Supported ABIs</a>,
-and {@code &lt;name&gt;} is the name of the library as you defined it for the {@code LOCAL_MODULE}
+<p>Here, {@code <abi>} is one of the ABI names listed under <a href="#sa">Supported ABIs</a>,
+and {@code <name>} is the name of the library as you defined it for the {@code LOCAL_MODULE}
 variable in the <a href="{@docRoot}ndk/guides/android_mk.html">{@code Android.mk}</a> file. Since
 APK files are just zip files, it is trivial to open them and confirm that the shared native
 libraries are where they belong.</p>
@@ -488,7 +488,7 @@
 
 <p>When it finds the libraries that it's looking for, the package manager
 copies them to <code>/lib/lib&lt;name&gt;.so</code>, under the application's
-{@code data} directory ({@code data/data/&lt;package_name&gt;/lib/}).</p>
+{@code data} directory ({@code data/data/<package_name>/lib/}).</p>
 
 <p>If there is no shared-object file at all, the application builds and installs, but crashes at
 runtime.</p>
diff --git a/docs/html/ndk/guides/android_mk.jd b/docs/html/ndk/guides/android_mk.jd
index 47fefc3..1416d13 100644
--- a/docs/html/ndk/guides/android_mk.jd
+++ b/docs/html/ndk/guides/android_mk.jd
@@ -774,7 +774,7 @@
 
 <h3 id="npfm">NDK-provided function macros</h2>
 <p>This section explains GNU Make function macros that the NDK provides. Use
-{@code $(call &lt;function&gt;)} to evaluate them; they return textual information.</p>
+{@code $(call <function>)} to evaluate them; they return textual information.</p>
 
 <h4>my-dir</h4>
 
@@ -870,6 +870,6 @@
 $(call import-module,&lt;name&gt;)
 </pre>
 
-<p>In this example, the build system looks for the module tagged {@code &lt;name&gt;} in the list of
+<p>In this example, the build system looks for the module tagged {@code <name>} in the list of
 directories referenced that your {@code NDK_MODULE_PATH} environment variable references, and
 includes its {@code Android.mk} file automatically for you.</p>
\ No newline at end of file
diff --git a/docs/html/ndk/guides/application_mk.jd b/docs/html/ndk/guides/application_mk.jd
index 1294687..e669f3f 100644
--- a/docs/html/ndk/guides/application_mk.jd
+++ b/docs/html/ndk/guides/application_mk.jd
@@ -30,7 +30,7 @@
 $NDK/apps/&lt;myapp&gt;/Application.mk
 </pre>
 
-<p>Here, {@code &lt;myapp&gt;} is a short name used to describe your app to the NDK build system. It
+<p>Here, {@code <myapp>} is a short name used to describe your app to the NDK build system. It
 doesn't actually go into your generated shared libraries or your final packages.</p>
 
 <h2 id="var">Variables</h2>
@@ -39,7 +39,7 @@
 uses this information to place stripped-down versions of the generated JNI shared libraries
 into a specific location known to the APK-generating tools.</p>
 
-<p>If you place your {@code Application.mk} file under {@code $NDK/apps/&lt;myapp&gt;/}, you must
+<p>If you place your {@code Application.mk} file under {@code $NDK/apps/<myapp>/}, you must
 define this variable. If you place it under {@code $PROJECT/jni/}, it is optional.
 
 <h4>APP_OPTIM</h4>
@@ -54,7 +54,7 @@
 preventing you from inspecting them. Also, code re-ordering can make it more difficult to step
 through the code; stack traces may not be reliable.</p>
 
-<p>Declaring {@code android:debuggable} in your application manifest's {@code &lt;application&gt;}
+<p>Declaring {@code android:debuggable} in your application manifest's {@code <application>}
 tag will cause this variable to default to {@code debug} instead of {@code release}. Override this
 default value by setting {@code APP_OPTIM} to {@code release}.</p>
 
diff --git a/docs/html/ndk/guides/concepts.jd b/docs/html/ndk/guides/concepts.jd
index 0601f21..9f2b22a 100644
--- a/docs/html/ndk/guides/concepts.jd
+++ b/docs/html/ndk/guides/concepts.jd
@@ -222,10 +222,10 @@
 callbacks from blocking your main thread.</li>
 </ul>
 
-<p>The {@code &lt;ndk_root&gt;/sources/android/native_app_glue/android_native_app_glue.c} source is
+<p>The {@code <ndk_root>/sources/android/native_app_glue/android_native_app_glue.c} source is
 also available, allowing you to modify the implementation.</p>
 <p>For more information on how to use this static library, examine the native-activity sample
-application and its documentation. Further reading is also available in the comments in the {@code &lt;ndk_root&gt;/sources/android/native_app_glue/android_native_app_glue.h} file.</p>
+application and its documentation. Further reading is also available in the comments in the {@code <ndk_root>/sources/android/native_app_glue/android_native_app_glue.h} file.</p>
 
 <h3 id="na">Using the native_activity.h interface</h3>
 
@@ -277,13 +277,13 @@
 <a href="{@docRoot}ndk/reference/struct_a_native_activity.html">{@code ANativeActivity}</a>
 structure, which contains function pointers to the various callback implementations that you need
 to write.
-Set the applicable callback function pointers in {@code ANativeActivity-&gt;callbacks} to the
+Set the applicable callback function pointers in {@code ANativeActivity->callbacks} to the
 implementations of your callbacks.</li>
 
-<li>Set the {@code ANativeActivity-&gt;instance} field to the address of any instance of specific
+<li>Set the {@code ANativeActivity->instance} field to the address of any instance of specific
 data that you want to use.</li>
 <li>Implement anything else that you want your activity to do upon starting.</li>
-<li>Implement the rest of the callbacks that you set in {@code ANativeActivity-&gt;callbacks}. For
+<li>Implement the rest of the callbacks that you set in {@code ANativeActivity->callbacks}. For
 more information on when the callbacks are called, see
 <a href="{@docRoot}training/basics/activity-lifecycle/index.html">Managing the Activity
 Lifecycle</a>.
diff --git a/docs/html/ndk/guides/cpp-support.jd b/docs/html/ndk/guides/cpp-support.jd
index 0074b80..21df6af 100644
--- a/docs/html/ndk/guides/cpp-support.jd
+++ b/docs/html/ndk/guides/cpp-support.jd
@@ -188,7 +188,7 @@
 
 <h4>atomic support</h4>
 
-<p>If you include {@code &lt;atomic&gt;}, it's likely that you also need {@code libatomic}.
+<p>If you include {@code <atomic>}, it's likely that you also need {@code libatomic}.
 If you are using {@code ndk-build}, add the following line:</p>
 
 <pre>
diff --git a/docs/html/ndk/guides/cpu-features.jd b/docs/html/ndk/guides/cpu-features.jd
index b031909..3323efd 100644
--- a/docs/html/ndk/guides/cpu-features.jd
+++ b/docs/html/ndk/guides/cpu-features.jd
@@ -29,7 +29,7 @@
 </pre>
 </li>
 
-<li>In your source code, include the {@code &lt;cpu-features.h&gt;} header file.</li>
+<li>In your source code, include the {@code <cpu-features.h>} header file.</li>
 
 <li>At the end of your <a href="{@docRoot}ndk/guides/android_mk.html">{@code Android.mk}</a> file,
 insert an instruction to import the {@code android/cpufeatures} module. For example:
diff --git a/docs/html/ndk/guides/ndk-build.jd b/docs/html/ndk/guides/ndk-build.jd
index 18ca2d8..e8f6fc5 100644
--- a/docs/html/ndk/guides/ndk-build.jd
+++ b/docs/html/ndk/guides/ndk-build.jd
@@ -77,11 +77,11 @@
   <dt>{@code NDK_HOST_32BIT=1}</dt>
   <dd>Always use the toolchain in 32-bit mode (see <a href="#6432">64-bit and 32-bit
   Toolchains</a>).</dd>
-  <dt>{@code NDK_APPLICATION_MK=&lt;file&gt;}</dt>
+  <dt>{@code NDK_APPLICATION_MK=<file>}</dt>
   <dd>Build, using a specific <code>Application.mk</code> file pointed to by the
   {@code NDK_APPLICATION_MK} variable.</dd>
-  <dt>{@code -C &lt;project&gt;}</dt>
-  <dd>Build the native code for the project path located at {@code &lt;project&gt;}. Useful if you
+  <dt>{@code -C <project>}</dt>
+  <dd>Build the native code for the project path located at {@code <project>}. Useful if you
   don't want to {@code cd} to it in your terminal.</dd>
 </dl>
 
@@ -159,8 +159,8 @@
 
 <h2 id="6432">64-Bit and 32-Bit Toolchains</h2>
 <p>Some toolchains come with both 64-bit and 32-bit versions. For example,
-directories {@code &lt;ndk&gt;/toolchain/&lt;name&gt;/prebuilt/} and
-{@code &lt;ndk&gt;/prebuilt/} may contain both {@code linux-x86} and
+directories {@code <ndk>/toolchain/<name>/prebuilt/} and
+{@code <ndk>/prebuilt/} may contain both {@code linux-x86} and
 {@code linux-x86_64} folders for Linux tools in 32-bit and 64-bit modes,
 respectively. The ndk-build script automatically chooses a 64-bit version of
 the toolchain if the host OS supports it. You can force the use of a 32-bit
@@ -182,7 +182,7 @@
 $ ndk-build
 </pre>
 
-<p>You can override other host prebuilt tools in {@code $NDK/prebuilt/&lt;OS&gt;/bin/}
+<p>You can override other host prebuilt tools in {@code $NDK/prebuilt/<OS>/bin/}
 with the following environment variables: </p>
 
 <pre class="no-pretty-print">
diff --git a/docs/html/ndk/guides/ndk-gdb.jd b/docs/html/ndk/guides/ndk-gdb.jd
index b15e67e..5e2b751 100644
--- a/docs/html/ndk/guides/ndk-gdb.jd
+++ b/docs/html/ndk/guides/ndk-gdb.jd
@@ -22,9 +22,9 @@
 
 <ul>
 <li>Build your app using the {@code ndk-build} script. The {@code ndk-gdb} script
-does not support using the legacy {@code make APP=&lt;name&gt;} method to build.</p></li>
+does not support using the legacy {@code make APP=<name>} method to build.</p></li>
 <li>Enable app debugging in your {@code AndroidManifest.xml} file by including an
-{@code &lt;application&gt;} element that sets the {@code android:debuggable} attribute to {@code
+{@code <application>} element that sets the {@code android:debuggable} attribute to {@code
 true}.</li>
 <li>Build your app to run on Android 2.2 (Android API level 8) or higher.</li>
 <li>Debug on a device or emulator running Android 2.2 or higher. For debugging purposes, the target
@@ -59,7 +59,7 @@
 <p>Next, {@code ndk-gdb} displays a normal GDB prompt.</p>
 
 <p>You interact with {@code ndk-gdb} in the same way as you would with GNU GDB. For example, you can
-use {@code b &lt;location&gt;} to set breakpoints, and {@code c} (for "continue") to
+use {@code b <location>} to set breakpoints, and {@code c} (for "continue") to
 resume execution. For a comprehensive list of commands, see the
 <a href="http://www.gnu.org/software/gdb/">GDB manual.</a></p>
 
@@ -78,7 +78,7 @@
 
 <p>By default, {@code ndk-gdb} searches for an already-running application process, and displays an
 error if it doesn't find one. You can, however, use the {@code --start} or
-{@code --launch=&lt;name&gt;} option to automatically start your activity before the debugging
+{@code --launch=<name>} option to automatically start your activity before the debugging
 session. For more information, see <a href="#opt">Options</a>.</p>
 
 
@@ -117,13 +117,13 @@
 explicitly launch the application on the target device before the debugging session.</p></td>
 
 <p>Starting {@code ndk-gdb} with this option specified launches the first launchable activity listed
-in your application manifest. Use {@code --launch=&lt;name&gt;} to start the next launchable
+in your application manifest. Use {@code --launch=<name>} to start the next launchable
 activity. To dump the list of launchable activities, run {@code --launch-list} from the command
 line.</p>
 </tr>
 
 <tr>
-<td>{@code --launch=&lt;name&gt;}</td>
+<td>{@code --launch=<name>}</td>
 <td><p>This option is similar to {@code --start}, except that it allows you to start a specific
  activity from your application. This feature is only useful if your manifest defines multiple
  launchable activities.</p></td>
@@ -136,20 +136,20 @@
 </tr>
 
 <tr>
-<td>{@code --project=&lt;path&gt;}</td>
+<td>{@code --project=<path>}</td>
 <td>This option specifies the app project directory. It is useful if you want to launch the
  script without first having to change to the project directory.</p></td>
 </tr>
 
 <tr>
-<td>{@code --port=&lt;port&gt;}</td>
+<td>{@code --port=<port>}</td>
 <td> <p>By default, {@code ndk-gdb} uses local TCP port 5039 to communicate with the app it
  is debugging on the target device. Using a different port allows you to natively debug programs
  running on different devices or emulators connected to the same host machine.</p></td>
 </tr>
 
 <tr>
-<td>{@code --adb=&lt;file&gt;}</td>
+<td>{@code --adb=<file>}</td>
 <td><p>This option specifies the <a href="{@docRoot}tools/help/adb.html">adb</a>
 tool executable. It is only necessary if you have not set your path to include that executable.</p>
 </td>
@@ -159,7 +159,7 @@
 <td>
 <li>{@code -d}</li>
 <li>{@code -e}</li>
-<li>{@code -s &lt;serial&gt;}</li></td>
+<li>{@code -s <serial>}</li></td>
 <td><p>These flags are similar to the adb commands with the same names. Set these flags if you have
 several devices or emulators connected to your host machine. Their meanings are as follows:</p>
 <dl>
@@ -167,8 +167,8 @@
    <dd>Connect to a single physical device.</dd>
    <dt>{@code -e}</dt>
    <dd>Connect to a single emulator device.</dd>
-   <dt>{@code -s &lt;serial&gt;}</dt>
-   <dd>Connect to a specific device or emulator. Here, {@code &lt;serial&gt;} is the device's name
+   <dt>{@code -s <serial>}</dt>
+   <dd>Connect to a specific device or emulator. Here, {@code <serial>} is the device's name
    as listed by the {@code adb devices} command.</dd>
 </dl>
 
@@ -178,11 +178,11 @@
 
 <tr>
 <td>
-<li>{@code --exec=&lt;file&gt;}</li>
-<li>{@code -x &lt;file&gt;}</li>
+<li>{@code --exec=<file>}</li>
+<li>{@code -x <file>}</li>
 </td>
 <td><p>This option tells {@code ndk-gdb} to run the GDB initialization commands found in
-{@code &lt;file&gt;} after connecting to the process it is debugging. This is a useful feature if
+{@code <file>} after connecting to the process it is debugging. This is a useful feature if
 you want to do something repeatedly, such as setting up a list of breakpoints, and then resuming
 execution automatically.</p></td>
 </tr>
@@ -200,7 +200,7 @@
 </tr>
 
 <tr>
-<td>{@code --gnumake-flag=&lt;flag&gt;}</td>
+<td>{@code --gnumake-flag=<flag>}</td>
 <td><p>This option is an extra flag (or flags) to pass to the
 {@code ndk-build} system when
 querying it for project information. You can use multiple instances of this option in the
diff --git a/docs/html/ndk/guides/ndk-stack.jd b/docs/html/ndk/guides/ndk-stack.jd
index 46146cb..45d433c 100644
--- a/docs/html/ndk/guides/ndk-stack.jd
+++ b/docs/html/ndk/guides/ndk-stack.jd
@@ -14,7 +14,7 @@
 <p>The {@code ndk-stack} tool allows you to filter stack traces as they appear in the
 output of <a href="{@docRoot}tools/help/logcat.html">{@code adb logcat}</a>. It also replaces any
 address inside a shared library with the corresponding
-{@code &lt;source-file&gt;:&lt;line-number&gt;} values from your source code, making issues easier
+{@code <source-file>:<line-number>} values from your source code, making issues easier
 to pinpoint.</p>
 
 <p>For example, it translates something like:</p>
@@ -57,7 +57,7 @@
 <h2>Usage</h2>
 <p>To use {@code ndk-stack}, you first need a directory containing symbolic versions of your app's
 shared libraries. If you use the NDK build system ({@code ndk-build}), these shared-library
-files reside under {@code $PROJECT_PATH/obj/local/&lt;abi&gt;}, where {@code &lt;abi&gt;} represents
+files reside under {@code $PROJECT_PATH/obj/local/<abi>}, where {@code <abi>} represents
 your device's ABI. By default, the system uses the {@code armeabi} ABI.</p>
 
 <p>There are two ways to use the tool. You can feed the logcat text as direct input to the program.
diff --git a/docs/html/ndk/guides/prebuilts.jd b/docs/html/ndk/guides/prebuilts.jd
index 52eb437..4cb1819 100644
--- a/docs/html/ndk/guides/prebuilts.jd
+++ b/docs/html/ndk/guides/prebuilts.jd
@@ -58,7 +58,7 @@
 <p>In this example, the name of the module is the same as that of the prebuilt library.</p>
 
 <p>The build system places a copy of your prebuilt shared library into {@code $PROJECT/obj/local},
-and another copy, stripped of debug information, into {@code $PROJECT/libs/&lt;abi&gt;}. Here,
+and another copy, stripped of debug information, into {@code $PROJECT/libs/<abi>}. Here,
 {@code $PROJECT} is the root directory of your project.</p>
 
 <h2 id="rp">Referencing the Prebuilt Library from Other Modules</h2>
@@ -111,7 +111,7 @@
 <h2 id="dp">Debugging Prebuilt Libraries</h2>
 <p>We recommend that you provide prebuilt shared libraries containing debug symbols. The NDK build
 system always strips the symbols from the version of the library that it installs into
-{@code $PROJECT/libs/&lt;abi&gt;/}, but you can use the debug version for debugging with
+{@code $PROJECT/libs/<abi>/}, but you can use the debug version for debugging with
 {@code ndk-gdb}.</p>
 
 <h2 id="sa">Selecting ABIs for Prebuilt Libraries</h2>
diff --git a/docs/html/ndk/guides/setup.jd b/docs/html/ndk/guides/setup.jd
index 81a33c0..8d4334e 100644
--- a/docs/html/ndk/guides/setup.jd
+++ b/docs/html/ndk/guides/setup.jd
@@ -61,7 +61,7 @@
 <p>To confirm that you have installed the NDK, set it up correctly, and properly configured Eclipse,
 follow these steps:</p>
 <ol type="1">
-<li>Import the hello-jni sample from {@code &lt;ndk&gt;/samples/}, as you would any other Android
+<li>Import the hello-jni sample from {@code <ndk>/samples/}, as you would any other Android
 project.</li>
 <li>In the <i>Project Explorer</i> pane, right-click the project name (<i>HelloJni</i>). A
 context menu appears.</li>
diff --git a/docs/html/ndk/guides/stable_apis.jd b/docs/html/ndk/guides/stable_apis.jd
index cad02ac..c38e684 100644
--- a/docs/html/ndk/guides/stable_apis.jd
+++ b/docs/html/ndk/guides/stable_apis.jd
@@ -54,7 +54,7 @@
 the C and C++ libraries, see <a href="#a3">Android API level 3</a>.</p>
 
 <p>The NDK often provides new headers and libraries for new Android releases. These files reside
-under {@code $NDK/platforms/android-&lt;level&gt;/&lt;abi&gt;/usr/include}. When the NDK does not
+under {@code $NDK/platforms/android-<level>/<abi>/usr/include}. When the NDK does not
 have a specific new group of headers and libraries for an Android API level, it means that
 an app targeting that level should use the most recently released NDK assets. For example,
 there was no new release of NDK headers or libraries for Android API levels 6 and 7. Therefore,
@@ -154,7 +154,7 @@
 
 <h4>Android-specific log support</h4>
 
-<p>{@code &lt;android/log.h&gt;} contains various definitions that an app can use to send log
+<p>{@code <android/log.h>} contains various definitions that an app can use to send log
 messages to the kernel from native code. For more information about these definitions, see the
 comments in {@code $NDK/platforms/android-3/arch-arm/usr/include/android/log.h}, where {@code $NDK}
 is the root of your NDK installation.</p>
@@ -214,7 +214,7 @@
 
 <p>Additionally, you must put a
 <a href="http://developer.android.com/guide/topics/manifest/uses-feature-element.html">{@code
-&lt;uses-feature&gt;}</a> tag in your manifest file to indicate the version of
+<uses-feature>}</a> tag in your manifest file to indicate the version of
 <a href="http://developer.android.com/guide/topics/graphics/opengl.html#manifest">OpenGL ES</a>
 that your application requires.</p>
 
@@ -234,7 +234,7 @@
 images and above.</p>
 
 <h4>OpenGL ES 2.0 library:</h4>
-<p>The standard OpenGL ES 2.0 headers {@code &lt;GLES2/gl2.h&gt;} and {@code &lt;GLES2/gl2ext.h&gt;}
+<p>The standard OpenGL ES 2.0 headers {@code <GLES2/gl2.h>} and {@code <GLES2/gl2ext.h>}
 contain the declarations needed for performing OpenGL ES 2.0 rendering calls from native code.
 These rendering calls provide the ability to use the GLSL language to define and use vertex and
 fragment shaders.</p>
@@ -255,9 +255,9 @@
 
 <p>Additionally, you must put a
 <a href="http://developer.android.com/guide/topics/manifest/uses-feature-element.html">{@code
-&lt;uses-feature&gt;}</a> tag in your manifest file to indicate which version of OpenGL ES your
+<uses-feature>}</a> tag in your manifest file to indicate which version of OpenGL ES your
 application requires. For more information about the OpenGL ES settings for
-{@code &lt;uses-feature&gt;}, see
+{@code <uses-feature>}, see
 <a href="http://developer.android.com/guide/topics/graphics/opengl.html#manifest">OpenGL ES</a>.</p>
 
 <p>The hello-gl2 sample application provies a basic example of how to use OpenGL ES 2.0 with the
@@ -296,7 +296,7 @@
 <li>Call {@code AndroidBitmap_unlockPixels()} to unlock the buffer.</li>
 </ol>
 
-<p>To use {@code jnigraphics}, include the {@code &lt;bitmap.h&gt;} header in your source code, and
+<p>To use {@code jnigraphics}, include the {@code <bitmap.h>} header in your source code, and
 link against {@code jnigraphics} by including the following line in your
 <a href="{@docRoot}ndk/guides/android_mk.html">{@code Android.mk}</a> file:</p>
 
@@ -368,19 +368,19 @@
 
 <p>This release provides the following native headers:</p>
 <ul>
-<li>{@code &lt;native_activity.h&gt;}</li>
-<li>{@code &lt;looper.h&gt;}</li>
-<li>{@code &lt;input.h&gt;}</li>
-<li>{@code &lt;keycodes.h&gt;}</li>
-<li>{@code &lt;sensor.h&gt;}</li>
-<li>{@code &lt;rect.h&gt;}</li>
-<li>{@code &lt;window.h&gt;}</li>
-<li>{@code &lt;native_window.h&gt;}</li>
-<li>{@code &lt;native_window_jni.h&gt;}</li>
-<li>{@code &lt;configuration.h&gt;}</li>
-<li>{@code &lt;asset_manager.h&gt;}</li>
-<li>{@code &lt;storage_manager.h&gt;}</li>
-<li>{@code &lt;obb.h&gt;}</li>
+<li>{@code <native_activity.h>}</li>
+<li>{@code <looper.h>}</li>
+<li>{@code <input.h>}</li>
+<li>{@code <keycodes.h>}</li>
+<li>{@code <sensor.h>}</li>
+<li>{@code <rect.h>}</li>
+<li>{@code <window.h>}</li>
+<li>{@code <native_window.h>}</li>
+<li>{@code <native_window_jni.h>}</li>
+<li>{@code <configuration.h>}</li>
+<li>{@code <asset_manager.h>}</li>
+<li>{@code <storage_manager.h>}</li>
+<li>{@code <obb.h>}</li>
 </ul>
 
 <p>For more information about these headers, see the
@@ -403,8 +403,8 @@
 
 <h4>OpenMAX AL</h4>
 <p>Android native multimedia handling is based on Khronos Group OpenMAX AL 1.0.1 API.</p>
-<p>The standard OpenMAX AL headers {@code &lt;OMXAL/OpenMAXAL.h&gt;} and
-{@code &lt;OMXAL/OpenMAXAL_Platform.h&gt;} contain the declarations necessary for performing
+<p>The standard OpenMAX AL headers {@code <OMXAL/OpenMAXAL.h>} and
+{@code <OMXAL/OpenMAXAL_Platform.h>} contain the declarations necessary for performing
 multimedia output from the native side of Android.</p>
 
 <p>The NDK distribution of OpenMAX AL also provides Android-specific extensions. For information
@@ -448,9 +448,9 @@
 
 <p>Additionally, you must put a
 <a href="http://developer.android.com/guide/topics/manifest/uses-feature-element.html">{@code
-&lt;uses-feature&gt;}</a> tag in your manifest file to indicate which version of OpenGL ES your
+<uses-feature>}</a> tag in your manifest file to indicate which version of OpenGL ES your
 application requires. For more information about the OpenGL ES settings for
-{@code &lt;uses-feature&gt;}, see
+{@code <uses-feature>}, see
 <a href="http://developer.android.com/guide/topics/graphics/opengl.html#manifest">OpenGL ES</a>.</p>
 
 <p>The gles3jni sample application provides a basic example of how to use OpenGL ES 3.0 with the
@@ -487,9 +487,9 @@
 
 <p>Additionally, you must put a
 <a href="http://developer.android.com/guide/topics/manifest/uses-feature-element.html">{@code
-&lt;uses-feature&gt;}</a> tag in your manifest file to indicate which version of OpenGL ES your
+<uses-feature>}</a> tag in your manifest file to indicate which version of OpenGL ES your
 application requires. For more information about the OpenGL ES settings for
-{@code &lt;uses-feature&gt;}, see
+{@code <uses-feature>}, see
 <a href="http://developer.android.com/guide/topics/graphics/opengl.html#manifest">OpenGL ES</a>.</p>
 
 <p>The gles3jni sample application provides a basic example of how to use OpenGL ES 3.1 with the
diff --git a/docs/html/ndk/guides/standalone_toolchain.jd b/docs/html/ndk/guides/standalone_toolchain.jd
index 3b6f7f1..aec7073 100644
--- a/docs/html/ndk/guides/standalone_toolchain.jd
+++ b/docs/html/ndk/guides/standalone_toolchain.jd
@@ -43,27 +43,27 @@
   </tr>
   <tr>
     <td>ARM-based</td>
-    <td>{@code arm-linux-androideabi-&lt;gcc-version&gt;}</td>
+    <td>{@code arm-linux-androideabi-<gcc-version>}</td>
   </tr>
   <tr>
     <td>x86-based</td>
-    <td>{@code x86-&lt;gcc-version&gt;}</td>
+    <td>{@code x86-<gcc-version>}</td>
   </tr>
   <tr>
     <td>MIPS-based</td>
-    <td>{@code mipsel-linux-android-&lt;gcc-version&gt;}</td>
+    <td>{@code mipsel-linux-android-<gcc-version>}</td>
   </tr>
   <tr>
     <td>ARM64-based</td>
-    <td>{@code aarch64-linux-android-&lt;gcc-version&gt;}</td>
+    <td>{@code aarch64-linux-android-<gcc-version>}</td>
   </tr>
   <tr>
     <td>X86-64-based</td>
-    <td>{@code x86_64-&lt;gcc-version&gt;}</td>
+    <td>{@code x86_64-<gcc-version>}</td>
   </tr>
   <tr>
     <td>MIPS64-based</td>
-    <td>{@code mips64el-linux-android--&lt;gcc-version&gt;}</td>
+    <td>{@code mips64el-linux-android--<gcc-version>}</td>
   </tr>
 </table>
 
@@ -184,7 +184,7 @@
 you can install them in any location, or even move them if you need to.</p>
 
 <p>By default, the build system uses the 32-bit, ARM-based GCC 4.8 toolchain. You can specify a
-different value, however, by specifying {@code --arch=&lt;toolchain&gt;} as an option.
+different value, however, by specifying {@code --arch=<toolchain>} as an option.
 Table 3 shows the values to use for other toolchains:
 
 <p class="table-caption" id="table3">
@@ -216,8 +216,8 @@
   </tr>
 </table>
 
-<p>Alternatively, you can use the {@code --toolchain=&lt;toolchain&gt;} option. Table 4 shows the
-values you can specify for {@code &lt;toolchain&gt;}:</p>
+<p>Alternatively, you can use the {@code --toolchain=<toolchain>} option. Table 4 shows the
+values you can specify for {@code <toolchain>}:</p>
 
 <p class="table-caption" id="table4">
   <strong>Table 4.</strong> Toolchains and corresponding values, using {@code --toolchain}.</p>
@@ -296,7 +296,7 @@
 line.</p>
 
 <p class="note"><strong>Note: </strong>Instead of specifying a specific version, you can also
-use {@code &lt;version&gt;}, which defaults
+use {@code <version>}, which defaults
 to the highest available version of Clang.</p>
 
 <p>By default, the build system builds for a 32-bit host toolchain. You can specify a 64-bit
@@ -344,7 +344,7 @@
 </pre>
 
 <p>Note that if you omit the {@code -install-dir} option, the {@code make-standalone-toolchain.sh}
-shell script creates a tarball in {@code tmp/ndk/&lt;toolchain-name&gt;.tar.bz2}. This tarball makes
+shell script creates a tarball in {@code tmp/ndk/<toolchain-name>.tar.bz2}. This tarball makes
 it easy to archive, as well as to redistribute the binaries.</p>
 
 <p>This standalone toolchain provides an additional benefit, as well, in that it contains a working
@@ -354,7 +354,7 @@
 
 <h2 id="wwc">Working with Clang</h2>
 <p>You can install Clang binaries in the standalone installation by using the
-{@code --llvm-version=&lt;version&gt;} option. {@code &lt;version&gt;} is a LLVM/Clang version
+{@code --llvm-version=<version>} option. {@code <version>} is a LLVM/Clang version
 number, such as {@code 3.5} or {@code 3.6}. For example:
 
 <pre class="no-pretty-print">
@@ -368,7 +368,7 @@
 assembler, linker, headers, libraries, and C++ STL implementation.</p>
 
 <p>This operation also installs two scripts, named {@code clang} and {@code clang++}, under
-{@code &lt;install-dir&gt;/bin/@}. These scripts invoke the real {@code clang} binary with default
+{@code <install-dir>/bin/@}. These scripts invoke the real {@code clang} binary with default
 target architecture flags. In other words, they should work without any modification, and you should
 be able to use them in your own builds by just setting the {@code CC} and {@code CXX} environment
 variables to point to them.</p>
@@ -534,7 +534,7 @@
 <h3>C++ STL support</h3>
 <p>The standalone toolchain includes a copy of a C++ Standard Template Library implementation. This
 implementation is either for GNU libstdc++, STLport, or libc++, depending on what you specify for the
-{@code --stl=&lt;name&gt;} option described previously. To use this implementation of STL, you need
+{@code --stl=<name>} option described previously. To use this implementation of STL, you need
 to link your project with the proper library:</p>
 
 <ul>
diff --git a/docs/html/ndk/samples/sample_na.jd b/docs/html/ndk/samples/sample_na.jd
index a706be5..0966dd8 100644
--- a/docs/html/ndk/samples/sample_na.jd
+++ b/docs/html/ndk/samples/sample_na.jd
@@ -92,7 +92,7 @@
 {@code .so} extension. For example, the actual file name for the
 {@code log} library is {@code liblog.so}.</li>
 <li>The library resides in the following directory, NDK root:
-{@code &lt;ndk&gt;/platforms/android-&lt;sdk_version&gt;/arch-&lt;abi&gt;/usr/lib/}.</li>
+{@code <ndk>/platforms/android-<sdk_version>/arch-<abi>/usr/lib/}.</li>
 </ul>
 
 <pre class="no-pretty-print">
diff --git a/docs/html/preview/api-overview.jd b/docs/html/preview/api-overview.jd
index 55829d3..599dc1e 100644
--- a/docs/html/preview/api-overview.jd
+++ b/docs/html/preview/api-overview.jd
@@ -149,8 +149,8 @@
 <pre class="no-prettyprint">
 adb -e emu finger touch &lt;finger_id&gt;
 </pre>
-<p>On Windows, you may have to run {@code telnet 127.0.0.1 &lt;emulator-id&gt;} followed by
-  {@code finger touch &lt;finger_id&gt;}.
+<p>On Windows, you may have to run {@code telnet 127.0.0.1 <emulator-id>} followed by
+  {@code finger touch <finger_id>}.
 </p>
 </li>
 </ol>
@@ -210,7 +210,7 @@
 
 <p>For each activity that you want to expose to
 {@link android.service.chooser.ChooserTargetService}, add a
-{@code &lt;meta-data&gt;} element with the name
+{@code <meta-data>} element with the name
 {@code "android.service.chooser.chooser_target_service"} in your app manifest.
 </p>
 
diff --git a/docs/html/tools/adk/adk2.jd b/docs/html/tools/adk/adk2.jd
index d69125a..052ec48 100644
--- a/docs/html/tools/adk/adk2.jd
+++ b/docs/html/tools/adk/adk2.jd
@@ -303,7 +303,7 @@
   <li>Start the ADK 2012 IDE and choose <strong>File > Preferences</strong>.</li>
   <li>In the <strong>Preferences</strong> dialog, make a note of the <strong>Sketchbook
 location</strong> directory.</li>
-  <li>Copy the {@code &lt;adk-source-download&gt;/adk2012/board/library/ADK2} directory and its
+  <li>Copy the {@code <adk-source-download>/adk2012/board/library/ADK2} directory and its
 contents into your {@code sketchbook/libraries/} directory, so that you create a {@code
 sketchbook/libraries/ADK2} directory.</li>
   <li>Stop and restart the <strong>ADK 2012 IDE</strong>.</li>
@@ -339,7 +339,7 @@
 <ol>
   <li><a href="#src-download">Download</a> the ADK 2012 source code files.</li>
   <li>In a terminal window, navigate to {@code
-&lt;adk-source-download&gt;/adk2012/board/MakefileBasedBuild}.</li>
+<adk-source-download>/adk2012/board/MakefileBasedBuild}.</li>
   <li>Execute the following command and follow the instructions:
     <pre>$> ./setup</pre>
   </li>
diff --git a/docs/html/tools/devices/emulator.jd b/docs/html/tools/devices/emulator.jd
index 5bdd4e2..1e70562 100644
--- a/docs/html/tools/devices/emulator.jd
+++ b/docs/html/tools/devices/emulator.jd
@@ -393,7 +393,7 @@
   <li>Start the Android SDK Manager, select <strong>Extras</strong> and then select <strong>Intel
 Hardware Accelerated Execution Manager</strong>.</li>
   <li>After the download completes, execute {@code
-&lt;sdk&gt;/extras/intel/Hardware_Accelerated_Execution_Manager/IntelHAXM.exe}.</li>
+<sdk>/extras/intel/Hardware_Accelerated_Execution_Manager/IntelHAXM.exe}.</li>
   <li>Follow the on-screen instructions to complete installation.</li>
   <li>After installation completes, confirm that the virtualization driver is operating correctly by
 opening a command prompt window and running the following command:
@@ -449,7 +449,7 @@
   <li>Start the Android SDK Manager, select <strong>Extras</strong> and then select <strong>Intel
 Hardware Accelerated Execution Manager</strong>.
   <li>After the download completes, execute
-    {@code &lt;sdk&gt;/extras/intel/Hardware_Accelerated_Execution_Manager/IntelHAXM.dmg}.</li>
+    {@code <sdk>/extras/intel/Hardware_Accelerated_Execution_Manager/IntelHAXM.dmg}.</li>
   <li>Double click the <strong>IntelHAXM.mpkg</strong> icon to begin installation.</li>
   <li>Follow the on-screen instructions to complete installation.</li>
   <li>After installation completes, confirm that the new kernel extension is operating correctly by
diff --git a/docs/html/tools/devices/managing-avds.jd b/docs/html/tools/devices/managing-avds.jd
index 4ca8588..fb680aa 100644
--- a/docs/html/tools/devices/managing-avds.jd
+++ b/docs/html/tools/devices/managing-avds.jd
@@ -56,7 +56,7 @@
   you have designed your app to support. For instance, you should create an AVD for each
   API level equal to and higher than the minimum version you've specified in your manifest
   <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html" style="white-space: nowrap;"
-  >{@code &lt;uses-sdk>}</a> tag.</p>
+  >{@code <uses-sdk>}</a> tag.</p>
 
   <p>To create an AVD based on an existing device definition:</p>
 
diff --git a/docs/html/tools/extras/oem-usb.jd b/docs/html/tools/extras/oem-usb.jd
index 6d449ee..eed8a5e 100644
--- a/docs/html/tools/extras/oem-usb.jd
+++ b/docs/html/tools/extras/oem-usb.jd
@@ -86,7 +86,7 @@
   <li>Select <strong>Browse my computer for driver software</strong> and click
     <strong>Next</strong>.</li>
   <li>Click <strong>Browse</strong> and locate the USB driver folder. (The Google USB
-Driver is located in {@code &lt;sdk&gt;\extras\google\usb_driver\}.)</li>
+Driver is located in {@code <sdk>\extras\google\usb_driver\}.)</li>
   <li>Click <strong>Next</strong> to install the driver.</li>
 </ol>
 
@@ -109,7 +109,7 @@
 <strong>Search removable media</strong>; and check <strong>Include this location in the
 search</strong>.</li>
   <li>Click <strong>Browse</strong> and locate the USB driver folder. (The Google USB
-Driver is located in {@code &lt;sdk&gt;\extras\google\usb_driver\}.)</li>
+Driver is located in {@code <sdk>\extras\google\usb_driver\}.)</li>
   <li>Click <strong>Next</strong> to upgrade the driver.</li>
 </ol>
 
@@ -127,7 +127,7 @@
   <li>Select <strong>I don't have the disk. Show me other options</strong>.</li>
   <li>Select <strong>Browse my computer for driver software</strong>.</li>
   <li>Click <strong>Browse</strong> and locate the USB driver folder. (The Google USB
-Driver is located in {@code &lt;sdk&gt;\extras\google\usb_driver\}.) As long as you specified the
+Driver is located in {@code <sdk>\extras\google\usb_driver\}.) As long as you specified the
 exact location of the 
     installation package, you may leave <strong>Include subfolders</strong> checked or
   unchecked&mdash;it doesn't matter.</li>
@@ -152,7 +152,7 @@
   search for the driver
     software. Select <strong>Browse my computer for driver software</strong>.</li>
   <li>Click <strong>Browse</strong> and locate the USB driver folder. (The Google USB
-Driver is located in {@code &lt;sdk&gt;\extras\google\usb_driver\}.) As long as you specified the
+Driver is located in {@code <sdk>\extras\google\usb_driver\}.) As long as you specified the
 exact location of the
     installation package, you may leave <strong>Include subfolders</strong> checked or
     unchecked&mdash;it doesn't matter.</li>
diff --git a/docs/html/tools/help/adb.jd b/docs/html/tools/help/adb.jd
index 2faff4f..bcd949a 100644
--- a/docs/html/tools/help/adb.jd
+++ b/docs/html/tools/help/adb.jd
@@ -36,7 +36,7 @@
   <li>A daemon, which runs as a background process on each emulator or device instance. </li>
 </ul>
 
-<p>You can find the {@code adb} tool in {@code &lt;sdk&gt;/platform-tools/}.</p>
+<p>You can find the {@code adb} tool in {@code <sdk>/platform-tools/}.</p>
 
 <p>When you start an adb client, the client first checks whether there is an adb server
 process already running. If there isn't, it starts the server process. When the server starts,
diff --git a/docs/html/tools/help/desktop-head-unit.jd b/docs/html/tools/help/desktop-head-unit.jd
index 981979c..a2b71e6 100644
--- a/docs/html/tools/help/desktop-head-unit.jd
+++ b/docs/html/tools/help/desktop-head-unit.jd
@@ -400,7 +400,7 @@
 
 <ol>
 <li>Install the Android Media Browser simulator
-({@code &lt;sdk&gt;/extras/google/simulators/media-browser-simulator.apk}) on
+({@code <sdk>/extras/google/simulators/media-browser-simulator.apk}) on
 the test device. You can do this using
 the <a href="{@docRoot}tools/help/adb.html#move">adb</a> command line tool.</li>
 <li>Enable <a href="{@docRoot}tools/device.html#developer-device-options">
@@ -417,7 +417,7 @@
 
 <ol>
 <li>Install the Android Messaging simulator
-  ({@code &lt;sdk&gt;/extras/google/simulators/messaging-simulator.apk})
+  ({@code <sdk>/extras/google/simulators/messaging-simulator.apk})
 on the test device. You can do this using the
 <a href="{@docRoot}tools/help/adb.html#move">adb</a> command line tool.</li>
 <li>Enable the simulator to read notifications posted on the system:
diff --git a/docs/html/tools/help/emulator.jd b/docs/html/tools/help/emulator.jd
index fa101e1..366b3bd 100644
--- a/docs/html/tools/help/emulator.jd
+++ b/docs/html/tools/help/emulator.jd
@@ -166,7 +166,7 @@
 </td></tr>
 <tr>
   <td><code>-data&nbsp;&lt;filepath&gt;</code></td>
-  <td>Use {@code &lt;filepath&gt;} as the working user-data disk image. </td>
+  <td>Use {@code <filepath>} as the working user-data disk image. </td>
   <td>Optionally, you can specify a path relative to the current working directory.
   If <code>-data</code> is not used, the emulator looks for a file named {@code userdata-qemu.img}
   in the storage area of the AVD being used (see <code>-avd</code>).
@@ -426,7 +426,7 @@
   <td>Enable KVM acceleration of the emulator virtual machine.</td>
   <td>This option is only effective when your system is set up to use
   <a href="{@docRoot}tools/devices/emulator.html#vm-linux">KVM-based VM acceleration</a>.
-  You can optionally specify a memory size ({@code -m &lt;size&gt;}) for the VM, which should match
+  You can optionally specify a memory size ({@code -m <size>}) for the VM, which should match
   your emulator's memory size:</p>
   {@code -qemu -m 512 -enable-kvm}<br>
   {@code -qemu -m 1024 -enable-kvm}
diff --git a/docs/html/tools/help/jobb.jd b/docs/html/tools/help/jobb.jd
index 97f0942..ae60223 100644
--- a/docs/html/tools/help/jobb.jd
+++ b/docs/html/tools/help/jobb.jd
@@ -44,31 +44,31 @@
     <th>Description</th>
   </tr>
   <tr>
-    <td>{@code -d &lt;directory&gt;}</td>
+    <td>{@code -d <directory>}</td>
     <td>Set the input directory for creating an OBB file, or the output directory when extracting
       ({@code -dump}) an existing file. When creating an OBB file, the contents of the specified
       directory and all its sub-directories are included in the OBB file system.
     </td>
   </tr>
   <tr>
-    <td>{@code -o &lt;filename&gt;}</td>
+    <td>{@code -o <filename>}</td>
     <td>Specify the filename for the OBB file. This parameter is required when
     creating an OBB and extracting (dumping) its contents.</td>
   </tr>
   <tr>
-    <td>{@code -pn &lt;package&gt;}</td>
+    <td>{@code -pn <package>}</td>
     <td>Specify the package name for the application that mounts the OBB file, which corresponds
     to the {@code package} value specified in your application's manifest. This parameter is
     required when creating an OBB file.</td>
   </tr>
   <tr>
-    <td>{@code -pv &lt;version&gt;}</td>
+    <td>{@code -pv <version>}</td>
     <td>Set the minimum version for the application that can mount the OBB file, which corresponds
     to the {@code android:versionCode} value in your application's manifest. This parameter is
     required when creating an OBB file.</td>
   </tr>
   <tr>
-    <td>{@code -k &lt;key&gt;}</td>
+    <td>{@code -k <key>}</td>
     <td>Specify a password for encrypting a new OBB file or decrypting an existing, encypted
       OBB file.</td>
   </tr>
@@ -80,13 +80,13 @@
       overlay OBB file replace files that have the same path.</td>
   </tr>
   <tr>
-    <td style="white-space: nowrap">{@code -dump &lt;filename&gt;}</td>
+    <td style="white-space: nowrap">{@code -dump <filename>}</td>
     <td><p>Extract the contents of the specified OBB file. When using this option, you must also
-      specify the output directory for the contents using the {@code -d &lt;directory&gt;}
+      specify the output directory for the contents using the {@code -d <directory>}
       parameter.</p>
 
       <p class="note"><strong>Note:</strong> When dumping an existing OBB file, you can omit the
-      {@code -d &lt;directory&gt;} parameter to get a listing of the directories inside the file,
+      {@code -d <directory>} parameter to get a listing of the directories inside the file,
       without extracting the contents.</p>
     </td>
   </tr>
diff --git a/docs/html/tools/help/lint.jd b/docs/html/tools/help/lint.jd
index 0f52689..98a5652 100644
--- a/docs/html/tools/help/lint.jd
+++ b/docs/html/tools/help/lint.jd
@@ -154,7 +154,7 @@
 <td rowspan="4">Help</td>
 <td><nobr><code>--help</code></nobr></td>
 <td>List the command-line arguments supported by the {@code lint} tool.</td>
-<td>Use {@code --help &lt;topic&gt;} to see help information for a specific topic, such as "suppress".</td>
+<td>Use {@code --help <topic>} to see help information for a specific topic, such as "suppress".</td>
 </tr>
 
 <tr>
@@ -166,7 +166,7 @@
 <tr>
 <td><nobr><code>--show</code></nobr></td>
 <td>List the ID and verbose description for issues that can be checked by {@code lint}</td>
-<td>Use {@code --show &lt;ids&gt;} to see descriptions for a specific list of {@code lint} issue IDs.</td>
+<td>Use {@code --show <ids>} to see descriptions for a specific list of {@code lint} issue IDs.</td>
 </tr>
 
 <tr>
diff --git a/docs/html/tools/help/shell.jd b/docs/html/tools/help/shell.jd
index 417c871..41bef22 100644
--- a/docs/html/tools/help/shell.jd
+++ b/docs/html/tools/help/shell.jd
@@ -72,20 +72,20 @@
 <td><code>
 start [options] &lt;INTENT>
 </code></td>
-<td>Start an {@link android.app.Activity} specified by {@code &lt;INTENT>}. <p>See the
+<td>Start an {@link android.app.Activity} specified by {@code <INTENT>}. <p>See the
 <a href="#IntentSpec">Specification for &lt;INTENT> arguments</a>.
 <p>Options are:
 <ul>
     <li>{@code -D}: Enable debugging.
     <li>{@code -W}: Wait for launch to complete.
-    <li>{@code --start-profiler &lt;FILE>}: Start profiler and send results to {@code &lt;FILE>}.
-    <li>{@code -P &lt;FILE>}: Like <code>--start-profiler</code>,
+    <li>{@code --start-profiler <FILE>}: Start profiler and send results to {@code <FILE>}.
+    <li>{@code -P <FILE>}: Like <code>--start-profiler</code>,
         but profiling stops when the app goes idle.
-    <li>{@code -R}: Repeat the activity launch {@code &lt;COUNT>} times.  Prior to each repeat,
+    <li>{@code -R}: Repeat the activity launch {@code <COUNT>} times.  Prior to each repeat,
         the top activity will be finished.
     <li>{@code -S}: Force stop the target app before starting the activity.
     <li>{@code --opengl-trace}: Enable tracing of OpenGL functions.
-    <li>{@code --user &lt;USER_ID> | current}: Specify which user to run as; if not
+    <li>{@code --user <USER_ID> | current}: Specify which user to run as; if not
         specified, then run as the current user.
 </ul>
 </td>
@@ -95,11 +95,11 @@
 <td><code>
 startservice [options] &lt;INTENT>
 </code></td>
-<td>Start the {@link android.app.Service} specified by {@code &lt;INTENT>}. <p>See the
+<td>Start the {@link android.app.Service} specified by {@code <INTENT>}. <p>See the
 <a href="#IntentSpec">Specification for &lt;INTENT> arguments</a>.
 <p>Options are:
 <ul>
-    <li>{@code --user &lt;USER_ID> | current}: Specify which user to run as; if not
+    <li>{@code --user <USER_ID> | current}: Specify which user to run as; if not
         specified, then run as the current user.
 </ul>
 </td>
@@ -109,7 +109,7 @@
 <td><code>
 force-stop &lt;PACKAGE>
 </code></td>
-<td>Force stop everything associated with {@code &lt;PACKAGE>} (the app's package name).
+<td>Force stop everything associated with {@code <PACKAGE>} (the app's package name).
 </td>
 </tr>
 
@@ -117,13 +117,13 @@
 <td><code>
 kill  [options] &lt;PACKAGE>
 </code></td>
-<td> Kill all processes associated with {@code &lt;PACKAGE>}
+<td> Kill all processes associated with {@code <PACKAGE>}
   (the app's package name).  This command kills only
   processes that are safe to kill and that will not impact the user
   experience.
   <p>Options are:
   <ul>
-      <li>{@code --user &lt;USER_ID> | all | current}: Specify user whose processes to kill;
+      <li>{@code --user <USER_ID> | all | current}: Specify user whose processes to kill;
         all users if not specified.
   </ul>
 </td>
@@ -145,7 +145,7 @@
 <a href="#IntentSpec">Specification for &lt;INTENT> arguments</a>.
 <p>Options are:
 <ul>
-    <li>{@code [--user &lt;USER_ID> | all | current]}: Specify which user to send to; if not
+    <li>{@code [--user <USER_ID> | all | current]}: Specify which user to send to; if not
         specified then send to all users.
 </ul>
 </td>
@@ -156,24 +156,24 @@
 instrument [options] &lt;COMPONENT>
 </code></td>
 <td>Start monitoring with an {@link android.app.Instrumentation} instance.
-  Typically the target {@code &lt;COMPONENT>}
-  is the form {@code &lt;TEST_PACKAGE>/&lt;RUNNER_CLASS>}.  <p>Options are:
+  Typically the target {@code <COMPONENT>}
+  is the form {@code <TEST_PACKAGE>/<RUNNER_CLASS>}.  <p>Options are:
 <ul>
     <li>{@code -r}: Print raw results (otherwise decode
-        {@code &lt;REPORT_KEY_STREAMRESULT>}).  Use with
+        {@code <REPORT_KEY_STREAMRESULT>}).  Use with
         {@code [-e perf true]} to generate raw output for performance measurements.
 
-    <li>{@code -e &lt;NAME> &lt;VALUE>}: Set argument {@code &lt;NAME>} to {@code &lt;VALUE>}.
+    <li>{@code -e <NAME> <VALUE>}: Set argument {@code <NAME>} to {@code <VALUE>}.
         For test runners a common form is {@code
-        -e &lt;testrunner_flag> &lt;value>[,&lt;value>...]}.
+        -e <testrunner_flag> <value>[,<value>...]}.
 
-    <li>{@code -p &lt;FILE>}: Write profiling data to {@code &lt;FILE>}.
+    <li>{@code -p <FILE>}: Write profiling data to {@code <FILE>}.
 
     <li>{@code -w}: Wait for instrumentation to finish before returning.  Required for
         test runners.
 
     <li>{@code --no-window-animation}: Turn off window animations while running.
-    <li>{@code --user &lt;USER_ID> | current}: Specify which user instrumentation runs in;
+    <li>{@code --user <USER_ID> | current}: Specify which user instrumentation runs in;
         current user if not specified.
 </ul>
 
@@ -184,7 +184,7 @@
 <td><code>
 profile start &lt;PROCESS> &lt;FILE>
 </code></td>
-<td>Start profiler on {@code &lt;PROCESS>}, write results to {@code &lt;FILE>}.
+<td>Start profiler on {@code <PROCESS>}, write results to {@code <FILE>}.
 </td>
 </tr>
 
@@ -192,7 +192,7 @@
 <td><code>
 profile stop &lt;PROCESS>
 </code></td>
-<td>Stop profiler on {@code &lt;PROCESS>}.
+<td>Stop profiler on {@code <PROCESS>}.
 </td>
 </tr>
 
@@ -200,9 +200,9 @@
 <td style="white-space:nowrap"><code>
 dumpheap [options] &lt;PROCESS> &lt;FILE>
 </code></td>
-<td>Dump the heap of {@code &lt;PROCESS>}, write to {@code &lt;FILE>}. <p>Options are:
+<td>Dump the heap of {@code <PROCESS>}, write to {@code <FILE>}. <p>Options are:
 <ul>
-    <li>{@code --user [&lt;USER_ID>|current]}: When supplying a process name,
+    <li>{@code --user [<USER_ID>|current]}: When supplying a process name,
         specify user of process to dump; uses current user if not specified.
     <li>{@code -n}: Dump native heap instead of managed heap.
 </ul>
@@ -213,7 +213,7 @@
 <td><code>
 set-debug-app [options] &lt;PACKAGE>
 </code></td>
-<td>Set application {@code &lt;PACKAGE>} to debug.  <p>Options are:
+<td>Set application {@code <PACKAGE>} to debug.  <p>Options are:
 <ul>
     <li>{@code -w}: Wait for debugger when application starts.
     <li>{@code --persistent}: Retain this value.
@@ -245,7 +245,7 @@
 screen-compat [on|off] &lt;PACKAGE>
 </code></td>
 <td>Control <a href="{@docRoot}guide/practices/screen-compat-mode.html">screen
-compatibility</a> mode of {@code &lt;PACKAGE>}.</p>
+compatibility</a> mode of {@code <PACKAGE>}.</p>
 </td>
 </tr>
 
@@ -300,65 +300,65 @@
 
 <div class="intents" style="display:none">
 
-<p>For activity manager commands that take a {@code &lt;INTENT>} argument, you can
+<p>For activity manager commands that take a {@code <INTENT>} argument, you can
 specify the intent with the following options:</p>
 
 <dl>
-  <dt>{@code -a &lt;ACTION>}</dt>
+  <dt>{@code -a <ACTION>}</dt>
       <dd>Specify the intent action, such as "android.intent.action.VIEW".
       You can declare this only once.
 
-  <dt>{@code -d &lt;DATA_URI>}</dt>
+  <dt>{@code -d <DATA_URI>}</dt>
       <dd>Specify the intent data URI, such as "content://contacts/people/1".
       You can declare this only once.
 
-  <dt>{@code -t &lt;MIME_TYPE>}</dt>
+  <dt>{@code -t <MIME_TYPE>}</dt>
       <dd>Specify the intent MIME type, such as "image/png".
       You can declare this only once.
 
-  <dt>{@code -c &lt;CATEGORY>}</dt>
+  <dt>{@code -c <CATEGORY>}</dt>
       <dd>Specify an intent category, such as "android.intent.category.APP_CONTACTS".
 
-  <dt>{@code -n &lt;COMPONENT>}</dt>
+  <dt>{@code -n <COMPONENT>}</dt>
       <dd>Specify the component name with package name prefix to create an explicit intent, such
       as "com.example.app/.ExampleActivity".
 
-  <dt>{@code -f &lt;FLAGS>}</dt>
+  <dt>{@code -f <FLAGS>}</dt>
       <dd>Add flags to the intent, as supported by {@link
         android.content.Intent#setFlags setFlags()}.
 
-  <dt>{@code --esn &lt;EXTRA_KEY>}</dt>
+  <dt>{@code --esn <EXTRA_KEY>}</dt>
       <dd>Add a null extra. This option is not supported for URI intents.
 
-  <dt>{@code -e|--es &lt;EXTRA_KEY> &lt;EXTRA_STRING_VALUE>}</dt>
+  <dt>{@code -e|--es <EXTRA_KEY> <EXTRA_STRING_VALUE>}</dt>
       <dd>Add string data as a key-value pair.
 
-  <dt>{@code --ez &lt;EXTRA_KEY> &lt;EXTRA_BOOLEAN_VALUE>}</dt>
+  <dt>{@code --ez <EXTRA_KEY> <EXTRA_BOOLEAN_VALUE>}</dt>
       <dd>Add boolean data as a key-value pair.
 
-  <dt>{@code --ei &lt;EXTRA_KEY> &lt;EXTRA_INT_VALUE>}</dt>
+  <dt>{@code --ei <EXTRA_KEY> <EXTRA_INT_VALUE>}</dt>
       <dd>Add integer data as a key-value pair.
 
-  <dt>{@code --el &lt;EXTRA_KEY> &lt;EXTRA_LONG_VALUE>}</dt>
+  <dt>{@code --el <EXTRA_KEY> <EXTRA_LONG_VALUE>}</dt>
       <dd>Add long data as a key-value pair.
 
-  <dt>{@code --ef &lt;EXTRA_KEY> &lt;EXTRA_FLOAT_VALUE>}</dt>
+  <dt>{@code --ef <EXTRA_KEY> <EXTRA_FLOAT_VALUE>}</dt>
       <dd>Add float data as a key-value pair.
 
-  <dt>{@code --eu &lt;EXTRA_KEY> &lt;EXTRA_URI_VALUE>}</dt>
+  <dt>{@code --eu <EXTRA_KEY> <EXTRA_URI_VALUE>}</dt>
       <dd>Add URI data as a key-value pair.
 
-  <dt>{@code --ecn &lt;EXTRA_KEY> &lt;EXTRA_COMPONENT_NAME_VALUE>}</dt>
+  <dt>{@code --ecn <EXTRA_KEY> <EXTRA_COMPONENT_NAME_VALUE>}</dt>
       <dd>Add a component name, which is converted and passed as
       a {@link android.content.ComponentName} object.
 
-  <dt>{@code --eia &lt;EXTRA_KEY> &lt;EXTRA_INT_VALUE>[,&lt;EXTRA_INT_VALUE...]}</dt>
+  <dt>{@code --eia <EXTRA_KEY> <EXTRA_INT_VALUE>[,<EXTRA_INT_VALUE...]}</dt>
       <dd>Add an array of integers.
 
-  <dt>{@code --ela &lt;EXTRA_KEY> &lt;EXTRA_LONG_VALUE>[,&lt;EXTRA_LONG_VALUE...]}</dt>
+  <dt>{@code --ela <EXTRA_KEY> <EXTRA_LONG_VALUE>[,<EXTRA_LONG_VALUE...]}</dt>
       <dd>Add an array of longs.
 
-  <dt>{@code --efa &lt;EXTRA_KEY> &lt;EXTRA_FLOAT_VALUE>[,&lt;EXTRA_FLOAT_VALUE...]}</dt>
+  <dt>{@code --efa <EXTRA_KEY> <EXTRA_FLOAT_VALUE>[,<EXTRA_FLOAT_VALUE...]}</dt>
       <dd>Add an array of floats.
 
   <dt>{@code --grant-read-uri-permission}</dt>
@@ -430,7 +430,7 @@
   <dt>{@code --selector}</dt>
       <dd>Requires the use of {@code -d} and {@code -t} options to set the intent data and type.
 
-  <dt>{@code &lt;URI> &lt;COMPONENT> &lt;PACKAGE>}</dt>
+  <dt>{@code <URI> <COMPONENT> <PACKAGE>}</dt>
       <dd>You can directly specify a URI, package name, and component name when not qualified
       by one of the above options. When an argument is unqualified, the tool assumes the argument
       is a URI if it contains a ":" (colon); it assumes the argument is a component name if it
@@ -475,7 +475,7 @@
 list packages [options] &lt;FILTER>
 </code></td>
 <td>Prints all packages, optionally only
-  those whose package name contains the text in {@code &lt;FILTER>}.  <p>Options:
+  those whose package name contains the text in {@code <FILTER>}.  <p>Options:
 <ul>
     <li>{@code -f}: See their associated file.
     <li>{@code -d}: Filter to only show disabled packages.
@@ -484,7 +484,7 @@
     <li>{@code -3}: Filter to only show third party packages.
     <li>{@code -i}: See the installer for the packages.
     <li>{@code -u}: Also include uninstalled packages.
-    <li>{@code --user &lt;USER_ID>}: The user space to query.
+    <li>{@code --user <USER_ID>}: The user space to query.
 </ul>
 </td>
 </tr>
@@ -502,7 +502,7 @@
 list permissions [options] &lt;GROUP>
 </code></td>
 <td>Prints all known permissions, optionally only
-  those in {@code &lt;GROUP>}.  <p>Options:
+  those in {@code <GROUP>}.  <p>Options:
 <ul>
     <li>{@code -g}: Organize by group.
     <li>{@code -f}: Print all information.
@@ -520,7 +520,7 @@
 <td>List all test packages.  <p>Options:
   <ul>
     <li>{@code -f}: List the APK file for the test package.
-    <li>{@code &lt;TARGET_PACKAGE>}: List test packages for only this app.
+    <li>{@code <TARGET_PACKAGE>}: List test packages for only this app.
   </ul>
 </td>
 </tr>
@@ -553,7 +553,7 @@
 <td><code>
 path &lt;PACKAGE>
 </code></td>
-<td>Print the path to the APK of the given {@code &lt;PACKAGE>}.
+<td>Print the path to the APK of the given {@code <PACKAGE>}.
 </td>
 </tr>
 
@@ -561,12 +561,12 @@
 <td><code>
 install [options]  &lt;PATH>
 </code></td>
-<td>Installs a package (specified by {@code &lt;PATH>}) to the system.  <p>Options:
+<td>Installs a package (specified by {@code <PATH>}) to the system.  <p>Options:
   <ul>
     <li>{@code -l}: Install the package with forward lock.
     <li>{@code -r}: Reinstall an exisiting app, keeping its data.
     <li>{@code -t}: Allow test APKs to be installed.
-    <li>{@code -i &lt;INSTALLER_PACKAGE_NAME>}: Specify the installer package name.
+    <li>{@code -i <INSTALLER_PACKAGE_NAME>}: Specify the installer package name.
     <li>{@code -s}: Install package on the shared mass storage (such as sdcard).
     <li>{@code -f}: Install package on the internal system memory.
     <li>{@code -d}: Allow version code downgrade.
@@ -615,7 +615,7 @@
 </code></td>
 <td><p>Options:
   <ul>
-    <li>{@code --user &lt;USER_ID>}: The user to disable.
+    <li>{@code --user <USER_ID>}: The user to disable.
   </ul>
 </td>
 </tr>
@@ -688,7 +688,7 @@
 <td><code>
 create-user &lt;USER_NAME>
 </code></td>
-<td>Create a new user with the given {@code &lt;USER_NAME>},
+<td>Create a new user with the given {@code <USER_NAME>},
   printing the new user identifier of the user.
 </td>
 </tr>
@@ -697,7 +697,7 @@
 <td><code>
 remove-user &lt;USER_ID>
 </code></td>
-<td>Remove the user with the given {@code &lt;USER_IDENTIFIER>},
+<td>Remove the user with the given {@code <USER_IDENTIFIER>},
   deleting all data associated with that user
 </td>
 </tr>
diff --git a/docs/html/tools/help/uiautomator/index.jd b/docs/html/tools/help/uiautomator/index.jd
index 4b3c255..5eda4a3 100644
--- a/docs/html/tools/help/uiautomator/index.jd
+++ b/docs/html/tools/help/uiautomator/index.jd
@@ -46,14 +46,14 @@
 
 <tr>
 <td rowspan="7"><code>runtest</code></td>
-<td><nobr>{@code &lt;JARS&gt;}</nobr></td>
-<td><strong>Required</strong>. The {@code &lt;JARS&gt;} argument is the name of one or more JAR files that you deployed to the target device which contain your uiautomator testcases. You can list more than one JAR file by using a space as a separator.</td>
+<td><nobr>{@code <JARS>}</nobr></td>
+<td><strong>Required</strong>. The {@code <JARS>} argument is the name of one or more JAR files that you deployed to the target device which contain your uiautomator testcases. You can list more than one JAR file by using a space as a separator.</td>
 </tr>
 
 <tr>
 <td><nobr><code>-c &lt;CLASSES&gt; </code></nobr></td>
-<td><strong>Required (API 17 or lower)</strong>.The {@code &lt;CLASSES&gt;} 
-argument is a list of test classes or test methods in {@code &lt;JARS&gt;} to run. 
+<td><strong>Required (API 17 or lower)</strong>.The {@code <CLASSES>}
+argument is a list of test classes or test methods in {@code <JARS>} to run.
 <p>Each class or method must be fully 
 qualified with the package name, in one of these formats:
 <ul>
@@ -62,7 +62,7 @@
 </ul>
 You can list multiple classes or methods by using a space as a separator.</p>
 <p class="note"><strong>Note:</strong>This argument is not required for API 18 
-and higher. If not specified, all test cases in {@code &lt;JARS&gt;} will be run.
+and higher. If not specified, all test cases in {@code <JARS>} will be run.
 </p>
 </td>
 </tr>
@@ -100,7 +100,7 @@
 </table>
 
 <h2 id="api">uiautomator API</h2>
-<p>The {@code uiautomator} API is bundled in the {@code uiautomator.jar} file under the {@code &lt;android-sdk&gt;/platforms/} directory.  The API includes these key classes, interfaces, and exceptions that allow you to capture and manipulate UI components on the target app:</p>
+<p>The {@code uiautomator} API is bundled in the {@code uiautomator.jar} file under the {@code <android-sdk>/platforms/} directory.  The API includes these key classes, interfaces, and exceptions that allow you to capture and manipulate UI components on the target app:</p>
 
 <h3 id="classes">Classes</h3>
 <table>
diff --git a/docs/html/tools/help/zipalign.jd b/docs/html/tools/help/zipalign.jd
index 184cdcb..a32a3658 100644
--- a/docs/html/tools/help/zipalign.jd
+++ b/docs/html/tools/help/zipalign.jd
@@ -51,7 +51,7 @@
 
 <pre>zipalign -c -v &lt;alignment> existing.apk</pre>
 
-<p>The {@code &lt;alignment>} is an integer that defines the byte-alignment boundaries. 
+<p>The {@code <alignment>} is an integer that defines the byte-alignment boundaries.
 This must always be 4 (which provides 32-bit alignment) or else it effectively 
 does nothing.</p>
 
diff --git a/docs/html/tools/sdk/eclipse-adt.jd b/docs/html/tools/sdk/eclipse-adt.jd
index 3c12a64..5a9d9d0 100644
--- a/docs/html/tools/sdk/eclipse-adt.jd
+++ b/docs/html/tools/sdk/eclipse-adt.jd
@@ -748,7 +748,7 @@
         &gt; Rename</strong>.</li>
       <li>Updated XML Editor to improve double click handling.</li>
       <li>Added code completion improvements for custom views, theme references and class
-        references. For example, code completion in a {@code &lt;fragment android:name="" &gt;} tag
+        references. For example, code completion in a {@code <fragment android:name="" >} tag
         now suggests completion with a list of fragment classes. Similarly, code completion in the
         manifest now offers implementations suitable for the given tag.</li>
       <li>Updated the <strong>Project Import</strong> dialog so that it shows a table for all
@@ -1771,9 +1771,9 @@
     opened files as well as on device size and orientation changes to
     ensure that large layouts are always fully visible unless you
     manually zoom in.</li>
-    <li>You can drop in an {@code &lt;include&gt;} element from the palette, which will pop up
+    <li>You can drop in an {@code <include>} element from the palette, which will pop up
     a layout chooser. When you select the layout to include, it is added with an {@code
-&lt;include&gt;}. Similarly, dropping images or image buttons will pop up image
+<include>}. Similarly, dropping images or image buttons will pop up image
     resource choosers (<a
 href="http://tools.android.com/recent/includetagdropsupport">more info</a>).</li>
     <li>The configuration chooser now applies the "Render Target" and
@@ -1796,7 +1796,7 @@
 <dd>
 <ul>
   <li>Code completion has been significantly improved. It now works
-  with {@code &lt;style&gt;} elements, completes dimensional units,
+  with {@code <style>} elements, completes dimensional units,
   sorts resource paths in values based on the attribute name, and more. There are also many fixes to
 handle text replacement (<a
 href="http://tools.android.com/recent/xmlcodecompletionimprovements">more info</a>).</li>
diff --git a/docs/html/tools/sdk/tools-notes.jd b/docs/html/tools/sdk/tools-notes.jd
index da8d62cb..a43c969 100644
--- a/docs/html/tools/sdk/tools-notes.jd
+++ b/docs/html/tools/sdk/tools-notes.jd
@@ -791,7 +791,7 @@
         <li>Updated build tools to allow use of RenderScript on older versions of Android
          using new features in the
          <a href="{@docRoot}tools/support-library/features.html#v8">Support Library</a>.</li>
-        <li>Moved the Systrace tool to the {@code &gt;sdk&lt;/platform-tools/} directory. </li>
+        <li>Moved the Systrace tool to the {@code <sdk>/platform-tools/} directory. </li>
         <li>Modified <a href="{@docRoot}tools/help/gltracer.html">Tracer for OpenGL ES</a> to
           support OpenGL ES 3.0.</li>
         <li>Lint
diff --git a/docs/html/tools/support-library/features.jd b/docs/html/tools/support-library/features.jd
index 19f93e9..f03de77 100644
--- a/docs/html/tools/support-library/features.jd
+++ b/docs/html/tools/support-library/features.jd
@@ -140,7 +140,7 @@
 </p>
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/v4/} directory. The library does not contain user
+{@code <sdk>/extras/android/support/v4/} directory. The library does not contain user
 interface resources. To include it in your application project, follow the instructions for
 <a href="{@docRoot}tools/support-library/setup.html#libs-without-res">Adding libraries without
 resources</a>.</p>
@@ -167,7 +167,7 @@
 
 <p>
   After you download the Android Support Libraries, this library is located in the
-  {@code &lt;sdk&gt;/extras/android/support/multidex/} directory. The library does not contain
+  {@code <sdk>/extras/android/support/multidex/} directory. The library does not contain
   user interface resources. To include it in your application project, follow the instructions
   for
   <a href= "{@docRoot}tools/support-library/setup.html#libs-without-res">Adding libraries without
@@ -228,7 +228,7 @@
 </ul>
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/v7/appcompat/} directory. The library contains user
+{@code <sdk>/extras/android/support/v7/appcompat/} directory. The library contains user
 interface resources. To include it in your application project, follow the instructions for
 <a href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding libraries with
 resources</a>.</p>
@@ -249,7 +249,7 @@
 implementations, and are used extensively in layouts for TV apps.</p>
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/v7/cardview/} directory. The library contains user interface
+{@code <sdk>/extras/android/support/v7/cardview/} directory. The library contains user interface
 resources. To include it in your application project, follow the instructions
 for <a href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding
 libraries with resources</a>.</p>
@@ -270,7 +270,7 @@
 For detailed information about the v7 gridlayout library APIs, see the
 {@link android.support.v7.widget android.support.v7.widget} package in the API reference.</p>
 
-<p>This library is located in the {@code &lt;sdk&gt;/extras/android/support/v7/gridlayout/}
+<p>This library is located in the {@code <sdk>/extras/android/support/v7/gridlayout/}
   directory . The library contains user
   interface resources. To include it in your application project, follow the instructions for
   <a href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding libraries with
@@ -333,7 +333,7 @@
 title card.</p>
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/v7/palette/} directory. The library does not contain
+{@code <sdk>/extras/android/support/v7/palette/} directory. The library does not contain
 user interface resources. To include it in your application project, follow the instructions for
 <a href="{@docRoot}tools/support-library/setup.html#libs-without-res">Adding libraries without
 resources</a>.</p>
@@ -355,7 +355,7 @@
 limited window of data items.</p>
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/v7/recyclerview/} directory. The library contains
+{@code <sdk>/extras/android/support/v7/recyclerview/} directory. The library contains
 user interface resources. To include it in your application project, follow the instructions
 for <a href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding
 libraries with resources</a>.</p>
@@ -384,7 +384,7 @@
 
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/v7/preference} directory. For more information
+{@code <sdk>/extras/android/support/v7/preference} directory. For more information
 on how to set up your project, follow the instructions in <a
 href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding libraries
 with resources</a>. </p>
@@ -448,7 +448,7 @@
 </p>
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/v13/} directory. The library does not contain user
+{@code <sdk>/extras/android/support/v13/} directory. The library does not contain user
 interface resources. To include it in your application project, follow the instructions for
 <a href="{@docRoot}tools/support-library/setup.html#libs-without-res">Adding libraries without
 resources</a>.</p>
@@ -480,7 +480,7 @@
 </p>
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/v14/} directory. The library does not contain user
+{@code <sdk>/extras/android/support/v14/} directory. The library does not contain user
 interface resources. To include it in your application project, follow the instructions for
 <a href="{@docRoot}tools/support-library/setup.html#libs-without-res">Adding libraries without
 resources</a>.</p>
@@ -509,7 +509,7 @@
 </p>
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/v17/} directory. The library does not contain user
+{@code <sdk>/extras/android/support/v17/} directory. The library does not contain user
 interface resources. To include it in your application project, follow the instructions for
 <a href="{@docRoot}tools/support-library/setup.html#libs-without-res">Adding libraries without
 resources</a>.</p>
@@ -551,7 +551,7 @@
 </ul>
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/v17/leanback} directory. For more information
+{@code <sdk>/extras/android/support/v17/leanback} directory. For more information
 on how to set up your project, follow the instructions in <a
 href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding libraries
 with resources</a>. </p>
@@ -572,7 +572,7 @@
 <p></p>
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/annotations} directory. For more information
+{@code <sdk>/extras/android/support/annotations} directory. For more information
 on how to set up your project, follow the instructions in <a
 href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding libraries
 with resources</a>. </p>
@@ -597,7 +597,7 @@
 
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/design} directory. For more information
+{@code <sdk>/extras/android/support/design} directory. For more information
 on how to set up your project, follow the instructions in <a
 href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding libraries
 with resources</a>. </p>
@@ -625,7 +625,7 @@
 
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/customtabs} directory. For more information
+{@code <sdk>/extras/android/support/customtabs} directory. For more information
 on how to set up your project, follow the instructions in <a
 href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding libraries
 with resources</a>. </p>
@@ -656,7 +656,7 @@
 
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/customtabs} directory. For more information
+{@code <sdk>/extras/android/support/customtabs} directory. For more information
 on how to set up your project, follow the instructions in <a
 href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding libraries
 with resources</a>. </p>
@@ -686,7 +686,7 @@
 
 
 <p>After you download the Android Support Libraries, this library is located in the
-{@code &lt;sdk&gt;/extras/android/support/customtabs} directory. For more information
+{@code <sdk>/extras/android/support/customtabs} directory. For more information
 on how to set up your project, follow the instructions in <a
 href="{@docRoot}tools/support-library/setup.html#libs-with-res">Adding libraries
 with resources</a>. </p>
diff --git a/docs/html/tools/support-library/index.jd b/docs/html/tools/support-library/index.jd
index 22ad0c9..60620e7 100644
--- a/docs/html/tools/support-library/index.jd
+++ b/docs/html/tools/support-library/index.jd
@@ -1323,7 +1323,7 @@
 <a href="{@docRoot}design/index.html">Android Design</a> guidelines for navigation. These
 additions include a way to implement the action bar's <em>Up</em> button across versions.
 For an example implementation of this pattern, see the AppNavigation sample in
-({@code <em>&lt;sdk&gt;</em>/samples/<em>&lt;platform&gt;</em>/AppNavigation}).</li>
+(<code><em>&lt;sdk&gt;</em>/samples/<em>&lt;platform&gt;</em>/AppNavigation</code>).</li>
           <li>Added {@link android.support.v4.app.NotificationCompat.Builder} to provide a
 compatibility implementation of Android 3.0's {@link android.app.Notification.Builder} helper class
 for creating standardized system notifications.</li>
diff --git a/docs/html/tools/support-library/setup.jd b/docs/html/tools/support-library/setup.jd
index 8112071..a39e4b0 100644
--- a/docs/html/tools/support-library/setup.jd
+++ b/docs/html/tools/support-library/setup.jd
@@ -72,7 +72,7 @@
 
 <p>After downloading, the tool installs the Support Library files to your existing Android SDK
   directory. The library files are located in the following subdirectory of your SDK:
-  {@code &lt;sdk&gt;/extras/android/support/} directory.</p>
+  {@code <sdk>/extras/android/support/} directory.</p>
 
 
 <h2 id="choosing">Choosing Support Libraries</h2>
@@ -115,7 +115,7 @@
       using the <a href="#download">SDK Manager</a>.</li>
     <li>Create a {@code libs/} directory in the root of your application project.</li>
     <li>Copy the JAR file from your Android SDK installation directory (e.g.,
-      {@code &lt;sdk&gt;/extras/android/support/v4/android-support-v4.jar}) into your
+      {@code <sdk>/extras/android/support/v4/android-support-v4.jar}) into your
       application's project {@code libs/} directory.
     <li>Right click the JAR file and select <strong>Build Path &gt; Add to Build Path</strong>.
       </li>
@@ -333,9 +333,9 @@
 SDK installation directory, as listed below:</p>
 
 <ul>
-  <li>4v Samples: {@code &lt;sdk&gt;/extras/android/support/samples/Support4Demos/}</li>
-  <li>7v Samples: {@code &lt;sdk&gt;/extras/android/support/samples/Support7Demos/}</li>
-  <li>13v Samples: {@code &lt;sdk&gt;/extras/android/support/samples/Support13Demos/}</li>
-  <li>App Navigation: {@code &lt;sdk&gt;/extras/android/support/samples/SupportAppNavigation/}</li>
+  <li>4v Samples: {@code <sdk>/extras/android/support/samples/Support4Demos/}</li>
+  <li>7v Samples: {@code <sdk>/extras/android/support/samples/Support7Demos/}</li>
+  <li>13v Samples: {@code <sdk>/extras/android/support/samples/Support13Demos/}</li>
+  <li>App Navigation: {@code <sdk>/extras/android/support/samples/SupportAppNavigation/}</li>
 </ul>
 
diff --git a/docs/html/tools/testing-support-library/index.jd b/docs/html/tools/testing-support-library/index.jd
index 44f5631..97c2dcf 100644
--- a/docs/html/tools/testing-support-library/index.jd
+++ b/docs/html/tools/testing-support-library/index.jd
@@ -127,7 +127,7 @@
     4.10) tests. However, you should avoid mixing JUnit 3 and and JUnit 4 test code in the same
     package, as this might cause unexpected results. If you are creating an instrumented JUnit 4
     test class to run on a device or emulator, your test class must be prefixed with the
-    {@code &#64;RunWith(AndroidJUnit4.class)} annotation.
+    {@code @RunWith(AndroidJUnit4.class)} annotation.
   </p>
 
   <p>The following code snippet shows how you might write an instrumented JUnit 4 test to validate
@@ -193,14 +193,14 @@
   </p>
 
   <ul>
-    <li><a href="{@docRoot}reference/android/support/test/filters/RequiresDevice.html">{@code &#64;RequiresDevice}</a>:
+    <li><a href="{@docRoot}reference/android/support/test/filters/RequiresDevice.html">{@code @RequiresDevice}</a>:
     Specifies that the test should run only on physical devices, not on emulators.
     </li>
 
-    <li><a href="{@docRoot}reference/android/support/test/filters/SdkSuppress.html">{@code &#64;SdkSupress}</a>:
+    <li><a href="{@docRoot}reference/android/support/test/filters/SdkSuppress.html">{@code @SdkSupress}</a>:
     Suppresses the test from running on a lower Android API level than the given level. For
     example, to suppress tests on all API levels lower than 18 from running, use the annotation
-    {@code &#64;SDKSupress(minSdkVersion=18)}.
+    {@code @SDKSupress(minSdkVersion=18)}.
     </li>
 
     <li>{@link android.test.suitebuilder.annotation.SmallTest &#64;SmallTest},
@@ -440,7 +440,7 @@
   </p>
 
   <p>
-    The {@code uiautomatorviewer} tool is located in the {@code &lt;android-sdk&gt;/tools/}
+    The {@code uiautomatorviewer} tool is located in the {@code <android-sdk>/tools/}
     directory.
   </p>
 
@@ -570,7 +570,7 @@
   <p>
     After downloading, the tool installs the Support Repository files to your existing Android
     SDK directory. The library files are located in the following subdirectory of your SDK:
-    {@code &lt;sdk&gt;/extras/android/m2repository} directory.
+    {@code <sdk>/extras/android/m2repository} directory.
   </p>
 
   <p>
diff --git a/docs/html/tools/testing/testing_ui.jd b/docs/html/tools/testing/testing_ui.jd
index 4318a21..3f4bf7a 100644
--- a/docs/html/tools/testing/testing_ui.jd
+++ b/docs/html/tools/testing/testing_ui.jd
@@ -96,7 +96,7 @@
 <p>To analyze the UI components of the application that you want to test:</p>
 <ol>
 <li>Connect your Android device to your development machine.</li>
-<li>Open a terminal window and navigate to {@code &lt;android-sdk&gt;/tools/}.</li>
+<li>Open a terminal window and navigate to {@code <android-sdk>/tools/}.</li>
 <LI>Run the tool with this command:<pre>$ uiautomatorviewer</pre></LI>
 <li><p>To capture a screen for analysis, click the <strong>Device Screenshot</strong> button in the GUI of the {@code uiautomatorviewer} tool.</p>
 <p class="note"><strong>Note: </strong>If you have more than one device connected, specify the device for screen capture by setting the {@code ANDROID_SERIAL} environment variable:  
@@ -158,7 +158,7 @@
   </ol>
 </li>
 </ol>
-<p>If you did not configure Eclipse as your development environment, make sure that the {@code uiautomator.jar} and {@code android.jar} files from the {@code &lt;android-sdk&gt;/platforms/&lt;sdk&gt;} directory are in your Java class path.</p>
+<p>If you did not configure Eclipse as your development environment, make sure that the {@code uiautomator.jar} and {@code android.jar} files from the {@code <android-sdk>/platforms/<sdk>} directory are in your Java class path.</p>
 <p>Once you have completed these prerequisite tasks, you're almost ready to start creating your {@code uiautomator} tests. </li>
 
 <h2 id="creating">Creating uiautomator Tests</h2>
@@ -169,7 +169,7 @@
 <p>The first thing your test case should do is access the device that contains the target app. It’s also good practice to start the test from the Home screen of the device. From the Home screen (or some other starting location you’ve chosen in the target app), you can use the classes provided by the {@code uiautomator} API to simulate user actions and to test specific UI components. For an example of how to put together a {@code uiautomator} test case, see the <a href="#sample">sample test case</a>.</p>
 
 <h3 id="classes">uiautomator API</h3>
-<p>The {@code uiautomator} API is bundled in the {@code uiautomator.jar} file under the {@code &lt;android-sdk&gt;/platforms/} directory.  The API includes these key classes that allow you to capture and manipulate UI components on the target app:</p>
+<p>The {@code uiautomator} API is bundled in the {@code uiautomator.jar} file under the {@code <android-sdk>/platforms/} directory.  The API includes these key classes that allow you to capture and manipulate UI components on the target app:</p>
 <dl>
 <DT><a href="{@docRoot}tools/help/uiautomator/UiDevice.html">{@code UiDevice}</a></DT>
 <dd><p>Represents the device state.  In your tests, you can call methods on the <a href="{@docRoot}tools/help/uiautomator/UiDevice.html">{@code UiDevice}</a> instance to check for the state of various properties, such as current orientation or display size. Your tests also can use the <a href="{@docRoot}tools/help/uiautomator/UiDevice.html">{@code UiDevice}</a> instance to perform device level actions, such as forcing the device into a specific rotation, pressing the d-pad hardware button, or pressing the Home and Menu buttons.</p>
@@ -323,7 +323,7 @@
 <ol>
 <li>Create the required build configuration files to build the output JAR. To generate the build configuration files, open a terminal and run the following command:
 <pre>&lt;android-sdk&gt;/tools/android create uitest-project -n &lt;name&gt; -t 1 -p &lt;path&gt;</pre>
-The {@code &lt;name&gt;} is the name of the project that contains your {@code uiautomator} test source files, and the {@code &lt;path&gt;} is the path to the corresponding project directory. 
+The {@code <name>} is the name of the project that contains your {@code uiautomator} test source files, and the {@code <path>} is the path to the corresponding project directory.
 </li>
 <LI>From the command line, set the {@code ANDROID_HOME} variable: 
 <ul>
diff --git a/docs/html/training/activity-testing/activity-basic-testing.jd b/docs/html/training/activity-testing/activity-basic-testing.jd
index 016289d..6f39bcd 100644
--- a/docs/html/training/activity-testing/activity-basic-testing.jd
+++ b/docs/html/training/activity-testing/activity-basic-testing.jd
@@ -55,13 +55,13 @@
    <li>In the Package Explorer, right-click on the {@code /src} directory for
 your test project and select <strong>New &gt; Package</strong>.</li>
    <li>Set the <strong>Name</strong> field to
-{@code &lt;your_app_package_name&gt;.tests} (for example,
+{@code <your_app_package_name>.tests} (for example,
 {@code com.example.android.testingfun.tests}) and click
 <strong>Finish</strong>.</li>
    <li>Right-click on the test package you created, and select
 <strong>New &gt; Class</strong>.</li>
     <li>Set the <strong>Name</strong> field to
-{@code &lt;your_app_activity_name&gt;Test} (for example,
+{@code <your_app_activity_name>Test} (for example,
 {@code MyFirstTestActivityTest}) and click <strong>Finish</strong>.</li>
 </ol>
 
diff --git a/docs/html/training/activity-testing/activity-ui-testing.jd b/docs/html/training/activity-testing/activity-ui-testing.jd
index 644f3ca..a47ccf3 100644
--- a/docs/html/training/activity-testing/activity-ui-testing.jd
+++ b/docs/html/training/activity-testing/activity-ui-testing.jd
@@ -137,7 +137,7 @@
 object, then call assertion methods to verify that the
 {@link android.widget.Button} object's width and height attributes match the
 expected values.</p>
-<p>The {@code &#64;MediumTest} annotation specifies how the test is categorized,
+<p>The {@code @MediumTest} annotation specifies how the test is categorized,
 relative to its absolute execution time. To learn more about using test size
 annotations, see <a href="#annotations">Apply Test Annotations</a>.</p>
 
@@ -185,7 +185,7 @@
 <p class="caution"><strong>Caution: </strong>The {@link android.test.TouchUtils}
 methods are designed to send events to the UI thread safely from the test thread.
 You should not run {@link android.test.TouchUtils} directly in the UI thread or
-any test method annotated with {@code &#64;UIThread}. Doing so might
+any test method annotated with {@code @UIThread}. Doing so might
 raise the {@code WrongThreadException}.</p>
 
 <h2 id="annotations">Apply Test Annotations</h2>
@@ -202,8 +202,8 @@
 <dd>Marks a test that should run as part of the large tests.</dd>
 </dl>
 <p>Typically, a short running test that take only a few milliseconds should be
-marked as a {@code &#64;SmallTest}. Longer running tests (100 milliseconds or
-more) are usually marked as {@code &#64;MediumTest}s or {@code &#64;LargeTest}s,
+marked as a {@code @SmallTest}. Longer running tests (100 milliseconds or
+more) are usually marked as {@code @MediumTest}s or {@code @LargeTest}s,
 depending on whether the test accesses resources on the local system only or
 remote resources over a network. For guidance on using test size annotations,
 see this <a href="https://plus.sandbox.google.com/+AndroidDevelopers/posts/TPy1EeSaSg8">Android Tools Protip</a>.</p>
diff --git a/docs/html/training/app-indexing/deep-linking.jd b/docs/html/training/app-indexing/deep-linking.jd
index 2679937..fc67b26 100644
--- a/docs/html/training/app-indexing/deep-linking.jd
+++ b/docs/html/training/app-indexing/deep-linking.jd
@@ -32,13 +32,13 @@
 <p>To create a deep link to your app content, add an intent filter that
   contains these elements and attribute values in your manifest:</p>
 <dl>
-<dt><a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action&gt;}</a></dt>
+<dt><a href="{@docRoot}guide/topics/manifest/action-element.html">{@code <action>}</a></dt>
 <dd>Specify the {@link android.content.Intent#ACTION_VIEW} intent action so
   that the intent filter can be reached from Google Search.</dd>
-<dt><a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a></dt>
-<dd>Add one or more <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a> tags, where each tag represents a URI format that resolves to the activity. At minimum, the <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a> tag must include the <a href="{@docRoot}guide/topics/manifest/data-element.html#scheme">{@code android:scheme}</a> attribute.
+<dt><a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a></dt>
+<dd>Add one or more <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a> tags, where each tag represents a URI format that resolves to the activity. At minimum, the <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a> tag must include the <a href="{@docRoot}guide/topics/manifest/data-element.html#scheme">{@code android:scheme}</a> attribute.
 <p>You can add additional attributes to further refine the type of URI that the activity accepts. For example, you might have multiple activities that accept similar URIs, but which differ simply based on the path name. In this case, use the <a href="{@docRoot}guide/topics/manifest/data-element.html#path">{@code android:path}</a> attribute or its variants ({@code pathPattern} or {@code pathPrefix}) to differentiate which activity the system should open for different URI paths.</p></dd>
-<dt><a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category&gt;}</a></dt>
+<dt><a href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a></dt>
 <dd>Include the {@link android.content.Intent#CATEGORY_BROWSABLE BROWSABLE}
 category. The {@link android.content.Intent#CATEGORY_BROWSABLE BROWSABLE}
 category is required in order for the intent filter to be accessible from a web
diff --git a/docs/html/training/app-indexing/enabling-app-indexing.jd b/docs/html/training/app-indexing/enabling-app-indexing.jd
index f0339d6..d483795 100644
--- a/docs/html/training/app-indexing/enabling-app-indexing.jd
+++ b/docs/html/training/app-indexing/enabling-app-indexing.jd
@@ -28,7 +28,7 @@
 By opting in, you can allow Googlebot to crawl the content in the APK
 through the Google Play Store to index the app content. To indicate which app
 content you’d like Google to index, simply add link elements either to
-your existing <a href="https://support.google.com/webmasters/answer/156184?hl=en" class="external-link" target="_blank">Sitemap</a> file or in the {@code &lt;head&gt;} element of each web
+your existing <a href="https://support.google.com/webmasters/answer/156184?hl=en" class="external-link" target="_blank">Sitemap</a> file or in the {@code <head>} element of each web
 page in your site, in the same way as you would for web pages.</p>
 
 <p>The deep links that you share with Google Search must take this URI
@@ -49,10 +49,10 @@
 <h2 id="sitemap">Add Deep Links in Your Sitemap</h2>
 <p>To annotate the deep link for Google Search app indexing in your
 <a href="https://support.google.com/webmasters/answer/156184?hl=en" class="external-link" target="_blank">Sitemap</a>, use the
-{@code &lt;xhtml:link&gt;} tag and specify the deep link as an alternate URI.</p>
+{@code <xhtml:link>} tag and specify the deep link as an alternate URI.</p>
 <p>For example, the following XML snippet shows how you might specify a link to
-your web page by using the {@code &lt;loc&gt;} tag, and a corresponding deep
-link to your Android app by using the {@code &lt;xhtml:link&gt;} tag.</p>
+your web page by using the {@code <loc>} tag, and a corresponding deep
+link to your Android app by using the {@code <xhtml:link>} tag.</p>
 <pre>
 &lt;?xml version="1.0" encoding="UTF-8" ?&gt;
 &lt;urlset
@@ -70,8 +70,8 @@
 <h2 id="webpages">Add Deep Links in Your Web Pages</h2>
 <p>Instead of specifying the deep links for Google Search app indexing in your
 Sitemap file, you can annotate the deep links in the HTML markup of your web
-pages. You can do this in the {@code &lt;head&gt;} section for each web
-page by adding a {@code &lt;link&gt;} tag and specifying the deep link as an
+pages. You can do this in the {@code <head>} section for each web
+page by adding a {@code <link>} tag and specifying the deep link as an
 alternate URI.</p>
 <p>For example, the following HTML snippet shows how you might specify the
 corresponding deep link in a web page that has the URL
diff --git a/docs/html/training/articles/memory.jd b/docs/html/training/articles/memory.jd
index f15af68..de7af58 100644
--- a/docs/html/training/articles/memory.jd
+++ b/docs/html/training/articles/memory.jd
@@ -319,7 +319,7 @@
 <p>In very special situations, you can request a larger heap size by setting the <a
 href="{@docRoot}guide/topics/manifest/application-element.html#largeHeap">{@code largeHeap}</a>
 attribute to "true" in the manifest <a
-href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 tag. If you do so, you can call {@link
 android.app.ActivityManager#getLargeMemoryClass()} to get an estimate of the large heap size.</p>
 
diff --git a/docs/html/training/articles/security-tips.jd b/docs/html/training/articles/security-tips.jd
index 3215a0e..a3b7529 100644
--- a/docs/html/training/articles/security-tips.jd
+++ b/docs/html/training/articles/security-tips.jd
@@ -197,7 +197,7 @@
 on the internal storage.</p>
 
 <p>In addition to requesting permissions, your application can use the <a
-href="{@docRoot}guide/topics/manifest/permission-element.html">{@code &lt;permissions>}</a>
+href="{@docRoot}guide/topics/manifest/permission-element.html">{@code <permissions>}</a>
 to protect IPC that is security sensitive and will be exposed to other
 applications, such as a {@link android.content.ContentProvider}.
 In general, we recommend using access controls
@@ -537,7 +537,7 @@
 If your IPC mechanism is not intended for use by other applications, set the
 {@code android:exported} attribute to {@code "false"} in the component's manifest element,
 such as for the <a
-href="{@docRoot}guide/topics/manifest/service-element.html#exported">{@code &lt;service&gt;}</a>
+href="{@docRoot}guide/topics/manifest/service-element.html#exported">{@code <service>}</a>
 element.  This is useful for applications that consist of multiple processes
 within the same UID, or if you decide late in development that you do not
 actually want to expose functionality as IPC but you don’t want to rewrite
@@ -545,7 +545,7 @@
 
 <p>If your IPC is intended to be accessible to other applications, you can
 apply a security policy by using the <a
-href="{@docRoot}guide/topics/manifest/permission-element.html">{@code &lt;permission>}</a>
+href="{@docRoot}guide/topics/manifest/permission-element.html">{@code <permission>}</a>
 element. If IPC is between your own separate apps that are signed with the same key,
 it is preferable to use {@code "signature"} level permission in the <a
 href="{@docRoot}guide/topics/manifest/permission-element.html#plevel">{@code
diff --git a/docs/html/training/auto/start/index.jd b/docs/html/training/auto/start/index.jd
index 6c6f188..0fdcb2a 100644
--- a/docs/html/training/auto/start/index.jd
+++ b/docs/html/training/auto/start/index.jd
@@ -98,8 +98,8 @@
    &lt;uses name="media" /&gt;
 &lt;/automotiveApp&gt;
 </pre>
-<p>The {@code &lt;uses&gt;} element declares the Auto capability your app
-intends to use. Multiple {@code &lt;uses&gt;} tags can be added if your
+<p>The {@code <uses>} element declares the Auto capability your app
+intends to use. Multiple {@code <uses>} tags can be added if your
 application uses multiple car capabilities. The {@code name} attribute indicates
 the specific capability your app uses. The values supported are:</p>
 <ul>
@@ -115,7 +115,7 @@
 <p>In your app’s manifest ({@code AndroidManifest.xml}), provide a reference to
 the Auto XML configuration file you created in the previous section. Add a
 {@code "com.google.android.gms.car.application"} metadata entry under the
-<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>
+<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a>
 element that references your Auto XML configuration file. Omit the {@code .xml}
 file extension when specifying the configuration filename.</p>
 <p>The following code snippet shows how to include this reference in your
diff --git a/docs/html/training/basics/actionbar/adding-buttons.jd b/docs/html/training/basics/actionbar/adding-buttons.jd
index 40d0bd1..caee729 100644
--- a/docs/html/training/basics/actionbar/adding-buttons.jd
+++ b/docs/html/training/basics/actionbar/adding-buttons.jd
@@ -45,7 +45,7 @@
 actions to the action bar, create a new XML file in your project's
 {@code res/menu/} directory.</p>
 
-<p>Add an {@code &lt;item>} element for each item you want to include in the action bar.
+<p>Add an {@code <item>} element for each item you want to include in the action bar.
 For example:</p>
 
 <p class="code-caption">res/menu/main_activity_actions.xml</p>
@@ -77,9 +77,9 @@
 overflow, but it's good practice to explicitly declare your design intentions for each action.)
 
 <p>The {@code icon} attribute requires a resource ID for an
-image. The name that follows {@code &#64;drawable/} must be the name of a bitmap image you've
+image. The name that follows {@code @drawable/} must be the name of a bitmap image you've
 saved in your project's {@code res/drawable/} directory. For example,
-{@code "&#64;drawable/ic_action_search"} refers to {@code ic_action_search.png}.
+{@code "@drawable/ic_action_search"} refers to {@code ic_action_search.png}.
 Likewise, the {@code title} attribute uses a string resource that's defined by an XML
 file in your project's {@code res/values/} directory, as discussed in <a
 href="{@docRoot}training/basics/firstapp/building-ui.html#Strings">Building a Simple User
@@ -139,7 +139,7 @@
 onOptionsItemSelected()} callback method. In your implementation of this method,
 call {@link android.view.MenuItem#getItemId getItemId()} on the given {@link android.view.MenuItem} to
 determine which item was pressed&mdash;the returned ID matches the value you declared in the
-corresponding {@code &lt;item>} element's {@code android:id} attribute.</p>
+corresponding {@code <item>} element's {@code android:id} attribute.</p>
 
 <pre>
 &#64;Override
diff --git a/docs/html/training/basics/actionbar/setting-up.jd b/docs/html/training/basics/actionbar/setting-up.jd
index bccbd04..2cd4140 100644
--- a/docs/html/training/basics/actionbar/setting-up.jd
+++ b/docs/html/training/basics/actionbar/setting-up.jd
@@ -90,8 +90,8 @@
   </li>
   <li>In your manifest file, update either the <a
   href="{@docRoot}guide/topics/manifest/application-element.html">{@code
-  &lt;application>}</a> element or individual
-  <a href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;activity>}</a>
+  <application>}</a> element or individual
+  <a href="{@docRoot}guide/topics/manifest/application-element.html">{@code <activity>}</a>
   elements to use one of the {@link android.support.v7.appcompat.R.style#Theme_AppCompat
   Theme.AppCompat} themes. For example:
   <pre>&lt;activity android:theme="@style/Theme.AppCompat.Light" ... ></pre>
diff --git a/docs/html/training/basics/actionbar/styling.jd b/docs/html/training/basics/actionbar/styling.jd
index 7c63952..b658423 100644
--- a/docs/html/training/basics/actionbar/styling.jd
+++ b/docs/html/training/basics/actionbar/styling.jd
@@ -75,8 +75,8 @@
 <p>You can apply these themes to your entire app or to individual activities by
 declaring them in your manifest file with the {@code android:theme} attribute
 for the <a href="{@docRoot}guide/topics/manifest/application-element.html">{@code
-&lt;application>}</a> element or individual
-<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;activity>}</a>
+<application>}</a> element or individual
+<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code <activity>}</a>
 elements.</p>
 
 <p>For example:</p>
diff --git a/docs/html/training/basics/activity-lifecycle/starting.jd b/docs/html/training/basics/activity-lifecycle/starting.jd
index 2501f38..5b238b8 100644
--- a/docs/html/training/basics/activity-lifecycle/starting.jd
+++ b/docs/html/training/basics/activity-lifecycle/starting.jd
@@ -152,7 +152,7 @@
 
 <p>The main activity for your app must be declared in the manifest with an <a
 href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter>}</a> that includes the {@link
+<intent-filter>}</a> that includes the {@link
 android.content.Intent#ACTION_MAIN MAIN} action and
 {@link android.content.Intent#CATEGORY_LAUNCHER LAUNCHER} category. For example:</p> 
 
diff --git a/docs/html/training/basics/firstapp/starting-activity.jd b/docs/html/training/basics/firstapp/starting-activity.jd
index 7aad894..4f43ea0 100644
--- a/docs/html/training/basics/firstapp/starting-activity.jd
+++ b/docs/html/training/basics/firstapp/starting-activity.jd
@@ -383,7 +383,7 @@
 
 <li>In your manifest file, <code>AndroidManifest.xml</code>, within the <code>Application</code>
 element, add the
-<a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a> element
+<a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element
 for your {@code DisplayMessageActivity} class, as follows:
 
 <pre>
@@ -412,7 +412,7 @@
 older versions of Android by using the
 <a href="{@docRoot}tools/support-library/index.html">Support Library</a> and adding
 the <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code
-&lt;meta-data>}</a> element as shown here.</p>
+<meta-data>}</a> element as shown here.</p>
 
 <p class="note"><strong>Note:</strong> Your Android SDK should already include
 the latest Android Support Library, which you installed during the
diff --git a/docs/html/training/basics/fragments/fragment-ui.jd b/docs/html/training/basics/fragments/fragment-ui.jd
index 1061c15..c0bd0a4 100644
--- a/docs/html/training/basics/fragments/fragment-ui.jd
+++ b/docs/html/training/basics/fragments/fragment-ui.jd
@@ -55,7 +55,7 @@
 <h2 id="AddAtRuntime">Add a Fragment to an Activity at Runtime</h2> 
 
 <p>Rather than defining the fragments for an activity in the layout file&mdash;as shown in the
-<a href="creating.html">previous lesson</a> with the {@code &lt;fragment>} element&mdash;you can add
+<a href="creating.html">previous lesson</a> with the {@code <fragment>} element&mdash;you can add
 a fragment to the activity during the activity runtime. This is necessary
 if you plan to change fragments during the life of the activity.</p>
 
@@ -140,7 +140,7 @@
 </pre>
 
 <p>Because the fragment has been added to the {@link android.widget.FrameLayout} container at
-runtime&mdash;instead of defining it in the activity's layout with a {@code &lt;fragment>}
+runtime&mdash;instead of defining it in the activity's layout with a {@code <fragment>}
 element&mdash;the activity can remove the fragment and replace it with a different one.</p>
 
 
diff --git a/docs/html/training/basics/intents/filters.jd b/docs/html/training/basics/intents/filters.jd
index 221e31b..0a6d401 100644
--- a/docs/html/training/basics/intents/filters.jd
+++ b/docs/html/training/basics/intents/filters.jd
@@ -32,9 +32,9 @@
 "share" action from another app and launch your app to perform the action.</p>
 
 <p>To allow other apps to start your activity, you need to add an <a
-href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter>}</a>
+href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>
 element in your manifest file for the corresponding <a
-href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a> element.</p>
+href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element.</p>
 
 <p>When your app is installed on a device, the system identifies your intent
 filters and adds the information to an internal catalog of intents supported by all installed apps.
@@ -59,14 +59,14 @@
     <dd>A string naming the action to perform. Usually one of the platform-defined values such
 as {@link android.content.Intent#ACTION_SEND} or {@link android.content.Intent#ACTION_VIEW}.
     <p>Specify this in your intent filter with the <a
-href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action>}</a> element.
+href="{@docRoot}guide/topics/manifest/action-element.html">{@code <action>}</a> element.
 The value you specify in this element must be the full string name for the action, instead of the
 API constant (see the examples below).</p></dd>
 
   <dt>Data</dt>
     <dd>A description of the data associated with the intent.
     <p>Specify this in your intent filter with the <a
-href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a> element. Using one
+href="{@docRoot}guide/topics/manifest/data-element.html">{@code <data>}</a> element. Using one
 or more attributes in this element, you can specify just the MIME type, just a URI prefix,
 just a URI scheme, or a combination of these and others that indicate the data type
 accepted.</p>
@@ -81,13 +81,13 @@
 supported by the system, but most are rarely used. However, all implicit intents are defined with
 {@link android.content.Intent#CATEGORY_DEFAULT} by default.
     <p>Specify this in your intent filter with the <a
-href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category>}</a>
+href="{@docRoot}guide/topics/manifest/category-element.html">{@code <category>}</a>
 element.</p></dd>
 </dl>
 
 <p>In your intent filter, you can declare which criteria your activity accepts
 by declaring each of them with corresponding XML elements nested in the <a
-href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter>}</a>
+href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code <intent-filter>}</a>
 element.</p>
 
 <p>For example, here's an activity with an intent filter that handles the {@link
@@ -106,11 +106,11 @@
 
 <p>Each incoming intent specifies only one action and one data type, but it's OK to declare multiple
 instances of the <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
-&lt;action>}</a>, <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
-&lt;category>}</a>, and <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
-&lt;data>}</a> elements in each
+<action>}</a>, <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
+<category>}</a>, and <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
+<data>}</a> elements in each
 <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
-&lt;intent-filter>}</a>.</p>
+<intent-filter>}</a>.</p>
 
 <p>If any two pairs of action and data are mutually exclusive in
 their behaviors, you should create separate intent filters to specify which actions are acceptable
diff --git a/docs/html/training/basics/network-ops/managing.jd b/docs/html/training/basics/network-ops/managing.jd
index 990b8cb..a645b3f 100644
--- a/docs/html/training/basics/network-ops/managing.jd
+++ b/docs/html/training/basics/network-ops/managing.jd
@@ -398,12 +398,12 @@
 {@link android.app.Activity#onCreate(android.os.Bundle) onCreate()}, 
 and it unregisters it in 
 {@link android.app.Activity#onDestroy onDestroy()}. This is more lightweight 
-than declaring a {@code &lt;receiver&gt;} in the manifest. When you declare a 
-{@code &lt;receiver&gt;} in the manifest, it can wake up your app at any time, 
+than declaring a {@code <receiver>} in the manifest. When you declare a
+{@code <receiver>} in the manifest, it can wake up your app at any time,
 even if you haven't run it for weeks. By registering and unregistering 
 {@code NetworkReceiver} within the main activity, you ensure that the app won't 
 be woken up after the user leaves the app. 
-If you do declare a {@code &lt;receiver&gt;} in the manifest and you know exactly 
+If you do declare a {@code <receiver>} in the manifest and you know exactly
 where you need it, you can use 
 {@link android.content.pm.PackageManager#setComponentEnabledSetting setComponentEnabledSetting()}
 to enable and disable it as appropriate.</p>
diff --git a/docs/html/training/basics/supporting-devices/languages.jd b/docs/html/training/basics/supporting-devices/languages.jd
index 098b556..e1bf657 100644
--- a/docs/html/training/basics/supporting-devices/languages.jd
+++ b/docs/html/training/basics/supporting-devices/languages.jd
@@ -106,10 +106,10 @@
 <h2 id="UseString">Use the String Resources</h2>
 
 <p>You can reference your string resources in your source code and other XML files using the
-resource name defined by the {@code &lt;string>} element's {@code name} attribute.</p>
+resource name defined by the {@code <string>} element's {@code name} attribute.</p>
 
 <p>In your source code, you can refer to a string resource with the syntax {@code
-R.string.&lt;string_name>}. There are a variety of methods that accept a string resource this
+R.string.<string_name>}. There are a variety of methods that accept a string resource this
 way.</p>
   
 <p>For example:</p>
@@ -123,8 +123,8 @@
 textView.setText(R.string.hello_world);
 </pre>
 
-<p>In other XML files, you can refer to a string resource with the syntax {@code
-&#64;string/&lt;string_name>} whenever the XML attribute accepts a string value.</p>
+<p>In other XML files, you can refer to a string resource with the syntax
+<code>@string/&lt;string_name&gt;</code> whenever the XML attribute accepts a string value.</p>
 
 <p>For example:</p>
 
diff --git a/docs/html/training/basics/supporting-devices/platforms.jd b/docs/html/training/basics/supporting-devices/platforms.jd
index 9890c98..eecb356 100644
--- a/docs/html/training/basics/supporting-devices/platforms.jd
+++ b/docs/html/training/basics/supporting-devices/platforms.jd
@@ -52,7 +52,7 @@
 describes details about your app and 
 identifies which versions of Android it supports.   Specifically, the <code>minSdkVersion</code> 
 and <code>targetSdkVersion</code> attributes for the <a
-href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code &lt;uses-sdk}</a> element
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">{@code <uses-sdk>}</a> element
 identify the lowest API level with which your app is compatible and the highest API level against
 which you’ve designed and tested your app.</p>
 
@@ -128,7 +128,7 @@
 <p>To apply a theme to your entire app (all activities), add the <code>android:theme</code>
 attribute 
 to the <a href="{@docRoot}guide/topics/manifest/application-element.html">{@code
-&lt;application>}</a> element:</p>
+<application>}</a> element:</p>
 
 <pre>&lt;application android:theme="@style/CustomTheme"></pre>
 
diff --git a/docs/html/training/camera/photobasics.jd b/docs/html/training/camera/photobasics.jd
index 188b5cc..efac5483 100644
--- a/docs/html/training/camera/photobasics.jd
+++ b/docs/html/training/camera/photobasics.jd
@@ -58,7 +58,7 @@
 its visibility on Google Play to devices that have a camera.  To advertise
 that your application depends on having a camera, put a <a
 href="{@docRoot}guide/topics/manifest/uses-feature-element.html"> {@code
-&lt;uses-feature&gt;}</a> tag in your manifest file:</p>
+<uses-feature>}</a> tag in your manifest file:</p>
 
 <pre style="clear:right">
 &lt;manifest ... >
diff --git a/docs/html/training/camera/videobasics.jd b/docs/html/training/camera/videobasics.jd
index 135d4a1..6da239a 100644
--- a/docs/html/training/camera/videobasics.jd
+++ b/docs/html/training/camera/videobasics.jd
@@ -52,7 +52,7 @@
 <h2 id="TaskManifest">Request Camera Permission</h2>
 
 <p>To advertise that your application depends on having a camera, put a
-{@code &lt;uses-feature&gt;} tag in the manifest file:</p>
+{@code <uses-feature>} tag in the manifest file:</p>
 
 <pre style="clear:right">
 &lt;manifest ... >
diff --git a/docs/html/training/custom-views/create-view.jd b/docs/html/training/custom-views/create-view.jd
index 11be85f..a476bbe 100644
--- a/docs/html/training/custom-views/create-view.jd
+++ b/docs/html/training/custom-views/create-view.jd
@@ -84,7 +84,7 @@
 
 <ul>
     <li>Define custom attributes for your view in a {@code
-        &lt;declare-styleable&gt;
+        <declare-styleable>
         } resource element
     </li>
     <li>Specify values for the attributes in your XML layout</li>
@@ -97,7 +97,7 @@
     retrieving and applying the values at runtime.</p>
 
 <p>To define custom attributes, add {@code
-    &lt;declare-styleable&gt;
+    <declare-styleable>
     } resources to your project. It's customary to put these resources into a {@code
     res/values/attrs.xml} file. Here's
     an example of an {@code attrs.xml} file:
@@ -179,7 +179,7 @@
 
         <p>The Android resource compiler does a lot of work for you to make calling {@link
             android.content.res.Resources.Theme#obtainStyledAttributes obtainStyledAttributes()}
-            easier. For each {@code &lt;declare-styleable&gt;}
+            easier. For each {@code <declare-styleable>}
             resource in the res directory, the generated R.java defines both an array of attribute
             ids and a set of
             constants that define the index for each attribute in the array. You use the predefined
diff --git a/docs/html/training/displaying-bitmaps/manage-memory.jd b/docs/html/training/displaying-bitmaps/manage-memory.jd
index 5a5c2cd..b7c72bc 100644
--- a/docs/html/training/displaying-bitmaps/manage-memory.jd
+++ b/docs/html/training/displaying-bitmaps/manage-memory.jd
@@ -78,7 +78,7 @@
 {@link android.graphics.Bitmap#recycle recycle()} only when you are sure that the
 bitmap is no longer being used. If you call {@link android.graphics.Bitmap#recycle recycle()}
 and later attempt to draw the bitmap, you will get the error:
-{@code &quot;Canvas: trying to use a recycled bitmap&quot;}.</p>
+<code>&quot;Canvas: trying to use a recycled bitmap&quot;</code>.</p>
 
 <p>The following code snippet gives an example of calling
 {@link android.graphics.Bitmap#recycle recycle()}. It uses reference counting
diff --git a/docs/html/training/gestures/detector.jd b/docs/html/training/gestures/detector.jd
index a8e0fdb..97f039c 100644
--- a/docs/html/training/gestures/detector.jd
+++ b/docs/html/training/gestures/detector.jd
@@ -186,7 +186,7 @@
 
 
 <p>In the following snippet, a return value of {@code true} from the individual 
-{@code on<em>&lt;TouchEvent&gt;</em>} methods indicates that you
+<code>on<em>&lt;TouchEvent&gt;</em></code> methods indicates that you
 have handled the touch event. A return value of {@code false} passes events down
 through the view stack until the touch has been successfully handled.</p>
 
@@ -286,7 +286,7 @@
 <p>
 {@link
 android.view.GestureDetector.SimpleOnGestureListener} provides an implementation
-for all of the {@code on<em>&lt;TouchEvent&gt;</em>} methods by returning {@code false}
+for all of the <code>on<em>&lt;TouchEvent&gt;</em></code> methods by returning {@code false}
 for all of them. Thus you can override only the methods you care about.
 For
 example, the snippet below creates a class that extends {@link
diff --git a/docs/html/training/gestures/movement.jd b/docs/html/training/gestures/movement.jd
index 136b37a..ed4928e 100644
--- a/docs/html/training/gestures/movement.jd
+++ b/docs/html/training/gestures/movement.jd
@@ -73,8 +73,8 @@
 <li>History. You can find the size of a gesture's history by calling the {@link
 android.view.MotionEvent} method {@link android.view.MotionEvent#getHistorySize
 getHistorySize()}. You can then obtain the positions, sizes, time, and pressures
-of each of the historical events by using the motion event's {@code
-getHistorical<em>&lt;Value&gt;</em>} methods. History is useful when rendering a trail of the user's finger, 
+of each of the historical events by using the motion event's
+<code>getHistorical<em>&lt;Value&gt;</em></code> methods. History is useful when rendering a trail of the user's finger,
 such as for touch drawing. See the {@link android.view.MotionEvent} reference for
 details.</li>
 
diff --git a/docs/html/training/id-auth/custom_auth.jd b/docs/html/training/id-auth/custom_auth.jd
index 0509c6e..def9b51 100644
--- a/docs/html/training/id-auth/custom_auth.jd
+++ b/docs/html/training/id-auth/custom_auth.jd
@@ -148,7 +148,7 @@
 href="http://developer.android.com/resources/samples/SampleSyncAdapter/index.html">
 SampleSyncAdapter</a> contains a good example of an authenticator service.</p>
 
-<p>Don't forget to add a {@code &lt;service&gt;} tag to your manifest file
+<p>Don't forget to add a {@code <service>} tag to your manifest file
 and add an intent filter for the AccountAuthenticator intent and declare the account
 authenticator:</p>
 
diff --git a/docs/html/training/id-auth/identify.jd b/docs/html/training/id-auth/identify.jd
index 2b31bdd..db9ab3a 100644
--- a/docs/html/training/id-auth/identify.jd
+++ b/docs/html/training/id-auth/identify.jd
@@ -83,7 +83,7 @@
 <p>In order to get a list of accounts on the device, your app needs the {@link
 android.Manifest.permission#GET_ACCOUNTS}
 permission. Add a <a href="{@docRoot}guide/topics/manifest/uses-permission-element.html">{@code
-&lt;uses-permission&gt;}</a> tag in your manifest file to request
+<uses-permission>}</a> tag in your manifest file to request
 this permission:</p>
 
 <pre>
diff --git a/docs/html/training/implementing-navigation/ancestral.jd b/docs/html/training/implementing-navigation/ancestral.jd
index 8aa0fd6..29e1710 100644
--- a/docs/html/training/implementing-navigation/ancestral.jd
+++ b/docs/html/training/implementing-navigation/ancestral.jd
@@ -65,14 +65,14 @@
 activity by specifying the <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#parent">{@code
 android:parentActivityName}</a> attribute
-in the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a>
+in the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a>
 element.</p>
 
 <p>If your app supports Android 4.0 and lower, include the
 <a href="{@docRoot}tools/support-library/index.html">Support Library</a> with your app and
-add a <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data>}</a>
+add a <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a>
 element inside the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity>}</a>. Then specify the parent activity as the value
+<activity>}</a>. Then specify the parent activity as the value
 for {@code android.support.PARENT_ACTIVITY}, matching the <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#parent">{@code
 android:parentActivityName}</a> attribute.</p>
@@ -140,14 +140,14 @@
 <ul>
     <li>If the parent activity has launch mode <a
     href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">{@code
-    &lt;singleTop>}</a>, or the <code>up</code> intent contains {@link
+    <singleTop>}</a>, or the <code>up</code> intent contains {@link
     android.content.Intent#FLAG_ACTIVITY_CLEAR_TOP}, the parent activity is
     brought to the top of the stack, and receives the intent through its
     {@link android.app.Activity#onNewIntent onNewIntent()} method.</li>
 
     <li>If the parent activity has launch mode <a
     href="{@docRoot}guide/topics/manifest/activity-element.html#lmode">{@code
-    &lt;standard>}</a>, and the <code>up</code> intent does not contain
+    <standard>}</a>, and the <code>up</code> intent does not contain
     {@link android.content.Intent#FLAG_ACTIVITY_CLEAR_TOP}, the parent activity
     is popped off the stack, and a new instance of that activity is created on
     top of the stack to receive the intent.</li>
@@ -226,5 +226,5 @@
 you must declare the logical parent of each activity in your manifest file, using the
 <a href="{@docRoot}guide/topics/manifest/activity-element.html#parent">{@code
 android:parentActivityName}</a> attribute (and corresponding <a
-href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data>}</a> element)
+href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a> element)
 as described above.</p>
diff --git a/docs/html/training/implementing-navigation/lateral.jd b/docs/html/training/implementing-navigation/lateral.jd
index 9c83479..01ef599 100644
--- a/docs/html/training/implementing-navigation/lateral.jd
+++ b/docs/html/training/implementing-navigation/lateral.jd
@@ -62,7 +62,7 @@
 a separate page (a separate tab) in the layout.</p>
 
 <p>To set up your layout with {@link android.support.v4.view.ViewPager}, add a
-{@code &lt;ViewPager>} element to your XML layout. For example, if each page in the swipe view
+{@code <ViewPager>} element to your XML layout. For example, if each page in the swipe view
 should consume the entire layout, then your layout looks like this:</p>
 
 <pre>
diff --git a/docs/html/training/implementing-navigation/temporal.jd b/docs/html/training/implementing-navigation/temporal.jd
index e736648..cbe1333 100644
--- a/docs/html/training/implementing-navigation/temporal.jd
+++ b/docs/html/training/implementing-navigation/temporal.jd
@@ -80,15 +80,15 @@
 href="{@docRoot}guide/topics/manifest/activity-element.html#parent">{@code
 android:parentActivityName}</a> attribute
 in the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity>}</a> element. This allows the system to facilitate navigation patterns
+<activity>}</a> element. This allows the system to facilitate navigation patterns
 because it can determine the logical <em>Back</em> or <em>Up</em> navigation path with this
 information.</p>
 
 <p>If your app supports Android 4.0 and lower, include the
 <a href="{@docRoot}tools/support-library/index.html">Support Library</a> with your app and
-add a <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data>}</a>
+add a <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a>
 element inside the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
-&lt;activity>}</a>. Then specify the parent activity as the value
+<activity>}</a>. Then specify the parent activity as the value
 for {@code android.support.PARENT_ACTIVITY}, matching the <a
 href="{@docRoot}guide/topics/manifest/activity-element.html#parent">{@code
 android:parentActivityName}</a> attribute.</p>
@@ -165,7 +165,7 @@
 you must declare the logical parent of each activity in your manifest file, using the
 <a href="{@docRoot}guide/topics/manifest/activity-element.html#parent">{@code
 android:parentActivityName}</a> attribute (and corresponding <a
-href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code &lt;meta-data>}</a> element)
+href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code <meta-data>}</a> element)
 as described above.</p>
 
 
diff --git a/docs/html/training/improving-layouts/loading-ondemand.jd b/docs/html/training/improving-layouts/loading-ondemand.jd
index 9abd8fa..770157f 100644
--- a/docs/html/training/improving-layouts/loading-ondemand.jd
+++ b/docs/html/training/improving-layouts/loading-ondemand.jd
@@ -81,7 +81,7 @@
 android.view.ViewStub} layout is visible/inflated.)</p>
 
 <p class="note"><strong>Note:</strong> One drawback of {@link android.view.ViewStub} is that it
-doesn’t currently support the {@code &lt;merge/&gt;} tag in the layouts to be inflated.</p>
+doesn’t currently support the {@code <merge>} tag in the layouts to be inflated.</p>
 
 
 
diff --git a/docs/html/training/improving-layouts/optimizing-layout.jd b/docs/html/training/improving-layouts/optimizing-layout.jd
index 003e7a2..e0baedf 100644
--- a/docs/html/training/improving-layouts/optimizing-layout.jd
+++ b/docs/html/training/improving-layouts/optimizing-layout.jd
@@ -71,7 +71,7 @@
 <p class="img-caption"><strong>Figure 1.</strong> Conceptual layout for an item in a {@link
 android.widget.ListView}.</p>
 
-<p>The {@code hierarchyviewer} tool is available in  {@code &lt;sdk&gt;/tools/}. When opened,
+<p>The {@code hierarchyviewer} tool is available in  {@code <sdk>/tools/}. When opened,
 the Hierarchy Viewer shows a list of available devices and its running components. Click
 <strong>Load View Hierarchy</strong> to view the layout hierarchy of the selected component. For
 example, figure 2 shows the layout for the list item illustrated by figure 1.</p>
diff --git a/docs/html/training/improving-layouts/reusing-layouts.jd b/docs/html/training/improving-layouts/reusing-layouts.jd
index 87431d3..7b0185d 100644
--- a/docs/html/training/improving-layouts/reusing-layouts.jd
+++ b/docs/html/training/improving-layouts/reusing-layouts.jd
@@ -37,7 +37,7 @@
 
 <p>Although Android offers a variety of widgets to provide small and re-usable interactive elements,
 you might also need to re-use larger components that require a special layout. To efficiently
-re-use complete layouts, you can use the {@code &lt;include/&gt;} and {@code &lt;merge/&gt;} tags
+re-use complete layouts, you can use the {@code <include/>} and {@code <merge/>} tags
 to embed another layout inside the current layout.</p>
 
 <p>Reusing layouts is particularly powerful as it allows you create reusable complex layouts. For
@@ -73,7 +73,7 @@
 <h2 id="Include">Use the &lt;include&gt; Tag</h2>
 
 <p>Inside the layout to which you want to add the re-usable component, add the {@code
-&lt;include/&gt;} tag. For example, here's a layout from the
+<include/>} tag. For example, here's a layout from the
 G-Kenya codelab that includes the title bar from above:</p>
 
 <p>Here's the layout file:</p>
@@ -99,7 +99,7 @@
 </pre>
 
 <p>You can also override all the layout parameters (any {@code android:layout_*} attributes) of the
-included layout's root view by specifying them in the {@code &lt;include/&gt;} tag. For
+included layout's root view by specifying them in the {@code <include/>} tag. For
 example:</p>
 
 <pre>
@@ -117,7 +117,7 @@
 
 <h2 id="Merge">Use the &lt;merge&gt; Tag</h2>
 
-<p>The {@code &lt;merge />} tag helps eliminate redundant view groups in your view hierarchy
+<p>The {@code <merge />} tag helps eliminate redundant view groups in your view hierarchy
 when including one layout within another. For example, if your main layout is a vertical {@link
 android.widget.LinearLayout} in which two consecutive views can be
 re-used in multiple layouts, then the re-usable layout in which you place the two views requires its
@@ -127,7 +127,7 @@
 serves no real purpose other than to slow down your UI performance.</p>
 
 <p>To avoid including such a redundant view group, you can instead use the
-{@code &lt;merge&gt;} element as the root view for the re-usable layout. For example:</p>
+{@code <merge>} element as the root view for the re-usable layout. For example:</p>
 
 <pre>
 &lt;merge xmlns:android="http://schemas.android.com/apk/res/android">
@@ -145,7 +145,7 @@
 &lt;/merge>
 </pre>
 
-<p>Now, when you include this layout in another layout (using the {@code &lt;include/&gt;} tag), the
-system ignores the {@code &lt;merge&gt;} element and places the two buttons directly in the
-layout, in place of the {@code &lt;include/&gt;} tag.</p>
+<p>Now, when you include this layout in another layout (using the {@code <include/>} tag), the
+system ignores the {@code <merge>} element and places the two buttons directly in the
+layout, in place of the {@code <include/>} tag.</p>
 
diff --git a/docs/html/training/in-app-billing/preparing-iab-app.jd b/docs/html/training/in-app-billing/preparing-iab-app.jd
index 17cd0d51..42bc947 100644
--- a/docs/html/training/in-app-billing/preparing-iab-app.jd
+++ b/docs/html/training/in-app-billing/preparing-iab-app.jd
@@ -41,7 +41,7 @@
 <li>Select <strong>Google Play Billing Library</strong>.</li>
 <li>Click <strong>Install packages</strong> to complete the download.</li>
 </ol>
-<p>The sample files will be installed to {@code &lt;sdk&gt;/extras/google/play_billing/}.</p>
+<p>The sample files will be installed to {@code <sdk>/extras/google/play_billing/}.</p>
 
 <h2 id="AddToDevConsole">Add Your Application to the Developer Console</h2>
 <p>The Google Play Developer Console is where you publish your In-app Billing application and  manage the various digital goods that are available for purchase from your application. When you create a new application entry in the Developer Console, it automatically generates a public license key for your application. You will need this key to establish a trusted connection from your application to the Google Play servers. You only need to generate this key once per application, and don’t need to repeat these steps when you update the APK file for your application.</p>
diff --git a/docs/html/training/keyboard-input/visibility.jd b/docs/html/training/keyboard-input/visibility.jd
index 5dc6fc260..258884a 100644
--- a/docs/html/training/keyboard-input/visibility.jd
+++ b/docs/html/training/keyboard-input/visibility.jd
Binary files differ
diff --git a/docs/html/training/location/display-address.jd b/docs/html/training/location/display-address.jd
index 516f14f..8606629 100644
--- a/docs/html/training/location/display-address.jd
+++ b/docs/html/training/location/display-address.jd
@@ -131,7 +131,7 @@
 &lt;/manifest&gt;
 </pre>
 
-<p class="note"><strong>Note:</strong> The {@code &lt;service&gt;} element in
+<p class="note"><strong>Note:</strong> The {@code <service>} element in
   the manifest doesn't need to include an intent filter, because your main
   activity creates an explicit intent by specifying the name of the class to use
   for the intent.</p>
diff --git a/docs/html/training/scheduling/alarms.jd b/docs/html/training/scheduling/alarms.jd
index 8373d95..b332cb7 100644
--- a/docs/html/training/scheduling/alarms.jd
+++ b/docs/html/training/scheduling/alarms.jd
@@ -348,7 +348,7 @@
 
 
 <p>Notice that in the manifest, the boot receiver is set to
-{@code android:enabled=&quot;false&quot;}. This means that the receiver will not be called
+<code>android:enabled=&quot;false&quot;</code>. This means that the receiver will not be called
 unless the application explicitly enables it. This prevents the boot receiver from being
 called unnecessarily. You can enable a receiver (for example, if the user sets an alarm)
 as follows:</p>
diff --git a/docs/html/training/testing/ui-testing/uiautomator-testing.jd b/docs/html/training/testing/ui-testing/uiautomator-testing.jd
index a0050a8..d0defd8 100644
--- a/docs/html/training/testing/ui-testing/uiautomator-testing.jd
+++ b/docs/html/training/testing/ui-testing/uiautomator-testing.jd
@@ -119,7 +119,7 @@
 <ol>
   <li>Launch the target app on a physical device.</li>
   <li>Connect the device to your development machine.</li>
-  <li>Open a terminal window and navigate to the {@code &lt;android-sdk&gt;/tools/} directory.</li>
+  <li>Open a terminal window and navigate to the {@code <android-sdk>/tools/} directory.</li>
   <li>Run the tool with this command:
 <pre>$ uiautomatorviewer</pre>
   </li>
diff --git a/docs/html/training/testing/unit-testing/instrumented-unit-tests.jd b/docs/html/training/testing/unit-testing/instrumented-unit-tests.jd
index 81921f8..9906d8c 100644
--- a/docs/html/training/testing/unit-testing/instrumented-unit-tests.jd
+++ b/docs/html/training/testing/unit-testing/instrumented-unit-tests.jd
@@ -91,7 +91,7 @@
 creating JUnit 4 test classes and using JUnit 4 assertions and annotations, see
 <a href="local-unit-tests.html#build">Create a Local Unit Test Class</a>.
 </p>
-<p>To create an instrumented JUnit 4 test class, add the {@code &#64;RunWith(AndroidJUnit4.class)}
+<p>To create an instrumented JUnit 4 test class, add the {@code @RunWith(AndroidJUnit4.class)}
 annotation at the beginning of your test class definition. You also need to specify the
 <a href="{@docRoot}reference/android/support/test/runner/AndroidJUnitRunner.html">
 {@code AndroidJUnitRunner}</a> class
@@ -168,8 +168,8 @@
 class="external-link">{@code RunWith}</a> and
 <a href="http://junit.sourceforge.net/javadoc/org/junit/runners/Suite.html"
 class="external-link">{@code Suite}</a> classes. In your test suite, add the
-{@code &#64;RunWith(Suite.class)} and the {@code &#64;Suite.SuitClasses()} annotations. In
-the {@code &#64;Suite.SuiteClasses()} annotation, list the individual test classes or test
+{@code @RunWith(Suite.class)} and the {@code @Suite.SuitClasses()} annotations. In
+the {@code @Suite.SuiteClasses()} annotation, list the individual test classes or test
 suites as arguments.
 </p>
 
@@ -245,6 +245,6 @@
 </pre>
 
 <p>You can find the generated HTML test result reports in the
-{@code &lt;path_to_your_project&gt;/app/build/outputs/reports/androidTests/connected/} directory,
+{@code <path_to_your_project>/app/build/outputs/reports/androidTests/connected/} directory,
 and the corresponding XML files in the
-{@code &lt;path_to_your_project&gt;/app/build/outputs/androidTest-results/connected/} directory.</p>
\ No newline at end of file
+{@code <path_to_your_project>/app/build/outputs/androidTest-results/connected/} directory.</p>
\ No newline at end of file
diff --git a/docs/html/training/testing/unit-testing/local-unit-tests.jd b/docs/html/training/testing/unit-testing/local-unit-tests.jd
index 421709b..8221a6d 100644
--- a/docs/html/training/testing/unit-testing/local-unit-tests.jd
+++ b/docs/html/training/testing/unit-testing/local-unit-tests.jd
@@ -89,7 +89,7 @@
 {@code junit.extensions} package.</p>
 
 <p>To create a basic JUnit 4 test class, create a Java class that contains one or more test methods.
-A test method begins with the {@code &#64;Test} annotation and contains the code to exercise
+A test method begins with the {@code @Test} annotation and contains the code to exercise
 and verify a single functionality in the component that you want to test.</p>
 
 <p>The following example shows how you might implement a local unit test class. The test method
@@ -125,32 +125,32 @@
 
 <ul>
 <li>
-{@code &#64;Before}: Use this annotation to specify a block of code with test setup operations. This
-code block will be invoked before each test. You can have multiple {@code &#64;Before} methods but
+{@code @Before}: Use this annotation to specify a block of code with test setup operations. This
+code block will be invoked before each test. You can have multiple {@code @Before} methods but
 the order which these methods are called is not fixed.
 </li>
 <li>
-{@code &#64;After}: This annotation specifies a block of code with test tear-down operations. This
-code block will be called after every test method. You can define multiple {@code &#64;After}
+{@code @After}: This annotation specifies a block of code with test tear-down operations. This
+code block will be called after every test method. You can define multiple {@code @After}
 operations in your test code. Use this annotation to release any resources from memory.
 </li>
 <li>
-{@code &#64;Test}: Use this annotation to mark a test method. A single test class can contain
+{@code @Test}: Use this annotation to mark a test method. A single test class can contain
 multiple test methods, each prefixed with this annotation.
 </li>
 <li>
-{@code &#64;BeforeClass}: Use this annotation to specify static methods to be invoked only once per
+{@code @BeforeClass}: Use this annotation to specify static methods to be invoked only once per
 test class. This testing step is useful for expensive operations such as connecting to a database.
 </li>
 <li>
-{@code &#64;AfterClass}: Use this annotation to specify static methods to be invoked only after all
+{@code @AfterClass}: Use this annotation to specify static methods to be invoked only after all
 tests in the class have been run. This testing step is useful for releasing any resources allocated
-in the {@code &#64;BeforeClass} block.
+in the {@code @BeforeClass} block.
 </li>
 <li>
-{@code &#64;Test(timeout=&lt;milliseconds&gt;)}: Specifies a timeout period for the test. If the
+{@code @Test(timeout=<milliseconds>)}: Specifies a timeout period for the test. If the
 test starts but does not complete within the given timeout period, it automatically fails. You must
-specify the timeout period in milliseconds, for example: {@code &#64;Test(timeout=5000)}.
+specify the timeout period in milliseconds, for example: {@code @Test(timeout=5000)}.
 </li>
 </ul>
 
@@ -179,11 +179,11 @@
 <a href="#setup">Set Up Your Testing Environment</a>.
 </li>
 <li>At the beginning of your unit test class definition, add the
-{@code &#64;RunWith(MockitoJUnitRunner.class)} annotation. This annotation tells the Mockito test
+{@code @RunWith(MockitoJUnitRunner.class)} annotation. This annotation tells the Mockito test
 runner to validate that your usage of the framework is correct and simplifies the initialization of
 your mock objects.
 </li>
-<li>To create a mock object for an Android dependency, add the {@code &#64;Mock} annotation before
+<li>To create a mock object for an Android dependency, add the {@code @Mock} annotation before
 the field declaration.</li>
 <li>To stub the behavior of the dependency, you can specify a condition and return
 value when the condition is met by using the {@code when()} and {@code thenReturn()} methods.
@@ -298,5 +298,5 @@
 
 <p>If there are failing tests, the command will display links to HTML reports (one per build
 variant). You can find the generated HTML test result reports in the
-{@code &lt;path_to_your_project&gt;/app/build/reports/tests/} directory, and the corresponding XML
-files in the {@code &lt;path_to_your_project&gt;/app/build/test-results/} directory.</p>
\ No newline at end of file
+{@code <path_to_your_project>/app/build/reports/tests/} directory, and the corresponding XML
+files in the {@code <path_to_your_project>/app/build/test-results/} directory.</p>
\ No newline at end of file
diff --git a/docs/html/training/tv/discovery/searchable.jd b/docs/html/training/tv/discovery/searchable.jd
index 4ca7abb..bbcb56e 100644
--- a/docs/html/training/tv/discovery/searchable.jd
+++ b/docs/html/training/tv/discovery/searchable.jd
@@ -238,7 +238,7 @@
 
 <p>In your manifest file, the content provider receives special treatment. Rather than getting
 tagged as an activity, it is described as a
-<a href="{@docRoot}guide/topics/manifest/provider-element.html">{@code &lt;provider&gt;}</a>. The
+<a href="{@docRoot}guide/topics/manifest/provider-element.html">{@code <provider>}</a>. The
 provider includes the {@code android:searchSuggestAuthority} attribute to tell the system the
 namespace of your content provider. Also, you must set its {@code android:exported} attribute to
 {@code "true"} so that the Android global search can use the results returned from it.</p>
@@ -257,7 +257,7 @@
 {@code android:searchSuggestAuthority}</a> attribute to tell the system the namespace of your
 content provider. This must match the string value you specify in the
 <a href="{@docRoot}guide/topics/manifest/provider-element.html#auth">{@code android:authorities}</a>
-attribute of the <a href="{@docRoot}guide/topics/manifest/provider-element.html">{@code &lt;provider&gt;}
+attribute of the <a href="{@docRoot}guide/topics/manifest/provider-element.html">{@code <provider>}
 </a> element in your {@code AndroidManifest.xml} file.</p>
 
 The <a href="{@docRoot}guide/topics/search/searchable-config.html">{@code searchable.xml}</a> file
@@ -339,7 +339,7 @@
 <a href="{@docRoot}guide/topics/search/searchable-config.html">{@code searchable.xml}</a> file.
 To <a href="{@docRoot}guide/topics/search/search-dialog.html">use the global search dialog</a>,
 the manifest must describe which activity should receive search queries. The manifest must also
-describe the <a href="{@docRoot}guide/topics/manifest/provider-element.html">{@code &lt;provider&gt;}
+describe the <a href="{@docRoot}guide/topics/manifest/provider-element.html">{@code <provider>}
 </a>element, exactly as it is described in the <a href="{@docRoot}guide/topics/search/searchable-config.html">
 {@code searchable.xml}</a> file.</p>
 
diff --git a/docs/html/training/tv/start/start.jd b/docs/html/training/tv/start/start.jd
index e55e202..4d04ad6 100644
--- a/docs/html/training/tv/start/start.jd
+++ b/docs/html/training/tv/start/start.jd
@@ -233,7 +233,7 @@
 <p>
   The Android SDK includes support libraries that are intended for use with TV apps. These
   libraries provide APIs and user interface widgets for use on TV devices. The libraries are
-  located in the {@code &lt;sdk&gt;/extras/android/support/} directory. Here is a list of the
+  located in the {@code <sdk>/extras/android/support/} directory. Here is a list of the
   libraries and their general purpose:
 </p>
 
diff --git a/docs/html/training/volley/request-custom.jd b/docs/html/training/volley/request-custom.jd
index 7b669b9..c62c254 100644
--- a/docs/html/training/volley/request-custom.jd
+++ b/docs/html/training/volley/request-custom.jd
@@ -36,12 +36,12 @@
 
 <ul>
 
-<li>Extend the {@code Request&lt;T&gt;} class, where
-{@code &lt;T&gt;} represents the type of parsed response
+<li>Extend the {@code Request<T>} class, where
+{@code <T>} represents the type of parsed response
 the request expects. So if your parsed response is a string, for example,
-create your custom request by extending {@code Request&lt;String&gt;}. See the Volley
+create your custom request by extending {@code Request<String>}. See the Volley
 toolbox classes {@code StringRequest} and {@code ImageRequest} for examples of
-extending {@code Request&lt;T&gt;}.</li>
+extending {@code Request<T>}.</li>
 
 <li>Implement the abstract methods {@code parseNetworkResponse()}
 and {@code deliverResponse()}, described in more detail below.</li>
@@ -74,7 +74,7 @@
 <ul>
 <li>{@code parseNetworkResponse()} takes as its parameter a {@code NetworkResponse}, which
 contains the response payload as a byte[], HTTP status code, and response headers.</li>
-<li>Your implementation must return a {@code Response&lt;T&gt;}, which contains your typed
+<li>Your implementation must return a {@code Response<T>}, which contains your typed
 response object and cache metadata or an error, such as in the case of a parse failure.</li>
 </ul>
 
diff --git a/graphics/java/android/graphics/drawable/AnimationDrawable.java b/graphics/java/android/graphics/drawable/AnimationDrawable.java
index 6bf3afd..0fd1741 100644
--- a/graphics/java/android/graphics/drawable/AnimationDrawable.java
+++ b/graphics/java/android/graphics/drawable/AnimationDrawable.java
@@ -40,8 +40,8 @@
  * animation.
  * <p>
  * An AnimationDrawable defined in XML consists of a single
- * {@code &lt;animation-list&gt;} element and a series of nested
- * {@code &lt;item&gt;} tags. Each item defines a frame of the animation. See
+ * {@code <animation-list>} element and a series of nested
+ * {@code <item>} tags. Each item defines a frame of the animation. See
  * the example below.
  * <p>
  * spin_animation.xml file in res/drawable/ folder:
diff --git a/graphics/java/android/graphics/drawable/ScaleDrawable.java b/graphics/java/android/graphics/drawable/ScaleDrawable.java
index f87c19a..330266f 100644
--- a/graphics/java/android/graphics/drawable/ScaleDrawable.java
+++ b/graphics/java/android/graphics/drawable/ScaleDrawable.java
@@ -50,7 +50,7 @@
  * {@code android.R.styleable#ScaleDrawable_scaleHeight scaleHeight}. At run
  * time, the level may be set via {@link #setLevel(int)}.
  * <p>
- * A scale drawable may be defined in an XML file with the {@code &lt;scale>}
+ * A scale drawable may be defined in an XML file with the {@code <scale>}
  * element. For more information, see the guide to
  * <a href="{@docRoot}guide/topics/resources/drawable-resource.html">Drawable
  * Resources</a>.
diff --git a/keystore/java/android/security/KeyChain.java b/keystore/java/android/security/KeyChain.java
index 5b2594d..40fb0d3 100644
--- a/keystore/java/android/security/KeyChain.java
+++ b/keystore/java/android/security/KeyChain.java
@@ -457,9 +457,9 @@
      * KeyFactory keyFactory =
      *     KeyFactory.getInstance(key.getAlgorithm(), "AndroidKeyStore");
      * KeyInfo keyInfo = keyFactory.getKeySpec(key, KeyInfo.class);
-     * if (keyInfo.isInsideSecureHardware()) &#123;
+     * if (keyInfo.isInsideSecureHardware()) {
      *     // The key is bound to the secure hardware of this Android
-     * &#125;}</pre>
+     * }}</pre>
      */
     @Deprecated
     public static boolean isBoundKeyAlgorithm(
diff --git a/keystore/java/android/security/keystore/KeyInfo.java b/keystore/java/android/security/keystore/KeyInfo.java
index 785ec15..7cf4b04 100644
--- a/keystore/java/android/security/keystore/KeyInfo.java
+++ b/keystore/java/android/security/keystore/KeyInfo.java
@@ -38,32 +38,30 @@
  * <p><h3>Example: Symmetric Key</h3>
  * The following example illustrates how to obtain a {@code KeyInfo} describing the provided Android
  * Keystore {@link SecretKey}.
- * <pre> {@code
+ * <pre>{@code
  * SecretKey key = ...; // Android Keystore key
  *
  * SecretKeyFactory factory = SecretKeyFactory.getInstance(key.getAlgorithm(), "AndroidKeyStore");
  * KeyInfo keyInfo;
- * try &#123;
+ * try {
  *     keyInfo = (KeyInfo) factory.getKeySpec(key, KeyInfo.class);
- * &#125; catch (InvalidKeySpecException e) &#123;
+ * } catch (InvalidKeySpecException e) {
  *     // Not an Android KeyStore key.
- * &#125;
- * }</pre>
+ * }}</pre>
  *
  * <p><h3>Example: Private Key</h3>
  * The following example illustrates how to obtain a {@code KeyInfo} describing the provided
  * Android KeyStore {@link PrivateKey}.
- * <pre> {@code
+ * <pre>{@code
  * PrivateKey key = ...; // Android KeyStore key
  *
  * KeyFactory factory = KeyFactory.getInstance(key.getAlgorithm(), "AndroidKeyStore");
  * KeyInfo keyInfo;
- * try &#123;
+ * try {
  *     keyInfo = factory.getKeySpec(key, KeyInfo.class);
- * &#125; catch (InvalidKeySpecException e) &#123;
+ * } catch (InvalidKeySpecException e) {
  *     // Not an Android KeyStore key.
- * &#125;
- * }</pre>
+ * }}</pre>
  */
 public class KeyInfo implements KeySpec {
     private final String mKeystoreAlias;
diff --git a/telecomm/java/android/telecom/InCallService.java b/telecomm/java/android/telecom/InCallService.java
index 19c613d..5087080 100644
--- a/telecomm/java/android/telecom/InCallService.java
+++ b/telecomm/java/android/telecom/InCallService.java
@@ -48,13 +48,13 @@
  * {@code InCallService} implementation intends to replace the built-in in-call UI.
  * <pre>
  * {@code
- * &lt;service android:name="your.package.YourInCallServiceImplementation"
- *          android:permission="android.permission.BIND_IN_CALL_SERVICE"&gt;
- *      &lt;meta-data android:name="android.telecom.IN_CALL_SERVICE_UI" android:value="true" /&gt;
- *      &lt;intent-filter&gt;
- *          &lt;action android:name="android.telecom.InCallService"/&gt;
- *      &lt;/intent-filter&gt;
- * &lt;/service&gt;
+ * <service android:name="your.package.YourInCallServiceImplementation"
+ *          android:permission="android.permission.BIND_IN_CALL_SERVICE">
+ *      <meta-data android:name="android.telecom.IN_CALL_SERVICE_UI" android:value="true" />
+ *      <intent-filter>
+ *          <action android:name="android.telecom.InCallService"/>
+ *      </intent-filter>
+ * </service>
  * }
  * </pre>
  */
diff --git a/wifi/java/android/net/wifi/WifiManager.java b/wifi/java/android/net/wifi/WifiManager.java
index bd030e8..940fdcf 100644
--- a/wifi/java/android/net/wifi/WifiManager.java
+++ b/wifi/java/android/net/wifi/WifiManager.java
@@ -2173,7 +2173,7 @@
      * is idle.
      * <p>
      * Any application using a WifiLock must request the {@code android.permission.WAKE_LOCK}
-     * permission in an {@code &lt;uses-permission&gt;} element of the application's manifest.
+     * permission in an {@code <uses-permission>} element of the application's manifest.
      */
     public class WifiLock {
         private String mTag;
diff --git a/wifi/java/android/net/wifi/p2p/package.html b/wifi/java/android/net/wifi/p2p/package.html
index 94d695f..6a5e8e6 100644
--- a/wifi/java/android/net/wifi/p2p/package.html
+++ b/wifi/java/android/net/wifi/p2p/package.html
@@ -56,7 +56,7 @@
 
 <p class="note"><strong>Note:</strong> Not all Android-powered devices support Wi-Fi
 Direct. If your application uses Wi-Fi Direct, declare so with a <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element in the manifest file:</p>
 <pre>
 &lt;manifest ...>
diff --git a/wifi/java/android/net/wifi/package.html b/wifi/java/android/net/wifi/package.html
index 6f0d337..b21d39d 100644
--- a/wifi/java/android/net/wifi/package.html
+++ b/wifi/java/android/net/wifi/package.html
@@ -17,7 +17,7 @@
 
 <p class="note"><strong>Note:</strong> Not all Android-powered devices provide Wi-Fi functionality.
 If your application uses Wi-Fi, declare so with a <a
-href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code &lt;uses-feature&gt;}</a>
+href="{@docRoot}guide/topics/manifest/uses-feature-element.html">{@code <uses-feature>}</a>
 element in the manifest file:</p>
 <pre>
 &lt;manifest ...>
