diff --git a/src/devices/audio.jd b/src/devices/audio.jd
index 2b51d3a..657ec09 100644
--- a/src/devices/audio.jd
+++ b/src/devices/audio.jd
@@ -172,7 +172,7 @@
 <h3 id="codecs">Media Codecs</h3>
 
 <p>Ensure that the audio codecs that your hardware and drivers support are properly declared for your product. See
-  <a href="{@docRoot}guide/media.html#expose"> Exposing Codecs to the Framework</a> for information on how to do this.
+  <a href="media.html#expose"> Exposing Codecs to the Framework</a> for information on how to do this.
 </p>
 
 <h2 id="configuring">
diff --git a/src/devices/camera.jd b/src/devices/camera.jd
index 1e709c8..e85a23d 100644
--- a/src/devices/camera.jd
+++ b/src/devices/camera.jd
@@ -138,7 +138,7 @@
 <li>Declare your camera’s media codec, format, and resolution capabilities in
 <code>device/&lt;company_name&gt;/&lt;device_name&gt;/media_profiles.xml</code> and
 <code>device/&lt;company_name&gt;/&lt;device_name&gt;/media_codecs.xml</code> XML files.
- For more information, see <a href="{@docRoot}guide/media.html#expose"> Exposing
+ For more information, see <a href="media.html#expose"> Exposing
  Codecs and Profiles to the Framework</a> for information on how to do this.
 </p></code>
 
@@ -171,4 +171,4 @@
 </pre>
 </li>
 
-</ol>
\ No newline at end of file
+</ol>
diff --git a/src/devices/tech/dalvik/dex-format.jd b/src/devices/tech/dalvik/dex-format.jd
index fffc546..e78d18b 100644
--- a/src/devices/tech/dalvik/dex-format.jd
+++ b/src/devices/tech/dalvik/dex-format.jd
@@ -260,8 +260,8 @@
 
 <h2>Bitfield, String, and Constant Definitions</h2>
 
-<h3><code>DEX_FILE_MAGIC</code></h3>
-<h4>embedded in <code>header_item</code></h4>
+<h3>DEX_FILE_MAGIC</h3>
+<h4>embedded in header_item</h4>
 
 <p>The constant array/string <code>DEX_FILE_MAGIC</code> is the list of
 bytes that must appear at the beginning of a <code>.dex</code> file
@@ -286,8 +286,8 @@
 versions of the format differ significantly from the version described in this
 document.</p>
 
-<h3><code>ENDIAN_CONSTANT</code> and <code>REVERSE_ENDIAN_CONSTANT</code></h3>
-<h4>embedded in <code>header_item</code></h4>
+<h3>ENDIAN_CONSTANT and REVERSE_ENDIAN_CONSTANT</h3>
+<h4>embedded in header_item</h4>
 
 <p>The constant <code>ENDIAN_CONSTANT</code> is used to indicate the
 endianness of the file in which it is found. Although the standard
@@ -302,9 +302,8 @@
 uint REVERSE_ENDIAN_CONSTANT = 0x78563412;
 </pre>
 
-<h3><code>NO_INDEX</code></h3>
-<h4>embedded in <code>class_def_item</code> and
-<code>debug_info_item</code></h4>
+<h3>NO_INDEX</h3>
+<h4>embedded in class_def_item and debug_info_item</h4>
 
 <p>The constant <code>NO_INDEX</code> is used to indicate that
 an index value is absent.</p>
@@ -319,10 +318,9 @@
 uint NO_INDEX = 0xffffffff;    // == -1 if treated as a signed int
 </pre>
 
-<h3><code>access_flags</code> Definitions</h3>
-<h4>embedded in <code>class_def_item</code>,
-<code>encoded_field</code>, <code>encoded_method</code>, and
-<code>InnerClass</code></h4>
+<h3>access_flags Definitions</h3>
+<h4>embedded in class_def_item, encoded_field, encoded_method, and 
+InnerClass</h4>
 
 <p>Bitfields of these flags are used to indicate the accessibility and
 overall properties of classes and class members.</p>
@@ -535,9 +533,8 @@
 <a href="http://www.unicode.org/reports/tr26/">CESU-8</a> than to UTF-8
 per se.</p>
 
-<h3><code>encoded_value</code> Encoding</h3>
-<h4>embedded in <code>annotation_element</code> and
-<code>encoded_array_item</code></h4>
+<h3>encoded_value Encoding</h3>
+<h4>embedded in annotation_element and encoded_array_item </h4>
 
 <p>An <code>encoded_value</code> is an encoded piece of (nearly)
 arbitrary hierarchically structured data. The encoding is meant to
@@ -738,7 +735,7 @@
 </tbody>
 </table>
 
-<h3><code>encoded_array</code> Format</h3>
+<h3>encoded_array Format</h3>
 
 <table class="format">
 <thead>
@@ -765,7 +762,7 @@
 </tbody>
 </table>
 
-<h3><code>encoded_annotation</code> Format</h3>
+<h3>encoded_annotation Format</h3>
 
 <table class="format">
 <thead>
@@ -799,7 +796,7 @@
 </tbody>
 </table>
 
-<h3><code>annotation_element</code> Format</h3>
+<h3>annotation_element Format</h3>
 
 <table class="format">
 <thead>
@@ -902,7 +899,7 @@
 </table>
 
 <h3><i>MemberName</i></h3>
-<h4>used by <code>field_id_item</code> and <code>method_id_item</code></h4>
+<h4>used by field_id_item and method_id_item</h4>
 
 <p>A <i>MemberName</i> is the name of a member of a class, members being
 fields, methods, and inner classes.</p>
@@ -939,7 +936,7 @@
 </table>
 
 <h3><i>TypeDescriptor</i></h3>
-<h4>used by <code>type_id_item</code></h4>
+<h4>used by type_id_item</h4>
 
 <p>A <i>TypeDescriptor</i> is the representation of any type, including
 primitives, classes, arrays, and <code>void</code>. See below for
@@ -1009,7 +1006,7 @@
 </table>
 
 <h3><i>ShortyDescriptor</i></h3>
-<h4>used by <code>proto_id_item</code></h4>
+<h4>used by proto_id_item</h4>
 
 <p>A <i>ShortyDescriptor</i> is the short form representation of a method
 prototype, including return and parameter types, except that there is
@@ -1139,8 +1136,8 @@
 <p>This section includes definitions for each of the top-level items that
 may appear in a <code>.dex</code> file.
 
-<h3><code>header_item</code></h3>
-<h4>appears in the <code>header</code> section</h4>
+<h3>header_item</h3>
+<h4>appears in the header section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -1322,9 +1319,9 @@
 </tbody>
 </table>
 
-<h3><code>map_list</code></h3>
-<h4>appears in the <code>data</code> section</h4>
-<h4>referenced from <code>header_item</code></h4>
+<h3>map_list</h3>
+<h4>appears in the data section</h4>
+<h4>referenced from header_item</h4>
 <h4>alignment: 4 bytes</h4>
 
 <p>This is a list of the entire contents of a file, in order. It
@@ -1359,7 +1356,7 @@
 </tbody>
 </table>
 
-<h3><code>map_item</code> Format</h3>
+<h3>map_item Format</h3>
 
 <table class="format">
 <thead>
@@ -1518,8 +1515,8 @@
 </table>
 
 
-<h3><code>string_id_item</code></h3>
-<h4>appears in the <code>string_ids</code> section</h4>
+<h3>string_id_item</h3>
+<h4>appears in the string_ids section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -1544,8 +1541,8 @@
 </tbody>
 </table>
 
-<h3><code>string_data_item</code></h3>
-<h4>appears in the <code>data</code> section</h4>
+<h3>string_data_item</h3>
+<h4>appears in the data section</h4>
 <h4>alignment: none (byte-aligned)</h4>
 
 <table class="format">
@@ -1583,8 +1580,8 @@
 </tbody>
 </table>
 
-<h3><code>type_id_item</code></h3>
-<h4>appears in the <code>type_ids</code> section</h4>
+<h3>type_id_item</h3>
+<h4>appears in the type_ids section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -1607,8 +1604,8 @@
 </tbody>
 </table>
 
-<h3><code>proto_id_item</code></h3>
-<h4>appears in the <code>proto_ids</code> section</h4>
+<h3>proto_id_item</h3>
+<h4>appears in the proto_ids section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -1650,8 +1647,8 @@
 </tbody>
 </table>
 
-<h3><code>field_id_item</code></h3>
-<h4>appears in the <code>field_ids</code> section</h4>
+<h3>field_id_item</h3>
+<h4>appears in the field_ids section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -1688,8 +1685,8 @@
 </tbody>
 </table>
 
-<h3><code>method_id_item</code></h3>
-<h4>appears in the <code>method_ids</code> section</h4>
+<h3>method_id_item</h3>
+<h4>appears in the method_ids section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -1726,8 +1723,8 @@
 </tbody>
 </table>
 
-<h3><code>class_def_item</code></h3>
-<h4>appears in the <code>class_defs</code> section</h4>
+<h3>class_def_item</h3>
+<h4>appears in the class_defs section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -1830,9 +1827,9 @@
 </tbody>
 </table>
 
-<h3><code>class_data_item</code></h3>
-<h4>referenced from <code>class_def_item</code></h4>
-<h4>appears in the <code>data</code> section</h4>
+<h3>class_data_item</h3>
+<h4>referenced from class_def_item</h4>
+<h4>appears in the data section</h4>
 <h4>alignment: none (byte-aligned)</h4>
 
 <table class="format">
@@ -1905,7 +1902,7 @@
 <p><b>Note:</b> All elements' <code>field_id</code>s and
 <code>method_id</code>s must refer to the same defining class.</p>
 
-<h3><code>encoded_field</code> Format</h3>
+<h3>encoded_field Format</h3>
 
 <table class="format">
 <thead>
@@ -1935,7 +1932,7 @@
 </tbody>
 </table>
 
-<h3><code>encoded_method</code> Format</h3>
+<h3>encoded_method Format</h3>
 
 <table class="format">
 <thead>
@@ -1975,10 +1972,9 @@
 </tbody>
 </table>
 
-<h3><code>type_list</code></h3>
-<h4>referenced from <code>class_def_item</code> and
-<code>proto_id_item</code></h4>
-<h4>appears in the <code>data</code> section</h4>
+<h3>type_list</h3>
+<h4>referenced from class_def_item and proto_id_item</h4>
+<h4>appears in the data section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -2003,7 +1999,7 @@
 </tbody>
 </table>
 
-<h3><code>type_item</code> Format</h3>
+<h3>type_item Format</h3>
 
 <table class="format">
 <thead>
@@ -2022,9 +2018,9 @@
 </tbody>
 </table>
 
-<h3><code>code_item</code></h3>
-<h4>referenced from <code>encoded_method</code></h4>
-<h4>appears in the <code>data</code> section</h4>
+<h3>code_item</h3>
+<h4>referenced from encoded_method</h4>
+<h4>appears in the data section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -2119,7 +2115,7 @@
 </tbody>
 </table>
 
-<h3><code>try_item</code> Format </h3>
+<h3>try_item Format</h3>
 
 <table class="format">
 <thead>
@@ -2157,7 +2153,7 @@
 </tbody>
 </table>
 
-<h3><code>encoded_catch_handler_list</code> Format</h3>
+<h3>encoded_catch_handler_list Format</h3>
 
 <table class="format">
 <thead>
@@ -2182,7 +2178,7 @@
 </tbody>
 </table>
 
-<h3><code>encoded_catch_handler</code> Format</h3>
+<h3>encoded_catch_handler Format</h3>
 
 <table class="format">
 <thead>
@@ -2222,7 +2218,7 @@
 </tbody>
 </table>
 
-<h3><code>encoded_type_addr_pair</code> Format</h3>
+<h3>encoded_type_addr_pair Format</h3>
 
 <table class="format">
 <thead>
@@ -2248,9 +2244,9 @@
 </tbody>
 </table>
 
-<h3><code>debug_info_item</code></h3>
-<h4>referenced from <code>code_item</code></h4>
-<h4>appears in the <code>data</code> section</h4>
+<h3>debug_info_item</h3>
+<h4>referenced from code_item</h4>
+<h4>appears in the data section</h4>
 <h4>alignment: none (byte-aligned)</h4>
 
 <p>Each <code>debug_info_item</code> defines a DWARF3-inspired byte-coded
@@ -2481,9 +2477,9 @@
 address += (adjusted_opcode / DBG_LINE_RANGE)
 </pre>
 
-<h3><code>annotations_directory_item</code></h3>
-<h4>referenced from <code>class_def_item</code></h4>
-<h4>appears in the <code>data</code> section</h4>
+<h3>annotations_directory_item</h3>
+<h4>referenced from class_def_item</h4>
+<h4>appears in the data section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -2547,7 +2543,7 @@
 <p><b>Note:</b> All elements' <code>field_id</code>s and
 <code>method_id</code>s must refer to the same defining class.</p>
 
-<h3><code>field_annotation</code> Format</h3>
+<h3>field_annotation Format</h3>
 
 <table class="format">
 <thead>
@@ -2577,7 +2573,7 @@
 </tbody>
 </table>
 
-<h3><code>method_annotation</code> Format</h3>
+<h3>method_annotation Format</h3>
 
 <table class="format">
 <thead>
@@ -2607,7 +2603,7 @@
 </tbody>
 </table>
 
-<h3><code>parameter_annotation</code> Format</h3>
+<h3>parameter_annotation Format</h3>
 
 <table class="format">
 <thead>
@@ -2637,9 +2633,9 @@
 </tbody>
 </table>
 
-<h3><code>annotation_set_ref_list</code></h3>
-<h4>referenced from <code>parameter_annotations_item</code></h4>
-<h4>appears in the <code>data</code> section</h4>
+<h3>annotation_set_ref_list</h3>
+<h4>referenced from parameter_annotations_item</h4>
+<h4>appears in the data section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -2664,7 +2660,7 @@
 </tbody>
 </table>
 
-<h3><code>annotation_set_ref_item</code> Format</h3>
+<h3>annotation_set_ref_item Format</h3>
 
 <table class="format">
 <thead>
@@ -2688,12 +2684,10 @@
 </tbody>
 </table>
 
-<h3><code>annotation_set_item</code></h3>
-<h4>referenced from <code>annotations_directory_item</code>,
-<code>field_annotations_item</code>,
-<code>method_annotations_item</code>, and
-<code>annotation_set_ref_item</code></h4>
-<h4>appears in the <code>data</code> section</h4>
+<h3>annotation_set_item</h3>
+<h4>referenced from annotations_directory_item, field_annotations_item, 
+method_annotations_item, and annotation_set_ref_item</h4>
+<h4>appears in the data section</h4>
 <h4>alignment: 4 bytes</h4>
 
 <table class="format">
@@ -2720,7 +2714,7 @@
 </tbody>
 </table>
 
-<h3><code>annotation_off_item</code> Format</h3>
+<h3>annotation_off_item Format</h3>
 
 <table class="format">
 <thead>
@@ -2744,9 +2738,9 @@
 </table>
 
 
-<h3><code>annotation_item</code></h3>
-<h4>referenced from <code>annotation_set_item</code></h4>
-<h4>appears in the <code>data</code> section</h4>
+<h3>annotation_item</h3>
+<h4>referenced from annotation_set_item</h4>
+<h4>appears in the data section</h4>
 <h4>alignment: none (byte-aligned)</h4>
 
 <table class="format">
@@ -2810,9 +2804,9 @@
 </tbody>
 </table>
 
-<h3><code>encoded_array_item</code></h3>
-<h4>referenced from <code>class_def_item</code></h4>
-<h4>appears in the <code>data</code> section</h4>
+<h3>encoded_array_item</h3>
+<h4>referenced from class_def_item</h4>
+<h4>appears in the data section</h4>
 <h4>alignment: none (byte-aligned)</h4>
 
 <table class="format">
@@ -2844,7 +2838,7 @@
 <p>System annotations are represented in <code>.dex</code> files as
 annotations with visibility set to <code>VISIBILITY_SYSTEM</code>.
 
-<h3><code>dalvik.annotation.AnnotationDefault</code></h3>
+<h3>dalvik.annotation.AnnotationDefault</h3>
 <h4>appears on methods in annotation interfaces</h4>
 
 <p>An <code>AnnotationDefault</code> annotation is attached to each
@@ -2870,7 +2864,7 @@
 </tbody>
 </table>
 
-<h3><code>dalvik.annotation.EnclosingClass</code></h3>
+<h3>dalvik.annotation.EnclosingClass</h3>
 <h4>appears on classes</h4>
 
 <p>An <code>EnclosingClass</code> annotation is attached to each class
@@ -2898,7 +2892,7 @@
 </tbody>
 </table>
 
-<h3><code>dalvik.annotation.EnclosingMethod</code></h3>
+<h3>dalvik.annotation.EnclosingMethod</h3>
 <h4>appears on classes</h4>
 
 <p>An <code>EnclosingMethod</code> annotation is attached to each class
@@ -2924,7 +2918,7 @@
 </tbody>
 </table>
 
-<h3><code>dalvik.annotation.InnerClass</code></h3>
+<h3>dalvik.annotation.InnerClass</h3>
 <h4>appears on classes</h4>
 
 <p>An <code>InnerClass</code> annotation is attached to each class
@@ -2961,7 +2955,7 @@
 </tbody>
 </table>
 
-<h3><code>dalvik.annotation.MemberClasses</code></h3>
+<h3>dalvik.annotation.MemberClasses</h3>
 <h4>appears on classes</h4>
 
 <p>A <code>MemberClasses</code> annotation is attached to each class
@@ -2985,7 +2979,7 @@
 </tbody>
 </table>
 
-<h3><code>dalvik.annotation.Signature</code></h3>
+<h3>dalvik.annotation.Signature</h3>
 <h4>appears on classes, fields, and methods</h4>
 
 <p>A <code>Signature</code> annotation is attached to each class,
@@ -3028,7 +3022,7 @@
 </tbody>
 </table>
 
-<h3><code>dalvik.annotation.Throws</code></h3>
+<h3>dalvik.annotation.Throws</h3>
 <h4>appears on methods</h4>
 
 <p>A <code>Throws</code> annotation is attached to each method which is
diff --git a/src/devices/tech/input/input-device-configuration-files.jd b/src/devices/tech/input/input-device-configuration-files.jd
index e5629c3..06c8994 100644
--- a/src/devices/tech/input/input-device-configuration-files.jd
+++ b/src/devices/tech/input/input-device-configuration-files.jd
@@ -123,5 +123,5 @@
 correctly for all internal input devices.</p>
 <h2 id="validation">Validation</h2>
 <p>Make sure to validate your input device configuration files using the
-<a href="/tech/input/validate-keymaps.html">Validate Keymaps</a> tool.</p>
+<a href="validate-keymaps.html">Validate Keymaps</a> tool.</p>
 
diff --git a/src/devices/tech/input/key-character-map-files.jd b/src/devices/tech/input/key-character-map-files.jd
index 7b1ac5b..e60484e 100644
--- a/src/devices/tech/input/key-character-map-files.jd
+++ b/src/devices/tech/input/key-character-map-files.jd
@@ -422,4 +422,4 @@
 or user-selectable keyboard layouts.</p>
 <h2 id="validation">Validation</h2>
 <p>Make sure to validate your key character map files using the
-<a href="/tech/input/validate-keymaps.html">Validate Keymaps</a> tool.</p>
+<a href="validate-keymaps.html">Validate Keymaps</a> tool.</p>
diff --git a/src/devices/tech/input/key-layout-files.jd b/src/devices/tech/input/key-layout-files.jd
index e925881..ecab0ef 100644
--- a/src/devices/tech/input/key-layout-files.jd
+++ b/src/devices/tech/input/key-layout-files.jd
@@ -239,7 +239,7 @@
     input system uses a virtual key map file to translate X / Y touch coordinates
     into Linux key codes, then uses the key layout file to translate
     Linux key codes into Android key codes.</p>
-<p>Refer to the section on <a href="/tech/input/touch-devices.html">Touch Devices</a>
+<p>Refer to the section on <a href="touch-devices.html">Touch Devices</a>
 for more details about virtual key map files.</p>
 <p>The key layout file for the touch screen input device must specify the
 appropriate key mapping and include the <code>VIRTUAL</code> flag for each key.</p>
@@ -281,4 +281,4 @@
 </code></pre>
 <h2 id="validation">Validation</h2>
 <p>Make sure to validate your key layout files using the
-<a href="/tech/input/validate-keymaps.html">Validate Keymaps</a> tool.</p>
+<a href="validate-keymaps.html">Validate Keymaps</a> tool.</p>
diff --git a/src/devices/tech/input/keyboard-devices.jd b/src/devices/tech/input/keyboard-devices.jd
index aa968ac..e7740fe 100644
--- a/src/devices/tech/input/keyboard-devices.jd
+++ b/src/devices/tech/input/keyboard-devices.jd
@@ -37,9 +37,7 @@
 </ul>
 <p>Joysticks are currently classified as keyboards because joystick and gamepad buttons
 are reported by <code>EV_KEY</code> events in the same way keyboard keys are reported.  Thus
-joysticks and gamepads also make use of key map files for configuration.
-Refer to the section on <a href="/tech/input/joystick-devices.html">Joystick Devices</a> for
-more information.</p>
+joysticks and gamepads also make use of key map files for configuration.</p>
 <p>Once an input device has been classified as a keyboard, the system loads the
 input device configuration file and keyboard layout for the keyboard.</p>
 <p>The system then tries to determine additional characteristics of the device.</p>
@@ -170,9 +168,9 @@
 <p>Refer to the following sections for more details about the files that
 participate in keyboard configuration:</p>
 <ul>
-<li><a href="/tech/input/key-layout-files.html">Key Layout Files</a></li>
-<li><a href="/tech/input/key-character-map-files.html">Key Character Map Files</a></li>
-<li><a href="/tech/input/input-device-configuration-files.html">Input Device Configuration Files</a></li>
+<li><a href="key-layout-files.html">Key Layout Files</a></li>
+<li><a href="key-character-map-files.html">Key Character Map Files</a></li>
+<li><a href="input-device-configuration-files.html">Input Device Configuration Files</a></li>
 </ul>
 <h3 id="properties">Properties</h3>
 <p>The following input device configuration properties are used for keyboards.</p>
diff --git a/src/devices/tech/input/migration-guide.jd b/src/devices/tech/input/migration-guide.jd
index dbdf666..ff39dfd 100644
--- a/src/devices/tech/input/migration-guide.jd
+++ b/src/devices/tech/input/migration-guide.jd
@@ -38,7 +38,7 @@
 function input devices.  These files should simple contain a line to set
 the keyboard type to <code>SPECIAL_FUNCTION</code>.</p>
 <p>A good way to ensure that all built-in input devices are appropriately configured
-is to run <a href="/tech/input/dumpsys.html">Dumpsys</a> and look for devices that
+is to run <a href="dumpsys.html">Dumpsys</a> and look for devices that
 are inappropriately using <code>Generic.kcm</code>.</p>
 <h2 id="migrating-to-android-honeycomb-32">Migrating to Android Honeycomb 3.2</h2>
 <p>In Honeycomb 3.2, we added support for joysticks and extended the key layout file
@@ -51,5 +51,5 @@
 multitouch input protocol correctly according to the standard.</p>
 <p>You will also need to update your input device configuration files because some
 properties have been changed to be simpler and more systematic.</p>
-<p>Refer to <a href="/tech/input/touch-devices.html">Touch Devices</a> for more details about
-driver requirements.</p>
\ No newline at end of file
+<p>Refer to <a href="touch-devices.html">Touch Devices</a> for more details about
+driver requirements.</p>
diff --git a/src/devices/tech/input/touch-devices.jd b/src/devices/tech/input/touch-devices.jd
index 21567d3..e7c909a 100644
--- a/src/devices/tech/input/touch-devices.jd
+++ b/src/devices/tech/input/touch-devices.jd
@@ -545,7 +545,7 @@
 <p>Refer to the following sections for more details about the files that
 participate in keyboard configuration:</p>
 <ul>
-<li><a href="/tech/input/input-device-configuration-files.html">Input Device Configuration Files</a></li>
+<li><a href="input-device-configuration-files.html">Input Device Configuration Files</a></li>
 <li><a href="#virtual-key-map-files">Virtual Key Map Files</a></li>
 </ul>
 <h3 id="properties">Properties</h3>
diff --git a/src/devices/tech/security/index.jd b/src/devices/tech/security/index.jd
index 5a79598..2c0186c 100644
--- a/src/devices/tech/security/index.jd
+++ b/src/devices/tech/security/index.jd
@@ -398,7 +398,7 @@
 administrator and enforced by the operating system. Filesystem encryption
 requires the use of a user password, pattern-based screen lock is not supported.</p>
 <p>More details on implementation of filesystem encryption are available at
-<a href="/tech/encryption/android_crypto_implementation.html">https://source.android.com/tech/encryption/android_crypto_implementation.html</a></p>
+<a href="/devices/tech/encryption/android_crypto_implementation.html">https://source.android.com/devices/tech/encryption/android_crypto_implementation.html</a></p>
 
 <h2 id="password-protection">Password Protection</h2>
 <p>Android can be configured to verify a user-supplied password prior to providing
diff --git a/src/index.jd b/src/index.jd
index 5dfd122..7fa4b2f 100644
--- a/src/index.jd
+++ b/src/index.jd
@@ -28,7 +28,7 @@
       <p>
       Android is an open-source software stack for a wide range of mobile devices and a corresponding open-source project led by 
       Google. Here you can find the information and source code you need to learn more about the Android platform. From there you can
-      create custom variants of the Android software stack, build devices and accessories that run on the Android platform,
+      create custom variants of the Android software stack, port devices and accessories to the Android platform,
       and ensure your devices are compatible with the Android compatibility definition.
       </p>
 
@@ -66,8 +66,8 @@
         the Android ecosystem.</p>
       </a>
       <a href="{@docRoot}devices/index.html">
-        <h4>Build Devices</h4>
-        <p>Build devices with the latest Android platform and
+        <h4>Port Android to Devices</h4>
+        <p>Port the latest Android platform and
         create compelling devices that your customers want.</p>
       </a>
 
diff --git a/src/source/build-numbers.jd b/src/source/build-numbers.jd
index cf33d51..886ebf6 100644
--- a/src/source/build-numbers.jd
+++ b/src/source/build-numbers.jd
@@ -125,6 +125,11 @@
 <td>4.2.x</td>
 <td>API level 17</td>
 </tr>
+<tr>
+<td>Jelly Bean</td>
+<td>4.3</td>
+<td>API level 18</td>
+</tr>
 </tbody>
 </table>
 <p>Starting with Cupcake, individual builds are identified with a short
@@ -411,11 +416,25 @@
 <td>android-4.1.1_r6.1</td>
 <td>Nexus 7</td>
 </tr>
+
 <tr>
 <td>JZO54K</td>
 <td>android-4.1.2_r1</td>
 <td>Nexus S, Galaxy Nexus, Nexus 7</td>
 </tr>
+
+<tr>
+<td>JZO54L</td>
+<td>android-4.1.2_r2</td>
+<td></td>
+</tr>
+
+<tr>
+<td>JZO54M</td>
+<td>android-4.1.2_r2.1</td>
+<td></td>
+</tr>
+
 <tr>
 <td>JOP40C</td>
 <td>android-4.2_r1</td>
@@ -443,13 +462,49 @@
 <tr>
 <td>JDQ39</td>
 <td>android-4.2.2_r1</td>
-<td>latest Jelly Bean version, Galaxy Nexus, Nexus 7, Nexus 4, Nexus 10</td>
+<td>Galaxy Nexus, Nexus 7, Nexus 4, Nexus 10</td>
+</tr>
+
+<tr>
+<td>JDQ39B</td>
+<td>android-4.2.2_r1.1</td>
+<td>Nexus 7</td>
+</tr>
+
+<tr>
+<td>JDQ39E</td>
+<td>android-4.2.2_r1.1</td>
+<td>Nexus 4</td>
+</tr>
+
+<tr>
+<td>JWR66L</td>
+<td>android-4.3_w_r0.8</td>
+<td>Nexus 7</td>
+</tr>
+
+<tr>
+<td>JWR66N</td>
+<td>android-4.3_w_r0.9</td>
+<td>Galaxy Nexus, Nexus 7, Nexus 4, Nexus 10</td>
+</tr>
+
+<tr>
+<td>JWR66V</td>
+<td>android-4.3_w_r1</td>
+<td>Galaxy Nexus, Nexus 7 (grouper/tilapia), Nexus 4, Nexus 10</td>
+</tr>
+
+<tr>
+<td>JSS15F</td>
+<td>android-4.3_s_r1</td>
+<td>latest Jelly Bean version, Nexus 7 (flo/deb)</td>
 </tr>
 
 </tbody>
 </table>
 <p>The branches froyo, gingerbread, ics-mr0, ics-mr1, jb-dev,
-jb-mr1-dev, jb-mr1.1-dev
+jb-mr1-dev, jb-mr1.1-dev, jb-mr2-dev
 represent development
 branches that do not exactly match configurations that were tested
 by Google. They might contain a variety of changes in addition to
diff --git a/src/source/building-devices.jd b/src/source/building-devices.jd
index bbf49ba..3b227a8 100644
--- a/src/source/building-devices.jd
+++ b/src/source/building-devices.jd
@@ -29,15 +29,15 @@
 information that is specific to individual devices.</p>
 
 <p>With the current release, it is possible to build for
-Nexus 4, Nexus 10, Nexus 7, and for some variants of Galaxy Nexus.
+Nexus 4, Nexus 7, and for some variants of Galaxy Nexus.
 The exact level of functionality for each device depends on the availability
 of the relevant proprietary hardware-specific binaries.</p>
-<p>For Nexus 4 "mako" and on Nexus 7 "grouper" (Wi-Fi) and "tilapia" (Mobile),
-all configurations can be used,
+<p>For Nexus 4 and Nexus 7, all configurations can be used,
 and all the hardware is functional.
 Due to hardware differences, do not use 4.1.1 on a Nexus 7 that
 was originally sold with 4.1.2 or newer.</p>
-<p>All configurations of Nexus 10 "manta" can be used. On those devices, graphics, audio,
+<p>All configurations of Nexus 10 "manta" can be used with 4.2.2.
+On those devices, graphics, audio,
 Wi-Fi, Bluetooth, camera, NFC, GPS and orientation sensors are functional.</p>
 <p>The variants of Galaxy Nexus that can be used are the GSM/HSPA+ configuration
 "maguro" (only if it was originally sold with a "yakju" or "takju" operating
@@ -76,6 +76,14 @@
 </thead>
 <tbody>
 <tr>
+<td>flo</td>
+<td>Press and hold <em>Volume Down</em>, then press and hold <em>Power</em></td>
+</tr>
+<tr>
+<td>deb</td>
+<td>Press and hold <em>Volume Down</em>, then press and hold <em>Power</em></td>
+</tr>
+<tr>
 <td>manta</td>
 <td>Press and hold both <em>Volume Up</em> and <em>Volume Down</em>, then press and hold <em>Power</em></td>
 </tr>
@@ -85,11 +93,11 @@
 </tr>
 <tr>
 <td>grouper</td>
-<td>Press <em>Power</em> for a second, and press <em>Volume Down</em> when the bootloader logo appears</td>
+<td>Press and hold <em>Volume Down</em>, then press and hold <em>Power</em></td>
 </tr>
 <tr>
 <td>tilapia</td>
-<td>Press <em>Power</em> for a second, and press <em>Volume Down</em> when the bootloader logo appears</td>
+<td>Press and hold <em>Volume Down</em>, then press and hold <em>Power</em></td>
 </tr>
 <tr>
 <td>phantasm</td>
@@ -185,44 +193,54 @@
 </thead>
 <tbody>
 <tr>
+<td>flo</td>
+<td>android-4.3_s_r1 or master</td>
+<td>aosp_flo-userdebug</td>
+</tr>
+<tr>
+<td>deb</td>
+<td>android-4.3_s_r1 or master</td>
+<td>aosp_deb-userdebug</td>
+</tr>
+<tr>
 <td>manta</td>
-<td>android-4.2.2_r1 or master</td>
+<td>android-4.2.2_r1</td>
 <td>full_manta-userdebug</td>
 </tr>
 <tr>
 <td>mako</td>
-<td>android-4.2.2_r1 or master</td>
-<td>full_mako-userdebug</td>
+<td>android-4.3_w_r1 or master</td>
+<td>aosp_mako-userdebug</td>
 </tr>
 <tr>
 <td>grouper</td>
-<td>android-4.2.2_r1 or master</td>
-<td>full_grouper-userdebug</td>
+<td>android-4.3_w_r1 or master</td>
+<td>aosp_grouper-userdebug</td>
 </tr>
 <tr>
 <td>tilapia</td>
-<td>android-4.2.2_r1 or master</td>
-<td>full_grouper-userdebug</td>
+<td>android-4.3_w_r1 or master</td>
+<td>aosp_tilapia-userdebug</td>
 </tr>
 <tr>
 <td>maguro</td>
-<td>android-4.2.2_r1 or master</td>
-<td>full_maguro-userdebug</td>
+<td>android-4.3_w_r1 or master</td>
+<td>aosp_maguro-userdebug</td>
 </tr>
 <tr>
 <td>toro</td>
-<td>android-4.2.2_r1 or master</td>
-<td>full_toro-userdebug</td>
+<td>android-4.3_w_r1 or master</td>
+<td>aosp_toro-userdebug</td>
 </tr>
 <tr>
 <td>toroplus</td>
 <td>master</td>
-<td>full_toroplus-userdebug</td>
+<td>aosp_toroplus-userdebug</td>
 </tr>
 <tr>
 <td>panda</td>
 <td>master</td>
-<td>full_panda-userdebug</td>
+<td>aosp_panda-userdebug</td>
 </tr>
 <tr>
 <td>wingray</td>
@@ -270,4 +288,4 @@
 for Nexus S and Nexus S 4G
 are available from
 <a href="https://developers.google.com/android/nexus/images">Google's factory image page</a>.</p>
-<p>Factory images for the Motorola Xoom are distributed directly by Motorola.</p>
\ No newline at end of file
+<p>Factory images for the Motorola Xoom are distributed directly by Motorola.</p>
diff --git a/src/source/building-kernels.jd b/src/source/building-kernels.jd
index 3cc6c1e..092e3d3 100644
--- a/src/source/building-kernels.jd
+++ b/src/source/building-kernels.jd
@@ -40,6 +40,18 @@
     <th>Build configuration</th>
   </tr>
   <tr>
+    <td>flo</td>
+    <td>device/asus/flo-kernel/kernel</td>
+    <td>kernel/msm</td>
+    <td>flo_defconfig</td>
+  </tr>
+  <tr>
+    <td>deb</td>
+    <td>device/asus/flo-kernel/kernel</td>
+    <td>kernel/msm</td>
+    <td>flo_defconfig</td>
+  </tr>
+  <tr>
     <td>manta</td>
     <td>device/samsung/manta/kernel</td>
     <td>kernel/exynos</td>
@@ -173,4 +185,4 @@
 <p>
 The kernel binary is output as `arch/arm/boot/zImage`, and needs to be copied
 into the Android source tree in order to build the matching boot image.
-</p>
\ No newline at end of file
+</p>
diff --git a/src/source/building-running.jd b/src/source/building-running.jd
index 3fcd457..ae4116c 100644
--- a/src/source/building-running.jd
+++ b/src/source/building-running.jd
@@ -50,7 +50,7 @@
 <h2 id="choose-a-target">Choose a Target</h2>
 <p>Choose which target to build with <code>lunch</code>.  The exact configuration can be passed as
 an argument, e.g. </p>
-<pre><code>$ lunch full-eng
+<pre><code>$ lunch aosp_arm-eng
 </code></pre>
 <p>The example above refers to a complete build for the emulator, with all debugging enabled.</p>
 <p>If run with no arguments <code>lunch</code> will prompt you to choose a target from the menu. </p>
@@ -66,19 +66,19 @@
 </thead>
 <tbody>
 <tr>
-<td>full</td>
-<td>emulator</td>
-<td>fully configured with all languages, apps, input methods</td>
+<td>aosp_arm</td>
+<td>ARM emulator</td>
+<td>AOSP, fully configured with all languages, apps, input methods</td>
 </tr>
 <tr>
-<td>full_maguro</td>
+<td>aosp_maguro</td>
 <td>maguro</td>
-<td><code>full</code> build running on Galaxy Nexus GSM/HSPA+ ("maguro")</td>
+<td>AOSP, running on Galaxy Nexus GSM/HSPA+ ("maguro")</td>
 </tr>
 <tr>
-<td>full_panda</td>
+<td>aosp_panda</td>
 <td>panda</td>
-<td><code>full</code> build running on PandaBoard ("panda")</td>
+<td>AOSP, running on PandaBoard ("panda")</td>
 </tr>
 </tbody>
 </table>
diff --git a/src/source/faqs.jd b/src/source/faqs.jd
index 7c1e5d4..625afcb 100644
--- a/src/source/faqs.jd
+++ b/src/source/faqs.jd
@@ -181,7 +181,7 @@
 <p>Once submitted, changes need to be accepted by a designated Approver.
 Approvers are typically Google employees, but the same approvers are
 responsible for all submissions, regardless of origin.</p>
-<p>You can find more information on this topic at the <a href="source/submit-patches.html">Submitting Patches</a> page.</p>
+<p>You can find more information on this topic at the <a href="{@docRoot}source/submit-patches.html">Submitting Patches</a> page.</p>
 <a href="#top">Back to top</a>  
 <h2 id="compatibility">Compatibility</h2>
 <h3 id="what-does-compatibility-mean">What does "compatibility" mean?</h3>
