diff --git a/CHANGES b/CHANGES
new file mode 100644
index 0000000..e2a6266
--- /dev/null
+++ b/CHANGES
@@ -0,0 +1,34 @@
+1.1.6 (2019-05-24)
+
+        * Updated to nlbuild-autotools 1.6.11.
+
+1.1.5 (2019-04-30)
+
+        * Updated to nlbuild-autotools 1.6.9.
+
+1.1.4 (2019-04-09)
+
+        * Updated to nlbuild-autotools 1.6.6.
+
+        * Addressed a documentation typo.
+
+1.1.3 (2018-11-19)
+
+        * Updated to nlbuild-autotools 1.6.5.
+
+1.1.2 (2018-11-15)
+
+        * Updated to nlbuild-autotools 1.6.4.
+
+1.1.1 (2018-04-26)
+
+        * Updated to nlbuild-autotools 1.5.2.
+
+1.1 (2018-04-19)
+
+        * Updated to utilize nlbuild-autotools 1.5.0, removing inlined
+          copy of nlunit-test in the process.
+
+1.0 (2017-06-29)
+
+	* First public release to Github.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..2827b7d
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,27 @@
+Want to contribute? Great! First, read this page (including the small print at the end).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement]
+(https://cla.developers.google.com/about/google-individual)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase, so we need your permission to use and distribute your code. We also
+need to be sure of various other things—for instance that you'll tell us if you
+know that your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+Before you start working on a larger contribution, you should get in touch with
+us first through the issue tracker with your idea so that we can help out and
+possibly guide you. Coordinating up front makes it much easier to avoid
+frustration later on.
+
+### Code reviews
+All submissions, including submissions by project members, require review. We
+use Github pull requests for this purpose.
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the
+[Software Grant and Corporate Contributor License Agreement]
+(https://cla.developers.google.com/about/google-corporate).
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..cddf2a0
--- /dev/null
+++ b/README.md
@@ -0,0 +1,45 @@
+[![Build Status][nlio-travis-svg]][nlio-travis]
+[![Coverage Status][nlio-codecov-svg]][nlio-codecov]
+
+Nest Labs Memory Mapped I/O
+===========================
+
+# Introduction
+
+Nest Labs Memory Mapped I/O (NLIO) is designed to provide both C
+and C++ language bindings to macros and functions for:
+
+1. Determining, at both compile- and run-time, the byte ordering
+   of the target system.
+2. Performing in place byte-swapping of compile-time constants
+   via the C preprocessor as well as functions for performing
+   byte-swapping by value and in place by pointer for 16-, 32-, and
+   64-bit types.
+3. Safely performing simple, efficient memory-mapped accesses,
+   potentially to unaligned memory locations, with or without byte
+   reordering, to 8-, 16-, 32-, and 64-bit quantities. Functions
+   both with and without pointer management are also available.
+
+[nlio-travis]: https://travis-ci.org/nestlabs/nlio
+[nlio-travis-svg]: https://travis-ci.org/nestlabs/nlio.svg?branch=master
+[nlio-codecov]: https://codecov.io/gh/nestlabs/nlio
+[nlio-codecov-svg]: https://codecov.io/gh/nestlabs/nlio/branch/master/graph/badge.svg
+
+# Interact
+
+There are numerous avenues for nlio support:
+
+  * Bugs and feature requests — [submit to the Issue Tracker](https://github.com/nestlabs/nlio/issues)
+  * Google Groups — discussion and announcements
+    * [nlio-announce](https://groups.google.com/forum/#!forum/nlio-announce) — release notes and new updates on nlio
+    * [nlio-users](https://groups.google.com/forum/#!forum/nlio-users) — discuss use of and enhancements to nlio
+
+# Versioning
+
+nlio follows the [Semantic Versioning guidelines](http://semver.org/) 
+for release cycle transparency and to maintain backwards compatibility.
+
+# License
+
+nlio is released under the [Apache License, Version 2.0 license](https://opensource.org/licenses/Apache-2.0). 
+See the `LICENSE` file for more information.
diff --git a/include/nlbyteorder-big.h b/include/nlbyteorder-big.h
new file mode 100644
index 0000000..959604b
--- /dev/null
+++ b/include/nlbyteorder-big.h
@@ -0,0 +1,246 @@
+/**
+ *    Copyright 2012-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines defines functions for performing by value
+ *      byte reordering for 16-, 32-, and 64-bit quantities both
+ *      to-and-from the target system (i.e. host) byte ordering
+ *      to-and-from both little and big endian byte ordering,
+ *      specifically for big endian target systems.
+ */
+
+#ifndef NLBYTEORDER_BIG_H
+#define NLBYTEORDER_BIG_H
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 16-bit value, presumed to
+ * be in little endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 16-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint16_t nlByteOrderSwap16LittleToHost(uint16_t inValue)
+{
+    return nlByteOrderSwap16(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 32-bit value, presumed to
+ * be in little endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 32-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint32_t nlByteOrderSwap32LittleToHost(uint32_t inValue)
+{
+    return nlByteOrderValueSwap32(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 64-bit value, presumed to
+ * be in little endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 64-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint64_t nlByteOrderSwap64LittleToHost(uint64_t inValue)
+{
+    return nlByteOrderValueSwap64(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 16-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to little endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 16-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint16_t nlByteOrderSwap16HostToLittle(uint16_t inValue)
+{
+    return nlByteOrderValueSwap16(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 32-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to little endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 32-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint32_t nlByteOrderSwap32HostToLittle(uint32_t inValue)
+{
+    return nlByteOrderValueSwap32(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 64-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to little endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 64-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint64_t nlByteOrderSwap64HostToLittle(uint64_t inValue)
+{
+    return nlByteOrderValueSwap64(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 16-bit value, presumed to
+ * be in big endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 16-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint16_t nlByteOrderSwap16BigToHost(uint16_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 32-bit value, presumed to
+ * be in big endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 32-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint32_t nlByteOrderSwap32BigToHost(uint32_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 64-bit value, presumed to
+ * be in big endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 64-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint64_t nlByteOrderSwap64BigToHost(uint64_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 16-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to big endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 16-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint16_t nlByteOrderSwap16HostToBig(uint16_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 32-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to big endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 32-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint32_t nlByteOrderSwap32HostToBig(uint32_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 64-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to big endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 64-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint64_t nlByteOrderSwap64HostToBig(uint64_t inValue)
+{
+    return inValue;
+}
+
+#endif /* NLBYTEORDER_BIG_H */
+
diff --git a/include/nlbyteorder-little.h b/include/nlbyteorder-little.h
new file mode 100644
index 0000000..72236ba
--- /dev/null
+++ b/include/nlbyteorder-little.h
@@ -0,0 +1,246 @@
+/**
+ *    Copyright 2012-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines defines functions for performing by value
+ *      byte reordering for 16-, 32-, and 64-bit quantities both
+ *      to-and-from the target system (i.e. host) byte ordering
+ *      to-and-from both little and big endian byte ordering,
+ *      specifically for little endian target systems.
+ */
+
+#ifndef NLBYTEORDER_LITTLE_H
+#define NLBYTEORDER_LITTLE_H
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 16-bit value, presumed to
+ * be in little endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 16-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint16_t nlByteOrderSwap16LittleToHost(uint16_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 32-bit value, presumed to
+ * be in little endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 32-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint32_t nlByteOrderSwap32LittleToHost(uint32_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 64-bit value, presumed to
+ * be in little endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 64-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint64_t nlByteOrderSwap64LittleToHost(uint64_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 16-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to little endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 16-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint16_t nlByteOrderSwap16HostToLittle(uint16_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 32-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to little endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 32-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint32_t nlByteOrderSwap32HostToLittle(uint32_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 64-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to little endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this is a no-op and
+ * on big endian target systems, this performs a reordering.
+ *
+ * @param[in]  inValue  The 64-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint64_t nlByteOrderSwap64HostToLittle(uint64_t inValue)
+{
+    return inValue;
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 16-bit value, presumed to
+ * be in big endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 16-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint16_t nlByteOrderSwap16BigToHost(uint16_t inValue)
+{
+    return nlByteOrderValueSwap16(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 32-bit value, presumed to
+ * be in big endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 32-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint32_t nlByteOrderSwap32BigToHost(uint32_t inValue)
+{
+    return nlByteOrderValueSwap32(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 64-bit value, presumed to
+ * be in big endian byte ordering to the target system (i.e. host)
+ * byte ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 64-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint64_t nlByteOrderSwap64BigToHost(uint64_t inValue)
+{
+    return nlByteOrderValueSwap64(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 16-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to big endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 16-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint16_t nlByteOrderSwap16HostToBig(uint16_t inValue)
+{
+    return nlByteOrderValueSwap16(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 32-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to big endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 32-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint32_t nlByteOrderSwap32HostToBig(uint32_t inValue)
+{
+    return nlByteOrderValueSwap32(inValue);
+}
+
+/**
+ * This conditionally performs, as necessary for the target system, a
+ * byte order swap by value of the specified 64-bit value, presumed to
+ * be in target system (i.e. host) byte ordering to big endian byte
+ * ordering.
+ *
+ * Consequently, on little endian target systems, this performs a
+ * reordering and on big endian target systems, this is a no-op.
+ *
+ * @param[in]  inValue  The 64-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint64_t nlByteOrderSwap64HostToBig(uint64_t inValue)
+{
+    return nlByteOrderValueSwap64(inValue);
+}
+
+#endif /* NLBYTEORDER_LITTLE_H */
+
diff --git a/include/nlbyteorder.h b/include/nlbyteorder.h
new file mode 100644
index 0000000..b56ffe6
--- /dev/null
+++ b/include/nlbyteorder.h
@@ -0,0 +1,322 @@
+/**
+ *    Copyright 2012-2017 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines macros for performing in place byte-
+ *      swapping of compile-time constants via the C preprocessor as
+ *      well as functions for performing byte-swapping by value and in
+ *      place by pointer for 16-, 32-, and 64-bit types.
+ */
+
+#ifndef NLBYTEORDER_H
+#define NLBYTEORDER_H
+
+#include <nlio-private.h>
+
+#include <stdint.h>
+
+/*
+ * If we are compiling under clang, GCC, or any such compatible
+ * compiler, in which -fno-builtins or -ffreestanding might be
+ * asserted, thereby eliminating built-in function optimization, we
+ * STILL want to leverage built-in bswap{16,32,64}, if available. We
+ * want this because it allows the compiler to use
+ * architecture-specific machine instructions or inline code
+ * generation to optimize an otherwise-generic and non-optimized code
+ * for byte reordering, which is exactly the kind of efficiency that
+ * would be expected of nlByteOrder.
+ */
+
+#if __nlIOHasBuiltin(__builtin_bswap16)
+#define __nlBYTEORDER_BSWAP16 __builtin_bswap16
+#else
+#define __nlBYTEORDER_BSWAP16 nlByteOrderConstantSwap16
+#endif
+
+#if __nlIOHasBuiltin(__builtin_bswap32)
+#define __nlBYTEORDER_BSWAP32 __builtin_bswap32
+#else
+#define __nlBYTEORDER_BSWAP32 nlByteOrderConstantSwap32
+#endif
+
+#if __nlIOHasBuiltin(__builtin_bswap64)
+#define __nlBYTEORDER_BSWAP64 __builtin_bswap64
+#else
+#define __nlBYTEORDER_BSWAP64 nlByteOrderConstantSwap64
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ *  @def nlByteOrderConstantSwap16
+ *
+ *  @brief
+ *     Performs a preprocessor-compatible in place byte swap of the
+ *     provided 16-bit value.
+ *
+ */
+#define nlByteOrderConstantSwap16(c)                                 \
+    ((uint16_t)                                                      \
+        ((((uint16_t)(c) & (uint16_t)0x00ffU) << 8) |                \
+         (((uint16_t)(c) & (uint16_t)0xff00U) >> 8)))
+
+/**
+ *  @def nlByteOrderConstantSwap32
+ *
+ *  @brief
+ *     Performs a preprocessor-compatible in place byte swap of the
+ *     provided 32-bit value.
+ *
+ */
+#define nlByteOrderConstantSwap32(c)                                 \
+    ((uint32_t)                                                      \
+        ((((uint32_t)(c) & (uint32_t)0x000000ffUL) << 24) |          \
+         (((uint32_t)(c) & (uint32_t)0x0000ff00UL) <<  8) |          \
+         (((uint32_t)(c) & (uint32_t)0x00ff0000UL) >>  8) |          \
+         (((uint32_t)(c) & (uint32_t)0xff000000UL) >> 24)))
+
+/**
+ *  @def nlByteOrderConstantSwap64
+ *
+ *  @brief
+ *     Performs a preprocessor-compatible in place byte swap of the
+ *     provided 64-bit value.
+ *
+ */
+#define nlByteOrderConstantSwap64(c)                                 \
+    ((uint64_t)                                                      \
+        ((((uint64_t)(c) & (uint64_t)0x00000000000000ffULL) << 56) | \
+         (((uint64_t)(c) & (uint64_t)0x000000000000ff00ULL) << 40) | \
+         (((uint64_t)(c) & (uint64_t)0x0000000000ff0000ULL) << 24) | \
+         (((uint64_t)(c) & (uint64_t)0x00000000ff000000ULL) <<  8) | \
+         (((uint64_t)(c) & (uint64_t)0x000000ff00000000ULL) >>  8) | \
+         (((uint64_t)(c) & (uint64_t)0x0000ff0000000000ULL) >> 24) | \
+         (((uint64_t)(c) & (uint64_t)0x00ff000000000000ULL) >> 40) | \
+         (((uint64_t)(c) & (uint64_t)0xff00000000000000ULL) >> 56)))
+
+/**
+ *  @def NLBYTEORDER_LITTLE_ENDIAN
+ *
+ *  @brief
+ *     Constant preprocessor definition used to test #NLBYTEORDER
+ *     against to determine whether the target system uses little
+ *     endian byte ordering.
+ *
+ *  @code
+ *  #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
+ *  
+ *      Do something that is little endian byte ordering-specific.
+ *
+ *  #endif
+ *  @endcode
+ *
+ */
+#define NLBYTEORDER_LITTLE_ENDIAN       0x1234
+
+/**
+ *  @def NLBYTEORDER_BIG_ENDIAN
+ *
+ *  @brief
+ *     Constant preprocessor definition used to test #NLBYTEORDER
+ *     against to determine whether the target system uses big
+ *     endian byte ordering.
+ *
+ *  @code
+ *  #if NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
+ *  
+ *      Do something that is little endian byte ordering-specific.
+ *
+ *  #endif
+ *  @endcode
+ *
+ */
+#define NLBYTEORDER_BIG_ENDIAN          0x4321
+
+/**
+ *  @def NLBYTEORDER_UNKNOWN_ENDIAN
+ *
+ *  @brief
+ *     Constant preprocessor definition used to test #NLBYTEORDER
+ *     against to determine whether the target system uses unknown
+ *     byte ordering.
+ *
+ *  @code
+ *  #elif NLBYTEORDER == NLBYTEORDER_UNKNOWN_ENDIAN
+ *  #error "Unknown byte ordering!"
+ *  #endif
+ *  @endcode
+ *
+ */
+#define NLBYTEORDER_UNKNOWN_ENDIAN      0xFFFF
+
+/**
+ *  @def NLBYTEORDER
+ *
+ *  @brief
+ *     Constant preprocessor definition containing the target system
+ *     byte ordering. May be one of:
+ *
+ *       - NLBYTEORDER_BIG_ENDIAN
+ *       - NLBYTEORDER_LITTLE_ENDIAN
+ *       - NLBYTEORDER_UNKNOWN_ENDIAN
+ *
+ */
+#if defined(__LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__) || (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define NLBYTEORDER NLBYTEORDER_LITTLE_ENDIAN
+#elif defined(__BIG_ENDIAN) || defined(__BIG_ENDIAN__) || (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define NLBYTEORDER NLBYTEORDER_BIG_ENDIAN
+#else
+#error "Endianness undefined!"
+#define NLBYTEORDER NLBYTEORDER_UNKNOWN_ENDIAN
+#endif /* defined(__LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__) || (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) */
+
+enum {
+    nlByteOrderUnknown	    = NLBYTEORDER_UNKNOWN_ENDIAN,
+    nlByteOrderLittleEndian = NLBYTEORDER_LITTLE_ENDIAN,
+    nlByteOrderBigEndian    = NLBYTEORDER_BIG_ENDIAN
+};
+
+/**
+ * This represents a type for a byte ordering.
+ */
+typedef uint16_t nlByteOrder;
+
+/**
+ * This returns the byte order of the current system.
+ *
+ * @return The byte order of the current system.
+ */
+static inline nlByteOrder nlByteOrderGetCurrent(void)
+{
+#if (NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN)
+    return nlByteOrderLittleEndian;
+#elif (NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN)
+    return nlByteOrderBigEndian;
+#else
+    return nlByteOrderUnknown;
+#endif
+}
+
+/**
+ * This unconditionally performs a byte order swap by value of the
+ * specified 16-bit value.
+ *
+ * @param[in]  inValue  The 16-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint16_t nlByteOrderValueSwap16(uint16_t inValue)
+{
+    return __nlBYTEORDER_BSWAP16(inValue);
+}
+
+/**
+ * This unconditionally performs a byte order swap by value of the
+ * specified 32-bit value.
+ *
+ * @param[in]  inValue  The 32-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint32_t nlByteOrderValueSwap32(uint32_t inValue)
+{
+    return __nlBYTEORDER_BSWAP32(inValue);
+}
+
+/**
+ * This unconditionally performs a byte order swap by value of the
+ * specified 64-bit value.
+ *
+ * @param[in]  inValue  The 64-bit value to be byte order swapped.
+ *
+ * @return The input value, byte order swapped.
+ */
+static inline uint64_t nlByteOrderValueSwap64(uint64_t inValue)
+{
+    return __nlBYTEORDER_BSWAP64(inValue);
+}
+
+/**
+ * This unconditionally performs a byte order swap by pointer in place
+ * of the specified 16-bit value.
+ *
+ * @warning  The input value is assumed to be on a natural alignment
+ * boundary for the target system. It is the responsibility of the
+ * caller to perform any necessary alignment to avoid system faults
+ * for systems that do not support unaligned accesses.
+ *
+ * @param[inout]  inValue  A pointer to the 16-bit value to be byte
+ *                         order swapped.
+ */
+static inline void nlByteOrderPointerSwap16(uint16_t *inValue)
+{
+    *inValue = nlByteOrderValueSwap16(*inValue);
+}
+
+/**
+ * This unconditionally performs a byte order swap by pointer in place
+ * of the specified 32-bit value.
+ *
+ * @warning  The input value is assumed to be on a natural alignment
+ * boundary for the target system. It is the responsibility of the
+ * caller to perform any necessary alignment to avoid system faults
+ * for systems that do not support unaligned accesses.
+ *
+ * @param[inout]  inValue  A pointer to the 32-bit value to be byte
+ *                         order swapped.
+ */
+static inline void nlByteOrderPointerSwap32(uint32_t *inValue)
+{
+    *inValue = nlByteOrderValueSwap32(*inValue);
+}
+
+/**
+ * This unconditionally performs a byte order swap by pointer in place
+ * of the specified 64-bit value.
+ *
+ * @warning  The input value is assumed to be on a natural alignment
+ * boundary for the target system. It is the responsibility of the
+ * caller to perform any necessary alignment to avoid system faults
+ * for systems that do not support unaligned accesses.
+ *
+ * @param[inout]  inValue  A pointer to the 64-bit value to be byte
+ *                         order swapped.
+ */
+static inline void nlByteOrderPointerSwap64(uint64_t *inValue)
+{
+    *inValue = nlByteOrderValueSwap64(*inValue);
+}
+
+#if (NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN)
+#include <nlbyteorder-little.h>
+#elif (NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN)
+#include <nlbyteorder-big.h>
+#endif /* (NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN) */
+
+#ifdef __cplusplus
+}
+#endif
+
+#undef __nlBYTEORDER_BSWAP16
+#undef __nlBYTEORDER_BSWAP32
+#undef __nlBYTEORDER_BSWAP64
+
+#endif /* NLBYTEORDER_H */
+
+
diff --git a/include/nlbyteorder.hpp b/include/nlbyteorder.hpp
new file mode 100644
index 0000000..7735b7d
--- /dev/null
+++ b/include/nlbyteorder.hpp
@@ -0,0 +1,378 @@
+/**
+ *    Copyright 2012-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines C++ functions for performing byte-swapping
+ *      by value and in place by pointer for 16-, 32-, and 64-bit
+ *      types.
+ *
+ */
+
+#ifndef NLBYTEORDER_HPP
+#define NLBYTEORDER_HPP
+
+#include <nlbyteorder.h>
+
+namespace nl
+{
+
+    namespace ByteOrder
+    {
+        enum {
+            Unknown	 = nlByteOrderUnknown,
+            LittleEndian = nlByteOrderLittleEndian,
+            BigEndian    = nlByteOrderBigEndian    
+        };
+
+        /**
+         * This represents a type for a byte ordering.
+         */
+        typedef nlByteOrder ByteOrder;
+
+        /**
+         * This returns the byte order of the current system.
+         *
+         * @return The byte order of the current system.
+         */
+        inline ByteOrder GetCurrent(void)
+        {
+            return nlByteOrderGetCurrent();
+        }
+
+        /**
+         * This unconditionally performs a byte order swap by value of the
+         * specified 16-bit value.
+         *
+         * @param[in]  inValue  The 16-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint16_t Swap16(uint16_t inValue)
+        {
+            return nlByteOrderValueSwap16(inValue);
+        }
+
+        /**
+         * This unconditionally performs a byte order swap by value of the
+         * specified 32-bit value.
+         *
+         * @param[in]  inValue  The 32-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint32_t Swap32(uint32_t inValue)
+        {
+            return nlByteOrderValueSwap32(inValue);
+        }
+
+        /**
+         * This unconditionally performs a byte order swap by value of the
+         * specified 64-bit value.
+         *
+         * @param[in]  inValue  The 64-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint64_t Swap64(uint64_t inValue)
+        {
+            return nlByteOrderValueSwap64(inValue);
+        }
+
+        /**
+         * This unconditionally performs a byte order swap by pointer in place
+         * of the specified 16-bit value.
+         *
+         * @warning  The input value is assumed to be on a natural alignment
+         * boundary for the target system. It is the responsibility of the
+         * caller to perform any necessary alignment to avoid system faults
+         * for systems that do not support unaligned accesses.
+         *
+         * @param[inout]  inValue  A pointer to the 16-bit value to be byte
+         *                         order swapped.
+         */
+        inline void Swap16(uint16_t *inValue)
+        {
+            nlByteOrderPointerSwap16(inValue);
+        }
+
+        /**
+         * This unconditionally performs a byte order swap by pointer in place
+         * of the specified 32-bit value.
+         *
+         * @warning  The input value is assumed to be on a natural alignment
+         * boundary for the target system. It is the responsibility of the
+         * caller to perform any necessary alignment to avoid system faults
+         * for systems that do not support unaligned accesses.
+         *
+         * @param[inout]  inValue  A pointer to the 32-bit value to be byte
+         *                         order swapped.
+         */
+        inline void Swap32(uint32_t *inValue)
+        {
+            nlByteOrderPointerSwap32(inValue);
+        }
+
+        /**
+         * This unconditionally performs a byte order swap by pointer in place
+         * of the specified 64-bit value.
+         *
+         * @warning  The input value is assumed to be on a natural alignment
+         * boundary for the target system. It is the responsibility of the
+         * caller to perform any necessary alignment to avoid system faults
+         * for systems that do not support unaligned accesses.
+         *
+         * @param[inout]  inValue  A pointer to the 64-bit value to be byte
+         *                         order swapped.
+         */
+        inline void Swap64(uint64_t *inValue)
+        {
+            nlByteOrderPointerSwap64(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 16-bit value, presumed to
+         * be in little endian byte ordering to the target system (i.e. host)
+         * byte ordering.
+         *
+         * Consequently, on little endian target systems, this is a no-op and
+         * on big endian target systems, this performs a reordering.
+         *
+         * @param[in]  inValue  The 16-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint16_t Swap16LittleToHost(uint16_t inValue)
+        {
+            return nlByteOrderSwap16LittleToHost(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 32-bit value, presumed to
+         * be in little endian byte ordering to the target system (i.e. host)
+         * byte ordering.
+         *
+         * Consequently, on little endian target systems, this is a no-op and
+         * on big endian target systems, this performs a reordering.
+         *
+         * @param[in]  inValue  The 32-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint32_t Swap32LittleToHost(uint32_t inValue)
+        {
+            return nlByteOrderSwap32LittleToHost(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 64-bit value, presumed to
+         * be in little endian byte ordering to the target system (i.e. host)
+         * byte ordering.
+         *
+         * Consequently, on little endian target systems, this is a no-op and
+         * on big endian target systems, this performs a reordering.
+         *
+         * @param[in]  inValue  The 64-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint64_t Swap64LittleToHost(uint64_t inValue)
+        {
+            return nlByteOrderSwap64LittleToHost(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 16-bit value, presumed to
+         * be in target system (i.e. host) byte ordering to little endian byte
+         * ordering.
+         *
+         * Consequently, on little endian target systems, this is a no-op and
+         * on big endian target systems, this performs a reordering.
+         *
+         * @param[in]  inValue  The 16-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint16_t Swap16HostToLittle(uint16_t inValue)
+        {
+            return nlByteOrderSwap16HostToLittle(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 32-bit value, presumed to
+         * be in target system (i.e. host) byte ordering to little endian byte
+         * ordering.
+         *
+         * Consequently, on little endian target systems, this is a no-op and
+         * on big endian target systems, this performs a reordering.
+         *
+         * @param[in]  inValue  The 32-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint32_t Swap32HostToLittle(uint32_t inValue)
+        {
+            return nlByteOrderSwap32HostToLittle(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 64-bit value, presumed to
+         * be in target system (i.e. host) byte ordering to little endian byte
+         * ordering.
+         *
+         * Consequently, on little endian target systems, this is a no-op and
+         * on big endian target systems, this performs a reordering.
+         *
+         * @param[in]  inValue  The 64-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint64_t Swap64HostToLittle(uint64_t inValue)
+        {
+            return nlByteOrderSwap64HostToLittle(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 16-bit value, presumed to
+         * be in big endian byte ordering to the target system (i.e. host)
+         * byte ordering.
+         *
+         * Consequently, on little endian target systems, this performs a
+         * reordering and on big endian target systems, this is a no-op.
+         *
+         * @param[in]  inValue  The 16-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint16_t Swap16BigToHost(uint16_t inValue)
+        {
+            return nlByteOrderSwap16BigToHost(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 32-bit value, presumed to
+         * be in big endian byte ordering to the target system (i.e. host)
+         * byte ordering.
+         *
+         * Consequently, on little endian target systems, this performs a
+         * reordering and on big endian target systems, this is a no-op.
+         *
+         * @param[in]  inValue  The 32-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint32_t Swap32BigToHost(uint32_t inValue)
+        {
+            return nlByteOrderSwap32BigToHost(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 64-bit value, presumed to
+         * be in big endian byte ordering to the target system (i.e. host)
+         * byte ordering.
+         *
+         * Consequently, on little endian target systems, this performs a
+         * reordering and on big endian target systems, this is a no-op.
+         *
+         * @param[in]  inValue  The 64-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint64_t Swap64BigToHost(uint64_t inValue)
+        {
+            return nlByteOrderSwap64BigToHost(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 16-bit value, presumed to
+         * be in target system (i.e. host) byte ordering to big endian byte
+         * ordering.
+         *
+         * Consequently, on little endian target systems, this performs a
+         * reordering and on big endian target systems, this is a no-op.
+         *
+         * @param[in]  inValue  The 16-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint16_t Swap16HostToBig(uint16_t inValue)
+        {
+            return nlByteOrderSwap16HostToBig(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 32-bit value, presumed to
+         * be in target system (i.e. host) byte ordering to big endian byte
+         * ordering.
+         *
+         * Consequently, on little endian target systems, this performs a
+         * reordering and on big endian target systems, this is a no-op.
+         *
+         * @param[in]  inValue  The 32-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint32_t Swap32HostToBig(uint32_t inValue)
+        {
+            return nlByteOrderSwap32HostToBig(inValue);
+        }
+
+        /**
+         * This conditionally performs, as necessary for the target system, a
+         * byte order swap by value of the specified 64-bit value, presumed to
+         * be in target system (i.e. host) byte ordering to big endian byte
+         * ordering.
+         *
+         * Consequently, on little endian target systems, this performs a
+         * reordering and on big endian target systems, this is a no-op.
+         *
+         * @param[in]  inValue  The 64-bit value to be byte order swapped.
+         *
+         * @return The input value, byte order swapped.
+         */
+        inline uint64_t Swap64HostToBig(uint64_t inValue)
+        {
+            return nlByteOrderSwap64HostToBig(inValue);
+        }
+
+    }; // namespace ByteOrder
+
+}; // namespace nl
+
+#endif // NLBYTEORDER_HPP
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/include/nlio-base.h b/include/nlio-base.h
new file mode 100644
index 0000000..f24a51e
--- /dev/null
+++ b/include/nlio-base.h
@@ -0,0 +1,1108 @@
+/**
+ *    Copyright 2013-2017 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines C functions for safely performing simple,
+ *      memory-mapped accesses, potentially to unaligned memory
+ *      locations.
+ */
+
+#ifndef NLIO_BASE_H
+#define NLIO_BASE_H
+
+#include <nlio-private.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+/*
+ * If we are compiling under clang, GCC, or any such compatible
+ * compiler, in which -fno-builtins or -ffreestanding might be
+ * asserted, thereby eliminating built-in function optimization, we
+ * STILL want built-in memcpy. We want this because it allows the
+ * compiler to use architecture-specific machine instructions or
+ * inline code generation to optimize an otherwise-expensive memcpy
+ * for unaligned reads and writes, which is exactly the kind of
+ * efficiency that would be expected of nlIO.
+ */
+#if __nlIOHasBuiltin(__builtin_memcpy)
+#define __nlIO_MEMCPY __builtin_memcpy
+#else
+#define __nlIO_MEMCPY memcpy
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * This determines whether the specified pointer is aligned on the
+ * indicated size boundary.
+ *
+ * @note The size should be a power of 2 (e.g. 1, 2, 4, 8, 16, etc.).
+ *
+ * @param[in]  p     The pointer to check the alignment of.
+ * @param[in]  size  The size, in bytes, boundary to check
+ *                   the alignment against.
+ *
+ * @return True if the pointer is aligned to the specified size;
+ *         otherwise, false.
+ */
+static inline bool nlIOIsAligned(const void *p, size_t size)
+{
+    const uintptr_t value = (uintptr_t)(p);
+    const uintptr_t mask  = size - 1;
+
+    return ((value & mask) == 0);
+}
+
+/**
+ * Perform an aligned memory read of the 8-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 8-bit value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOGetAligned8(const void *p)
+{
+    return *(const uint8_t *)(p);
+}
+
+/**
+ * Perform an aligned memory read of the 16-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 16-bit value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOGetAligned16(const void *p)
+{
+    return *(const uint16_t *)(p);
+}
+
+/**
+ * Perform an aligned memory read of the 32-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 32-bit value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOGetAligned32(const void *p)
+{
+    return *(const uint32_t *)(p);
+}
+
+/**
+ * Perform an aligned memory read of the 64-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 64-bit value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOGetAligned64(const void *p)
+{
+    return *(const uint64_t *)(p);
+}
+
+/**
+ * Perform an unaligned memory read of the 8-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 8-bit value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOGetUnaligned8(const void *p)
+{
+    return nlIOGetAligned8(p);
+}
+
+/**
+ * Perform an unaligned memory read of the 16-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 16-bit value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOGetUnaligned16(const void *p)
+{
+    uint16_t temp;
+
+    __nlIO_MEMCPY(&temp, p, sizeof(uint16_t));
+
+    return temp;
+}
+
+/**
+ * Perform an unaligned memory read of the 32-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 32-bit value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOGetUnaligned32(const void *p)
+{
+    uint32_t temp;
+
+    __nlIO_MEMCPY(&temp, p, sizeof(uint32_t));
+
+    return temp;
+}
+
+/**
+ * Perform an unaligned memory read of the 64-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 64-bit value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOGetUnaligned64(const void *p)
+{
+    uint64_t temp;
+
+    __nlIO_MEMCPY(&temp, p, sizeof(uint64_t));
+
+    return temp;
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 8-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 8-bit value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOGetMaybeAligned8(const void *p)
+{
+    return nlIOGetAligned8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 16-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 16-bit value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOGetMaybeAligned16(const void *p)
+{
+    if (nlIOIsAligned(p, sizeof (uint16_t)))
+        return nlIOGetAligned16(p);
+    else
+        return nlIOGetUnaligned16(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 32-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 32-bit value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOGetMaybeAligned32(const void *p)
+{
+    if (nlIOIsAligned(p, sizeof (uint32_t)))
+        return nlIOGetAligned32(p);
+    else
+        return nlIOGetUnaligned32(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 64-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 64-bit value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOGetMaybeAligned64(const void *p)
+{
+    if (nlIOIsAligned(p, sizeof (uint64_t)))
+        return nlIOGetAligned64(p);
+    else
+        return nlIOGetUnaligned64(p);
+}
+
+/**
+ * Perform an aligned memory write of the 8-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 8-bit value to.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOPutAligned8(void *p, const uint8_t v)
+{
+    *(uint8_t *)(p) = v;
+}
+
+/**
+ * Perform an aligned memory write of the 16-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 16-bit value to.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOPutAligned16(void *p, const uint16_t v)
+{
+    *(uint16_t *)(p) = v;
+}
+
+/**
+ * Perform an aligned memory write of the 32-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 32-bit value to.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOPutAligned32(void *p, const uint32_t v)
+{
+    *(uint32_t *)(p) = v;
+}
+
+/**
+ * Perform an aligned memory write of the 64-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 64-bit value to.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOPutAligned64(void *p, const uint64_t v)
+{
+    *(uint64_t *)(p) = v;
+}
+
+/**
+ * Perform an unaligned memory write of the 8-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 8-bit value to.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOPutUnaligned8(void *p, const uint8_t v)
+{
+    nlIOPutAligned8(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the 16-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 16-bit value to.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOPutUnaligned16(void *p, const uint16_t v)
+{
+    __nlIO_MEMCPY(p, &v, sizeof(uint16_t));
+}
+
+/**
+ * Perform an unaligned memory write of the 32-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 32-bit value to.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOPutUnaligned32(void *p, const uint32_t v)
+{
+    __nlIO_MEMCPY(p, &v, sizeof(uint32_t));
+}
+
+/**
+ * Perform an unaligned memory write of the 64-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 64-bit value to.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOPutUnaligned64(void *p, const uint64_t v)
+{
+    __nlIO_MEMCPY(p, &v, sizeof(uint64_t));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 8-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 8-bit value to.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOPutMaybeAligned8(void *p, const uint8_t v)
+{
+    nlIOPutAligned8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 16-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 16-bit value to.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOPutMaybeAligned16(void *p, const uint16_t v)
+{
+    if (nlIOIsAligned(p, sizeof (uint16_t)))
+        nlIOPutAligned16(p, v);
+    else
+        nlIOPutUnaligned16(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 32-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 32-bit value to.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOPutMaybeAligned32(void *p, const uint32_t v)
+{
+    if (nlIOIsAligned(p, sizeof (uint32_t)))
+        nlIOPutAligned32(p, v);
+    else
+        nlIOPutUnaligned32(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 64-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 64-bit value to.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOPutMaybeAligned64(void *p, const uint64_t v)
+{
+    if (nlIOIsAligned(p, sizeof (uint64_t)))
+        nlIOPutAligned64(p, v);
+    else
+        nlIOPutUnaligned64(p, v);
+}
+
+/**
+ * Perform an aligned memory read of the 8-bit value at the specified
+ * pointer address and increment the pointer by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the
+ *                    8-bit value from and to then increment by
+ *                    8-bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOReadAligned8(const void **p)
+{
+    const uint8_t temp = nlIOGetAligned8(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint8_t);
+
+    return temp;
+}
+
+/**
+ * Perform an aligned memory read of the 16-bit value at the specified
+ * pointer address and increment the pointer by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the
+ *                    16-bit value from and to then increment by
+ *                    16-bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOReadAligned16(const void **p)
+{
+    const uint16_t temp = nlIOGetAligned16(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint16_t);
+
+    return temp;
+}
+
+/**
+ * Perform an aligned memory read of the 32-bit value at the specified
+ * pointer address and increment the pointer by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the
+ *                    32-bit value from and to then increment by
+ *                    32-bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOReadAligned32(const void **p)
+{
+    const uint32_t temp = nlIOGetAligned32(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint32_t);
+
+    return temp;
+}
+
+/**
+ * Perform an aligned memory read of the 64-bit value at the specified
+ * pointer address and increment the pointer by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the
+ *                    64-bit value from and to then increment by
+ *                    64-bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOReadAligned64(const void **p)
+{
+    const uint64_t temp = nlIOGetAligned64(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint64_t);
+
+    return temp;
+}
+
+/**
+ * Perform an unaligned memory read of the 8-bit value at the specified
+ * pointer address and increment the pointer by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the
+ *                    8-bit value from and to then increment by
+ *                    8-bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t nlIOReadUnaligned8(const void **p)
+{
+    const uint8_t temp = nlIOGetUnaligned8(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint8_t);
+
+    return temp;
+}
+
+/**
+ * Perform an unaligned memory read of the 16-bit value at the specified
+ * pointer address and increment the pointer by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the
+ *                    16-bit value from and to then increment by
+ *                    16-bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOReadUnaligned16(const void **p)
+{
+    const uint16_t temp = nlIOGetUnaligned16(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint16_t);
+
+    return temp;
+}
+
+/**
+ * Perform an aligned memory read of the 32-bit value at the specified
+ * pointer address and increment the pointer by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the
+ *                    32-bit value from and to then increment by
+ *                    32-bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOReadUnaligned32(const void **p)
+{
+    const uint32_t temp = nlIOGetUnaligned32(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint32_t);
+
+    return temp;
+}
+
+/**
+ * Perform an unaligned memory read of the 64-bit value at the specified
+ * pointer address and increment the pointer by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the
+ *                    64-bit value from and to then increment by
+ *                    64-bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOReadUnaligned64(const void **p)
+{
+    const uint64_t temp = nlIOGetUnaligned64(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint64_t);
+
+    return temp;
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 8-bit value
+ * from the specified pointer address and increment the pointer by
+ * 8-bits (1 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 8-bit value from and to
+ *                    then increment by 8-bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOReadMaybeAligned8(const void **p)
+{
+    const uint8_t temp = nlIOGetMaybeAligned8(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint8_t);
+
+    return temp;
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 16-bit value
+ * from the specified pointer address and increment the pointer by
+ * 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 16-bit value from and to
+ *                    then increment by 16-bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOReadMaybeAligned16(const void **p)
+{
+    const uint16_t temp = nlIOGetMaybeAligned16(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint16_t);
+
+    return temp;
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 32-bit value
+ * from the specified pointer address and increment the pointer by
+ * 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 32-bit value from and to
+ *                    then increment by 32-bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOReadMaybeAligned32(const void **p)
+{
+    const uint32_t temp = nlIOGetMaybeAligned32(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint32_t);
+
+    return temp;
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 64-bit value
+ * from the specified pointer address and increment the pointer by
+ * 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 64-bit value from and to
+ *                    then increment by 64-bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOReadMaybeAligned64(const void **p)
+{
+    const uint64_t temp = nlIOGetMaybeAligned64(*p);
+
+    *(const uint8_t **)(p) += sizeof (uint64_t);
+
+    return temp;
+}
+
+/**
+ * Perform an aligned memory write of the 8-bit value to the specified
+ * pointer address and increment the pointer by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the 8-bit
+ *                    value from and to then increment by 8-bits (1 byte).
+ *
+ * @param[in]     v   The 8-bit value to write.
+ *
+ */
+static inline void     nlIOWriteAligned8(void **p, const uint8_t v)
+{
+    nlIOPutAligned8(*p, v);       *(const uint8_t **)(p) += sizeof (uint8_t);
+}
+
+/**
+ * Perform an aligned memory write of the 16-bit value to the specified
+ * pointer address and increment the pointer by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the 16-bit
+ *                    value from and to then increment by 16-bits (2 bytes).
+ *
+ * @param[in]     v   The 16-bit value to write.
+ *
+ */
+static inline void     nlIOWriteAligned16(void **p, const uint16_t v)
+{
+    nlIOPutAligned16(*p, v);      *(const uint8_t **)(p) += sizeof (uint16_t);
+}
+
+/**
+ * Perform an aligned memory write of the 32-bit value to the specified
+ * pointer address and increment the pointer by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the 32-bit
+ *                    value from and to then increment by 32-bits (4 bytes).
+ *
+ * @param[in]     v   The 32-bit value to write.
+ *
+ */
+static inline void     nlIOWriteAligned32(void **p, const uint32_t v)
+{
+    nlIOPutAligned32(*p, v);      *(const uint8_t **)(p) += sizeof (uint32_t);
+}
+
+/**
+ * Perform an aligned memory write of the 64-bit value to the specified
+ * pointer address and increment the pointer by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the 64-bit
+ *                    value from and to then increment by 64-bits (8 bytes).
+ *
+ * @param[in]     v   The 64-bit value to write.
+ *
+ */
+static inline void     nlIOWriteAligned64(void **p, const uint64_t v)
+{
+    nlIOPutAligned64(*p, v);      *(const uint8_t **)(p) += sizeof (uint64_t);
+}
+
+/**
+ * Perform an unaligned memory write of the 8-bit value to the specified
+ * pointer address and increment the pointer by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the 8-bit
+ *                    value from and to then increment by 8-bits (1 byte).
+ *
+ * @param[in]     v   The 8-bit value to write.
+ *
+ */
+static inline void     nlIOWriteUnaligned8(void **p, const uint8_t v)
+{
+    nlIOPutUnaligned8(*p, v);     *(const uint8_t **)(p) += sizeof (uint8_t);
+}
+
+/**
+ * Perform an unaligned memory write of the 16-bit value to the specified
+ * pointer address and increment the pointer by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the 16-bit
+ *                    value from and to then increment by 16-bits (2 bytes).
+ *
+ * @param[in]     v   The 16-bit value to write.
+ *
+ */
+static inline void     nlIOWriteUnaligned16(void **p, const uint16_t v)
+{
+    nlIOPutUnaligned16(*p, v);    *(const uint8_t **)(p) += sizeof (uint16_t);
+}
+
+/**
+ * Perform an unaligned memory write of the 32-bit value to the specified
+ * pointer address and increment the pointer by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the 32-bit
+ *                    value from and to then increment by 32-bits (4 bytes).
+ *
+ * @param[in]     v   The 32-bit value to write.
+ *
+ */
+static inline void     nlIOWriteUnaligned32(void **p, const uint32_t v)
+{
+    nlIOPutUnaligned32(*p, v);    *(const uint8_t **)(p) += sizeof (uint32_t);
+}
+
+/**
+ * Perform an unaligned memory write of the 64-bit value to the specified
+ * pointer address and increment the pointer by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address to read the 64-bit
+ *                    value from and to then increment by 64-bits (8 bytes).
+ *
+ * @param[in]     v   The 64-bit value to write.
+ *
+ */
+static inline void     nlIOWriteUnaligned64(void **p, const uint64_t v)
+{
+    nlIOPutUnaligned64(*p, v);    *(const uint8_t **)(p) += sizeof (uint64_t);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 8-bit value
+ * to the specified pointer address and increment the pointer by
+ * 8-bits (2 byte).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 8-bit value from and to
+ *                    then increment by 8-bits (1 byte).
+ *
+ * @param[in]     v   The 8-bit value to write.
+ *
+ */
+static inline void     nlIOWriteMaybeAligned8(void **p, const uint8_t v)
+{
+    nlIOPutMaybeAligned8(*p, v);  *(const uint8_t **)(p) += sizeof (uint8_t);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 16-bit value
+ * to the specified pointer address and increment the pointer by
+ * 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 16-bit value from and to
+ *                    then increment by 16-bits (2 bytes).
+ *
+ * @param[in]     v   The 16-bit value to write.
+ *
+ */
+static inline void     nlIOWriteMaybeAligned16(void **p, const uint16_t v)
+{
+    nlIOPutMaybeAligned16(*p, v); *(const uint8_t **)(p) += sizeof (uint16_t);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 32-bit value
+ * to the specified pointer address and increment the pointer by
+ * 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 32-bit value from and to
+ *                    then increment by 32-bits (4 bytes).
+ *
+ * @param[in]     v   The 32-bit value to write.
+ *
+ */
+static inline void     nlIOWriteMaybeAligned32(void **p, const uint32_t v)
+{
+    nlIOPutMaybeAligned32(*p, v); *(const uint8_t **)(p) += sizeof (uint32_t);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 64-bit value
+ * to the specified pointer address and increment the pointer by
+ * 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 64-bit value from and to
+ *                    then increment by 64-bits (8 bytes).
+ *
+ * @param[in]     v   The 64-bit value to write.
+ *
+ */
+static inline void     nlIOWriteMaybeAligned64(void **p, const uint64_t v)
+{
+    nlIOPutMaybeAligned64(*p, v); *(const uint8_t **)(p) += sizeof (uint64_t);
+}
+
+/**
+ * Perform a memory read of the 8-bit value at the specified pointer
+ * address.
+ *
+ * @param[in]  p      A pointer address to read the 8-bit value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t nlIOGet8(const void *p)
+{
+    return nlIOGetAligned8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 16-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 16-bit value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOGet16(const void *p)
+{
+    return nlIOGetMaybeAligned16(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 32-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 32-bit value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOGet32(const void *p)
+{
+    return nlIOGetMaybeAligned32(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 64-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 64-bit value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOGet64(const void *p)
+{
+    return nlIOGetMaybeAligned64(p);
+}
+
+/**
+ * Perform a memory write of the 8-bit value to the specified pointer
+ * address.
+ *
+ * @param[in]  p      A pointer address to write the 8-bit value to.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void nlIOPut8(void *p, uint8_t v)
+{
+    nlIOPutAligned8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 16-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 16-bit value to.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void nlIOPut16(void *p, uint16_t v)
+{
+    nlIOPutMaybeAligned16(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 32-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 32-bit value to.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void nlIOPut32(void *p, uint32_t v)
+{
+    nlIOPutMaybeAligned32(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 64-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 64-bit value to.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void nlIOPut64(void *p, uint64_t v)
+{
+    nlIOPutMaybeAligned64(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 16-bit value
+ * from the specified pointer address and increment the pointer by
+ * 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 8-bit value from and to
+ *                    then increment by 8-bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIORead8(const void **p)
+{
+    return nlIOReadAligned8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 16-bit value
+ * from the specified pointer address and increment the pointer by
+ * 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 16-bit value from and to
+ *                    then increment by 16-bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIORead16(const void **p)
+{
+    return nlIOReadMaybeAligned16(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 32-bit value
+ * from the specified pointer address and increment the pointer by
+ * 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 32-bit value from and to
+ *                    then increment by 32-bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIORead32(const void **p)
+{
+    return nlIOReadMaybeAligned32(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 64-bit value
+ * from the specified pointer address and increment the pointer by
+ * 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 64-bit value from and to
+ *                    then increment by 64-bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIORead64(const void **p)
+{
+    return nlIOReadMaybeAligned64(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 8-bit value
+ * to the specified pointer address and increment the pointer by
+ * 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 8-bit value from and to
+ *                    then increment by 8-bits (1 byte).
+ *
+ * @param[in]     v   The 8-bit value to write.
+ *
+ */
+static inline void nlIOWrite8(void **p, uint8_t v)
+{
+    nlIOWriteAligned8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 16-bit value
+ * to the specified pointer address and increment the pointer by
+ * 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 16-bit value from and to
+ *                    then increment by 16-bits (2 bytes).
+ *
+ * @param[in]     v   The 16-bit value to write.
+ *
+ */
+static inline void nlIOWrite16(void **p, uint16_t v)
+{
+    nlIOWriteMaybeAligned16(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 32-bit value
+ * to the specified pointer address and increment the pointer by
+ * 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 32-bit value from and to
+ *                    then increment by 32-bits (4 bytes).
+ *
+ * @param[in]     v   The 32-bit value to write.
+ *
+ */
+static inline void nlIOWrite32(void **p, uint32_t v)
+{
+    nlIOWriteMaybeAligned32(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 64-bit value
+ * to the specified pointer address and increment the pointer by
+ * 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 64-bit value from and to
+ *                    then increment by 64-bits (8 bytes).
+ *
+ * @param[in]     v   The 64-bit value to write.
+ *
+ */
+static inline void nlIOWrite64(void **p, uint64_t v)
+{
+    nlIOWriteMaybeAligned64(p, v);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#undef __nlIO_MEMCPY
+
+#endif /* NLIO_BASE_H */
diff --git a/include/nlio-base.hpp b/include/nlio-base.hpp
new file mode 100644
index 0000000..4be7a03
--- /dev/null
+++ b/include/nlio-base.hpp
@@ -0,0 +1,1025 @@
+/**
+ *    Copyright 2013-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines C++ functions for safely performing simple,
+ *      memory-mapped accesses, potentially to unaligned memory
+ *      locations.
+ */
+
+#ifndef NLIO_BASE_HPP
+#define NLIO_BASE_HPP
+
+#include <nlio-base.h>
+
+namespace nl
+{
+
+namespace IO
+{
+
+/**
+ * This determines whether the specified pointer is aligned on the
+ * indicated size boundary.
+ *
+ * @note The size should be a power of 2 (e.g. 1, 2, 4, 8, 16, etc.).
+ *
+ * @param[in]  p     The pointer to check the alignment of.
+ * @param[in]  size  The size, in bytes, boundary to check
+ *                   the alignment against.
+ *
+ * @return True if the pointer is aligned to the specified size;
+ *         otherwise, false.
+ */
+static inline bool IsAligned(const void *p, size_t size)
+{
+    return nlIOIsAligned(p, size);
+}
+
+/**
+ * This determines whether the specified pointer is aligned on the
+ * size boundary for the template type, T.
+ *
+ * @tparam     T     The type of pointer to check the alignment of.
+ *
+ * @param[in]  p     The pointer to check the alignment of.
+ *
+ * @return True if the pointer is aligned to size of the type;
+ *         otherwise, false.
+ */
+template <typename T>
+static inline bool IsAligned(const T *p)
+{
+    return nlIOIsAligned(p, sizeof(T));
+}
+
+/**
+ * Perform an aligned memory read of the 8-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 8-bit value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  GetAligned8(const void *p)
+{
+    return nlIOGetAligned8(p);
+}
+
+/**
+ * Perform an aligned memory read of the 16-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 16-bit value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t GetAligned16(const void *p)
+{
+    return nlIOGetAligned16(p);
+}
+
+/**
+ * Perform an aligned memory read of the 32-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 32-bit value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t GetAligned32(const void *p)
+{
+    return nlIOGetAligned32(p);
+}
+
+/**
+ * Perform an aligned memory read of the 64-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 64-bit value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t GetAligned64(const void *p)
+{
+    return nlIOGetAligned64(p);
+}
+
+/**
+ * Perform an unaligned memory read of the 8-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 8-bit value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  GetUnaligned8(const void *p)
+{
+    return nlIOGetUnaligned8(p);
+}
+
+/**
+ * Perform an unaligned memory read of the 16-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 16-bit value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t GetUnaligned16(const void *p)
+{
+    return nlIOGetUnaligned16(p);
+}
+
+/**
+ * Perform an unaligned memory read of the 32-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 32-bit value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t GetUnaligned32(const void *p)
+{
+    return nlIOGetUnaligned32(p);
+}
+
+/**
+ * Perform an unaligned memory read of the 64-bit value at the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to read the 64-bit value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t GetUnaligned64(const void *p)
+{
+    return nlIOGetUnaligned64(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 8-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 8-bit value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  GetMaybeAligned8(const void *p)
+{
+    return nlIOGetMaybeAligned8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 16-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 16-bit value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t GetMaybeAligned16(const void *p)
+{
+    return nlIOGetMaybeAligned16(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 32-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 32-bit value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t GetMaybeAligned32(const void *p)
+{
+    return nlIOGetMaybeAligned32(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 64-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 64-bit value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t GetMaybeAligned64(const void *p)
+{
+    return nlIOGetMaybeAligned64(p);
+}
+
+/**
+ * Perform an aligned memory write of the 8-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 8-bit value to.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     PutAligned8(void *p, const uint8_t v)
+{
+    nlIOPutAligned8(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the 16-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 16-bit value to.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     PutAligned16(void *p, const uint16_t v)
+{
+    nlIOPutAligned16(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the 32-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 32-bit value to.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     PutAligned32(void *p, const uint32_t v)
+{
+    nlIOPutAligned32(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the 64-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 64-bit value to.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     PutAligned64(void *p, const uint64_t v)
+{
+    nlIOPutAligned64(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the 8-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 8-bit value to.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     PutUnaligned8(void *p, const uint8_t v)
+{
+    nlIOPutUnaligned8(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the 16-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 16-bit value to.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     PutUnaligned16(void *p, const uint16_t v)
+{
+    nlIOPutUnaligned16(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the 32-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 32-bit value to.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     PutUnaligned32(void *p, const uint32_t v)
+{
+    nlIOPutUnaligned32(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the 64-bit value to the specified
+ * pointer address.
+ *
+ * @param[in]  p      A pointer address to write the 64-bit value to.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     PutUnaligned64(void *p, const uint64_t v)
+{
+    nlIOPutUnaligned64(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 8-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 8-bit value to.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     PutMaybeAligned8(void *p, const uint8_t v)
+{
+    nlIOPutMaybeAligned8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 16-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 16-bit value to.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     PutMaybeAligned16(void *p, const uint16_t v)
+{
+    nlIOPutMaybeAligned16(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 32-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 32-bit value to.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     PutMaybeAligned32(void *p, const uint32_t v)
+{
+    nlIOPutMaybeAligned32(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 64-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 64-bit value to.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     PutMaybeAligned64(void *p, const uint64_t v)
+{
+    nlIOPutMaybeAligned64(p, v);
+}
+
+/**
+ * Perform an aligned memory read of the 8-bit value at the specified
+ * pointer address and increment the pointer by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the
+ *                    8-bit value from and to then increment by
+ *                    8-bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  ReadAligned8(const void *&p)
+{
+    return nlIOReadAligned8(&p);
+}
+
+/**
+ * Perform an aligned memory read of the 16-bit value at the specified
+ * pointer address and increment the pointer by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the
+ *                    16-bit value from and to then increment by
+ *                    16-bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t ReadAligned16(const void *&p)
+{
+    return nlIOReadAligned16(&p);
+}
+
+/**
+ * Perform an aligned memory read of the 32-bit value at the specified
+ * pointer address and increment the pointer by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the
+ *                    32-bit value from and to then increment by
+ *                    32-bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t ReadAligned32(const void *&p)
+{
+    return nlIOReadAligned32(&p);
+}
+
+/**
+ * Perform an aligned memory read of the 64-bit value at the specified
+ * pointer address and increment the pointer by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the
+ *                    64-bit value from and to then increment by
+ *                    64-bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t ReadAligned64(const void *&p)
+{
+    return nlIOReadAligned64(&p);
+}
+
+/**
+ * Perform an unaligned memory read of the 8-bit value at the specified
+ * pointer address and increment the pointer by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the
+ *                    8-bit value from and to then increment by
+ *                    8-bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t ReadUnaligned8(const void *&p)
+{
+    return nlIOReadUnaligned8(&p);
+}
+
+/**
+ * Perform an unaligned memory read of the 16-bit value at the specified
+ * pointer address and increment the pointer by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the
+ *                    16-bit value from and to then increment by
+ *                    16-bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t ReadUnaligned16(const void *&p)
+{
+    return nlIOReadUnaligned16(&p);
+}
+
+/**
+ * Perform an aligned memory read of the 32-bit value at the specified
+ * pointer address and increment the pointer by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the
+ *                    32-bit value from and to then increment by
+ *                    32-bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t ReadUnaligned32(const void *&p)
+{
+    return nlIOReadUnaligned32(&p);
+}
+
+/**
+ * Perform an unaligned memory read of the 64-bit value at the specified
+ * pointer address and increment the pointer by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the
+ *                    64-bit value from and to then increment by
+ *                    64-bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t ReadUnaligned64(const void *&p)
+{
+    return nlIOReadUnaligned64(&p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 8-bit value
+ * from the specified pointer address and increment the pointer by
+ * 8-bits (1 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 8-bit value from and to
+ *                    then increment by 8-bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  ReadMaybeAligned8(const void *&p)
+{
+    return nlIOReadMaybeAligned8(&p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 16-bit value
+ * from the specified pointer address and increment the pointer by
+ * 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 16-bit value from and to
+ *                    then increment by 16-bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t ReadMaybeAligned16(const void *&p)
+{
+    return nlIOReadMaybeAligned16(&p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 32-bit value
+ * from the specified pointer address and increment the pointer by
+ * 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 32-bit value from and to
+ *                    then increment by 32-bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t ReadMaybeAligned32(const void *&p)
+{
+    return nlIOReadMaybeAligned32(&p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 64-bit value
+ * from the specified pointer address and increment the pointer by
+ * 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 64-bit value from and to
+ *                    then increment by 64-bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t ReadMaybeAligned64(const void *&p)
+{
+    return nlIOReadMaybeAligned64(&p);
+}
+
+/**
+ * Perform an aligned memory write of the 8-bit value to the specified
+ * pointer address and increment the pointer by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the 8-bit
+ *                    value from and to then increment by 8-bits (1 byte).
+ *
+ * @param[in]     v   The 8-bit value to write.
+ *
+ */
+static inline void     WriteAligned8(void *&p, const uint8_t v)
+{
+    nlIOWriteAligned8(&p, v);
+}
+
+/**
+ * Perform an aligned memory write of the 16-bit value to the specified
+ * pointer address and increment the pointer by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the 16-bit
+ *                    value from and to then increment by 16-bits (2 bytes).
+ *
+ * @param[in]     v   The 16-bit value to write.
+ *
+ */
+static inline void     WriteAligned16(void *&p, const uint16_t v)
+{
+    nlIOWriteAligned16(&p, v);
+}
+
+/**
+ * Perform an aligned memory write of the 32-bit value to the specified
+ * pointer address and increment the pointer by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the 32-bit
+ *                    value from and to then increment by 32-bits (4 bytes).
+ *
+ * @param[in]     v   The 32-bit value to write.
+ *
+ */
+static inline void     WriteAligned32(void *&p, const uint32_t v)
+{
+    nlIOWriteAligned32(&p, v);
+}
+
+/**
+ * Perform an aligned memory write of the 64-bit value to the specified
+ * pointer address and increment the pointer by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the 64-bit
+ *                    value from and to then increment by 64-bits (8 bytes).
+ *
+ * @param[in]     v   The 64-bit value to write.
+ *
+ */
+static inline void     WriteAligned64(void *&p, const uint64_t v)
+{
+    nlIOWriteAligned64(&p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the 8-bit value to the specified
+ * pointer address and increment the pointer by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the 8-bit
+ *                    value from and to then increment by 8-bits (1 byte).
+ *
+ * @param[in]     v   The 8-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned8(void *&p, const uint8_t v)
+{
+    nlIOWriteUnaligned8(&p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the 16-bit value to the specified
+ * pointer address and increment the pointer by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the 16-bit
+ *                    value from and to then increment by 16-bits (2 bytes).
+ *
+ * @param[in]     v   The 16-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned16(void *&p, const uint16_t v)
+{
+    nlIOWriteUnaligned16(&p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the 32-bit value to the specified
+ * pointer address and increment the pointer by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the 32-bit
+ *                    value from and to then increment by 32-bits (4 bytes).
+ *
+ * @param[in]     v   The 32-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned32(void *&p, const uint32_t v)
+{
+    nlIOWriteUnaligned32(&p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the 64-bit value to the specified
+ * pointer address and increment the pointer by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address to read the 64-bit
+ *                    value from and to then increment by 64-bits (8 bytes).
+ *
+ * @param[in]     v   The 64-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned64(void *&p, const uint64_t v)
+{
+    nlIOWriteUnaligned64(&p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 8-bit value
+ * to the specified pointer address and increment the pointer by
+ * 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 8-bit value from and to
+ *                    then increment by 8-bits (1 byte).
+ *
+ * @param[in]     v   The 8-bit value to write.
+ *
+ */
+static inline void     WriteMaybeAligned8(void *&p, const uint8_t v)
+{
+    nlIOWriteMaybeAligned8(&p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 16-bit value
+ * to the specified pointer address and increment the pointer by
+ * 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 16-bit value from and to
+ *                    then increment by 16-bits (2 bytes).
+ *
+ * @param[in]     v   The 16-bit value to write.
+ *
+ */
+static inline void     WriteMaybeAligned16(void *&p, const uint16_t v)
+{
+    nlIOWriteMaybeAligned16(&p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 32-bit value
+ * to the specified pointer address and increment the pointer by
+ * 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 32-bit value from and to
+ *                    then increment by 32-bits (4 bytes).
+ *
+ * @param[in]     v   The 32-bit value to write.
+ *
+ */
+static inline void     WriteMaybeAligned32(void *&p, const uint32_t v)
+{
+    nlIOWriteMaybeAligned32(&p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 64-bit value
+ * to the specified pointer address and increment the pointer by
+ * 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 64-bit value from and to
+ *                    then increment by 64-bits (8 bytes).
+ *
+ * @param[in]     v   The 64-bit value to write.
+ *
+ */
+static inline void     WriteMaybeAligned64(void *&p, const uint64_t v)
+{
+    nlIOWriteMaybeAligned64(&p, v);
+}
+
+/**
+ * Perform a memory read of the 8-bit value at the specified pointer
+ * address.
+ *
+ * @param[in]  p      A pointer address to read the 8-bit value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  Get8(const void *p)
+{
+    return nlIOGet8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 16-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 16-bit value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t Get16(const void *p)
+{
+    return nlIOGet16(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 32-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 32-bit value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t Get32(const void *p)
+{
+    return nlIOGet32(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 64-bit value
+ * from the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 64-bit value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t Get64(const void *p)
+{
+    return nlIOGet64(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 8-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 8-bit value to.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void Put8(void *p, const uint8_t v)
+{
+    nlIOPut8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 16-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 16-bit value to.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void Put16(void *p, const uint16_t v)
+{
+    nlIOPut16(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 32-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 32-bit value to.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void Put32(void *p, const uint32_t v)
+{
+    nlIOPut32(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 64-bit value
+ * to the specified pointer address.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the 64-bit value to.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void Put64(void *p, const uint64_t v)
+{
+    nlIOPut64(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 16-bit value
+ * from the specified pointer address and increment the pointer by
+ * 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 8-bit value from and to
+ *                    then increment by 8-bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  Read8(const void *&p)
+{
+    return nlIORead8(&p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 16-bit value
+ * from the specified pointer address and increment the pointer by
+ * 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 16-bit value from and to
+ *                    then increment by 16-bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t Read16(const void *&p)
+{
+    return nlIORead16(&p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 32-bit value
+ * from the specified pointer address and increment the pointer by
+ * 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 32-bit value from and to
+ *                    then increment by 32-bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t Read32(const void *&p)
+{
+    return nlIORead32(&p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the 64-bit value
+ * from the specified pointer address and increment the pointer by
+ * 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 64-bit value from and to
+ *                    then increment by 64-bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t Read64(const void *&p)
+{
+    return nlIORead64(&p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 8-bit value
+ * to the specified pointer address and increment the pointer by
+ * 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 8-bit value from and to
+ *                    then increment by 8-bits (1 byte).
+ *
+ * @param[in]     v   The 8-bit value to write.
+ *
+ */
+static inline void Write8(void *&p, const uint8_t v)
+{
+    nlIOWrite8(&p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 16-bit value
+ * to the specified pointer address and increment the pointer by
+ * 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 16-bit value from and to
+ *                    then increment by 16-bits (2 bytes).
+ *
+ * @param[in]     v   The 16-bit value to write.
+ *
+ */
+static inline void Write16(void *&p, const uint16_t v)
+{
+    nlIOWrite16(&p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 32-bit value
+ * to the specified pointer address and increment the pointer by
+ * 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 32-bit value from and to
+ *                    then increment by 32-bits (4 bytes).
+ *
+ * @param[in]     v   The 32-bit value to write.
+ *
+ */
+static inline void Write32(void *&p, const uint32_t v)
+{
+    nlIOWrite32(&p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the 64-bit value
+ * to the specified pointer address and increment the pointer by
+ * 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 64-bit value from and to
+ *                    then increment by 64-bits (8 bytes).
+ *
+ * @param[in]     v   The 64-bit value to write.
+ *
+ */
+static inline void Write64(void *&p, const uint64_t v)
+{
+    nlIOWrite64(&p, v);
+}
+
+}; // namespace IO
+
+}; // namespace nl
+
+#endif // NLIO_BASE_HPP
diff --git a/include/nlio-byteorder-big.h b/include/nlio-byteorder-big.h
new file mode 100644
index 0000000..a9ab69c
--- /dev/null
+++ b/include/nlio-byteorder-big.h
@@ -0,0 +1,915 @@
+/**
+ *    Copyright 2013-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines C functions for safely performing simple,
+ *      memory-mapped accesses, potentially to unaligned, aligned, and
+ *      unaligned memory locations with byte reordering, specifically
+ *      for big endian target systems.
+ */
+
+#ifndef NLIO_BYTEORDER_BIG_H
+#define NLIO_BYTEORDER_BIG_H
+
+#include <nlio-base.h>
+#include <nlbyteorder.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 8-bit big endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOBigEndianGet8(const void *p)
+{
+    return nlIOGet8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 16-bit big endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOBigEndianGet16(const void *p)
+{
+    return nlByteOrderSwap16BigToHost(nlIOGet16(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 32-bit big endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOBigEndianGet32(const void *p)
+{
+    return nlByteOrderSwap32BigToHost(nlIOGet32(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 64-bit big endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOBigEndianGet64(const void *p)
+{
+    return nlByteOrderSwap64BigToHost(nlIOGet64(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 8-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPut8(void *p, uint8_t v)
+{
+    nlIOPut8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 16-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPut16(void *p, uint16_t v)
+{
+    nlIOPut16(p, nlByteOrderSwap16HostToBig(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 32-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPut32(void *p, uint32_t v)
+{
+    nlIOPut32(p, nlByteOrderSwap32HostToBig(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 64-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPut64(void *p, uint64_t v)
+{
+    nlIOPut64(p, nlByteOrderSwap64HostToBig(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 8-bit big endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOBigEndianRead8(const void **p)
+{
+    return nlIORead8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 16-bit big endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOBigEndianRead16(const void **p)
+{
+    return nlByteOrderSwap16BigToHost(nlIORead16(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 32-bit big endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOBigEndianRead32(const void **p)
+{
+    return nlByteOrderSwap32BigToHost(nlIORead32(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 64-bit big endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOBigEndianRead64(const void **p)
+{
+    return nlByteOrderSwap64BigToHost(nlIORead64(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 8-bit value to in big endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWrite8(void **p, uint8_t v)
+{
+    nlIOWrite8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 16-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWrite16(void **p, uint16_t v)
+{
+    nlIOWrite16(p, nlByteOrderSwap16HostToBig(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 32-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWrite32(void **p, uint32_t v)
+{
+    nlIOWrite32(p, nlByteOrderSwap32HostToBig(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 64-bit value to in big endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWrite64(void **p, uint64_t v)
+{
+    nlIOWrite64(p, nlByteOrderSwap64HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 8-bit big endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOBigEndianGetAligned8(const void *p)
+{
+    return nlIOGetAligned8(p);
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 16-bit big endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOBigEndianGetAligned16(const void *p)
+{
+    return nlByteOrderSwap16BigToHost(nlIOGetAligned16(p));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 32-bit big endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOBigEndianGetAligned32(const void *p)
+{
+    return nlByteOrderSwap32BigToHost(nlIOGetAligned32(p));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 64-bit big endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOBigEndianGetAligned64(const void *p)
+{
+    return nlByteOrderSwap64BigToHost(nlIOGetAligned64(p));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 8-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPutAligned8(void *p, uint8_t v)
+{
+    nlIOPutAligned8(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 16-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPutAligned16(void *p, uint16_t v)
+{
+    nlIOPutAligned16(p, nlByteOrderSwap16HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 32-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPutAligned32(void *p, uint32_t v)
+{
+    nlIOPutAligned32(p, nlByteOrderSwap32HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 64-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPutAligned64(void *p, uint64_t v)
+{
+    nlIOPutAligned64(p, nlByteOrderSwap64HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to read the 8-bit big endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOBigEndianReadAligned8(const void **p)
+{
+    return nlIOReadAligned8(p);
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to read the 16-bit big endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOBigEndianReadAligned16(const void **p)
+{
+    return nlByteOrderSwap16BigToHost(nlIOReadAligned16(p));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to read the 32-bit big endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOBigEndianReadAligned32(const void **p)
+{
+    return nlByteOrderSwap32BigToHost(nlIOReadAligned32(p));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to read the 64-bit big endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOBigEndianReadAligned64(const void **p)
+{
+    return nlByteOrderSwap64BigToHost(nlIOReadAligned64(p));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to write the target system byte
+ *                    ordered 8-bit value to in big endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWriteAligned8(void **p, uint8_t v)
+{
+    nlIOWriteAligned8(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to write the target system byte
+ *                    ordered 16-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWriteAligned16(void **p, uint16_t v)
+{
+    nlIOWriteAligned16(p, nlByteOrderSwap16HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to write the target system byte
+ *                    ordered 32-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWriteAligned32(void **p, uint32_t v)
+{
+    nlIOWriteAligned32(p, nlByteOrderSwap32HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to write the target system byte
+ *                    ordered 64-bit value to in big endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWriteAligned64(void **p, uint64_t v)
+{
+    nlIOWriteAligned64(p, nlByteOrderSwap64HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 8-bit big endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOBigEndianGetUnaligned8(const void *p)
+{
+    return nlIOGetUnaligned8(p);
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 16-bit big endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOBigEndianGetUnaligned16(const void *p)
+{
+    return nlByteOrderSwap16BigToHost(nlIOGetUnaligned16(p));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 32-bit big endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOBigEndianGetUnaligned32(const void *p)
+{
+    return nlByteOrderSwap32BigToHost(nlIOGetUnaligned32(p));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 64-bit big endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOBigEndianGetUnaligned64(const void *p)
+{
+    return nlByteOrderSwap64BigToHost(nlIOGetUnaligned64(p));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 8-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPutUnaligned8(void *p, uint8_t v)
+{
+    nlIOPutUnaligned8(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 16-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPutUnaligned16(void *p, uint16_t v)
+{
+    nlIOPutUnaligned16(p, nlByteOrderSwap16HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 32-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPutUnaligned32(void *p, uint32_t v)
+{
+    nlIOPutUnaligned32(p, nlByteOrderSwap32HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 64-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianPutUnaligned64(void *p, uint64_t v)
+{
+    nlIOPutUnaligned64(p, nlByteOrderSwap64HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to read the 8-bit big endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOBigEndianReadUnaligned8(const void **p)
+{
+    return nlIOReadUnaligned8(p);
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to read the 16-bit big endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOBigEndianReadUnaligned16(const void **p)
+{
+    return nlByteOrderSwap16BigToHost(nlIOReadUnaligned16(p));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to read the 32-bit big endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOBigEndianReadUnaligned32(const void **p)
+{
+    return nlByteOrderSwap32BigToHost(nlIOReadUnaligned32(p));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to read the 64-bit big endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOBigEndianReadUnaligned64(const void **p)
+{
+    return nlByteOrderSwap64BigToHost(nlIOReadUnaligned64(p));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to write the target system byte
+ *                    ordered 8-bit value to in big endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWriteUnaligned8(void **p, uint8_t v)
+{
+    nlIOWriteUnaligned8(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to write the target system byte
+ *                    ordered 16-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWriteUnaligned16(void **p, uint16_t v)
+{
+    nlIOWriteUnaligned16(p, nlByteOrderSwap16HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to write the target system byte
+ *                    ordered 32-bit value to in big endian byte
+ *                    ordering and to then increment by 32-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWriteUnaligned32(void **p, uint32_t v)
+{
+    nlIOWriteUnaligned32(p, nlByteOrderSwap32HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to write the target system byte
+ *                    ordered 64-bit value to in big endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOBigEndianWriteUnaligned64(void **p, uint64_t v)
+{
+    nlIOWriteUnaligned64(p, nlByteOrderSwap64HostToBig(v));
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NLIO_BYTEORDER_BIG_H */
diff --git a/include/nlio-byteorder-big.hpp b/include/nlio-byteorder-big.hpp
new file mode 100644
index 0000000..a34be83
--- /dev/null
+++ b/include/nlio-byteorder-big.hpp
@@ -0,0 +1,922 @@
+/**
+ *    Copyright 2013-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines C++ functions for safely performing simple,
+ *      memory-mapped accesses, potentially to unaligned, aligned, and
+ *      unaligned memory locations with byte reordering, specifically
+ *      for big endian target systems.
+ */
+
+#ifndef NLIO_BYTEORDER_BIG_HPP
+#define NLIO_BYTEORDER_BIG_HPP
+
+#include <nlio-base.hpp>
+#include <nlbyteorder.hpp>
+
+namespace nl
+{
+
+namespace IO
+{
+
+namespace BigEndian
+{
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 8-bit big endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  Get8(const void *p)
+{
+    return IO::Get8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 16-bit big endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t Get16(const void *p)
+{
+    return ByteOrder::Swap16BigToHost(IO::Get16(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 32-bit big endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t Get32(const void *p)
+{
+    return ByteOrder::Swap32BigToHost(IO::Get32(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 64-bit big endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t Get64(const void *p)
+{
+    return ByteOrder::Swap64BigToHost(IO::Get64(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 8-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     Put8(void *p, uint8_t v)
+{
+    IO::Put8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 16-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     Put16(void *p, uint16_t v)
+{
+    IO::Put16(p, ByteOrder::Swap16HostToBig(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 32-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     Put32(void *p, uint32_t v)
+{
+    IO::Put32(p, ByteOrder::Swap32HostToBig(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 64-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     Put64(void *p, uint64_t v)
+{
+    IO::Put64(p, ByteOrder::Swap64HostToBig(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 8-bit big endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  Read8(const void *&p)
+{
+    return IO::Read8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 16-bit big endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t Read16(const void *&p)
+{
+    return ByteOrder::Swap16BigToHost(IO::Read16(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 32-bit big endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t Read32(const void *&p)
+{
+    return ByteOrder::Swap32BigToHost(IO::Read32(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 64-bit big endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t Read64(const void *&p)
+{
+    return ByteOrder::Swap64BigToHost(IO::Read64(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A reference to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 8-bit value to in big endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     Write8(void *&p, uint8_t v)
+{
+    IO::Write8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A reference to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 16-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     Write16(void *&p, uint16_t v)
+{
+    IO::Write16(p, ByteOrder::Swap16HostToBig(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A reference to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 32-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     Write32(void *&p, uint32_t v)
+{
+    IO::Write32(p, ByteOrder::Swap32HostToBig(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      A reference to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 64-bit value to in big endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     Write64(void *&p, uint64_t v)
+{
+    IO::Write64(p, ByteOrder::Swap64HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 8-bit big endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  GetAligned8(const void *p)
+{
+    return IO::GetAligned8(p);
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 16-bit big endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t GetAligned16(const void *p)
+{
+    return ByteOrder::Swap16BigToHost(IO::GetAligned16(p));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 32-bit big endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t GetAligned32(const void *p)
+{
+    return ByteOrder::Swap32BigToHost(IO::GetAligned32(p));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 64-bit big endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t GetAligned64(const void *p)
+{
+    return ByteOrder::Swap64BigToHost(IO::GetAligned64(p));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 8-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     PutAligned8(void *p, uint8_t v)
+{
+    IO::PutAligned8(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 16-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     PutAligned16(void *p, uint16_t v)
+{
+    IO::PutAligned16(p, ByteOrder::Swap16HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 32-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     PutAligned32(void *p, uint32_t v)
+{
+    IO::PutAligned32(p, ByteOrder::Swap32HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 64-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     PutAligned64(void *p, uint64_t v)
+{
+    IO::PutAligned64(p, ByteOrder::Swap64HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to read the 8-bit big endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  ReadAligned8(const void *&p)
+{
+    return IO::ReadAligned8(p);
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to read the 16-bit big endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t ReadAligned16(const void *&p)
+{
+    return ByteOrder::Swap16BigToHost(IO::ReadAligned16(p));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to read the 32-bit big endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t ReadAligned32(const void *&p)
+{
+    return ByteOrder::Swap32BigToHost(IO::ReadAligned32(p));
+}
+
+/**
+ * Perform an aligned memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to read the 64-bit big endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t ReadAligned64(const void *&p)
+{
+    return ByteOrder::Swap64BigToHost(IO::ReadAligned64(p));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to write the target system byte
+ *                    ordered 8-bit value to in big endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     WriteAligned8(void *&p, uint8_t v)
+{
+    IO::WriteAligned8(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to write the target system byte
+ *                    ordered 16-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     WriteAligned16(void *&p, uint16_t v)
+{
+    IO::WriteAligned16(p, ByteOrder::Swap16HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to write the target system byte
+ *                    ordered 32-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     WriteAligned32(void *&p, uint32_t v)
+{
+    IO::WriteAligned32(p, ByteOrder::Swap32HostToBig(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to write the target system byte
+ *                    ordered 64-bit value to in big endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     WriteAligned64(void *&p, uint64_t v)
+{
+    IO::WriteAligned64(p, ByteOrder::Swap64HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 8-bit big endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  GetUnaligned8(const void *p)
+{
+    return IO::GetUnaligned8(p);
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 16-bit big endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t GetUnaligned16(const void *p)
+{
+    return ByteOrder::Swap16BigToHost(IO::GetUnaligned16(p));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 32-bit big endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t GetUnaligned32(const void *p)
+{
+    return ByteOrder::Swap32BigToHost(IO::GetUnaligned32(p));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 64-bit big endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t GetUnaligned64(const void *p)
+{
+    return ByteOrder::Swap64BigToHost(IO::GetUnaligned64(p));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 8-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     PutUnaligned8(void *p, uint8_t v)
+{
+    IO::PutUnaligned8(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 16-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     PutUnaligned16(void *p, uint16_t v)
+{
+    IO::PutUnaligned16(p, ByteOrder::Swap16HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 32-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     PutUnaligned32(void *p, uint32_t v)
+{
+    IO::PutUnaligned32(p, ByteOrder::Swap32HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 64-bit value to in big
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     PutUnaligned64(void *p, uint64_t v)
+{
+    IO::PutUnaligned64(p, ByteOrder::Swap64HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to read the 8-bit big endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  ReadUnaligned8(const void *&p)
+{
+    return IO::ReadUnaligned8(p);
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to read the 16-bit big endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t ReadUnaligned16(const void *&p)
+{
+    return ByteOrder::Swap16BigToHost(IO::ReadUnaligned16(p));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to read the 32-bit big endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t ReadUnaligned32(const void *&p)
+{
+    return ByteOrder::Swap32BigToHost(IO::ReadUnaligned32(p));
+}
+
+/**
+ * Perform an unaligned memory read of the big endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to read the 64-bit big endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t ReadUnaligned64(const void *&p)
+{
+    return ByteOrder::Swap64BigToHost(IO::ReadUnaligned64(p));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to write the target system byte
+ *                    ordered 8-bit value to in big endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned8(void *&p, uint8_t v)
+{
+    IO::WriteUnaligned8(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to write the target system byte
+ *                    ordered 16-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned16(void *&p, uint16_t v)
+{
+    IO::WriteUnaligned16(p, ByteOrder::Swap16HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to write the target system byte
+ *                    ordered 32-bit value to in big endian byte
+ *                    ordering and to then increment by 16-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned32(void *&p, uint32_t v)
+{
+    IO::WriteUnaligned32(p, ByteOrder::Swap32HostToBig(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in big endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to write the target system byte
+ *                    ordered 64-bit value to in big endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned64(void *&p, uint64_t v)
+{
+    IO::WriteUnaligned64(p, ByteOrder::Swap64HostToBig(v));
+}
+
+}; // namespace BigEndian
+
+}; // namespace IO
+
+}; // namespace nl
+
+#endif // NLIO_BYTEORDER_BIG_HPP
diff --git a/include/nlio-byteorder-little.h b/include/nlio-byteorder-little.h
new file mode 100644
index 0000000..06c477e
--- /dev/null
+++ b/include/nlio-byteorder-little.h
@@ -0,0 +1,915 @@
+/**
+ *    Copyright 2013-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines C functions for safely performing simple,
+ *      memory-mapped accesses, potentially to unaligned, aligned, and
+ *      unaligned memory locations with byte reordering, specifically
+ *      for little endian target systems.
+ */
+
+#ifndef NLIO_BYTEORDER_LITTLE_H
+#define NLIO_BYTEORDER_LITTLE_H
+
+#include <nlio-base.h>
+#include <nlbyteorder.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 8-bit little endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOLittleEndianGet8(const void *p)
+{
+    return nlIOGet8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 16-bit little endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOLittleEndianGet16(const void *p)
+{
+    return nlByteOrderSwap16LittleToHost(nlIOGet16(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 32-bit little endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOLittleEndianGet32(const void *p)
+{
+    return nlByteOrderSwap32LittleToHost(nlIOGet32(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 64-bit little endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOLittleEndianGet64(const void *p)
+{
+    return nlByteOrderSwap64LittleToHost(nlIOGet64(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 8-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPut8(void *p, uint8_t v)
+{
+    nlIOPut8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 16-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPut16(void *p, uint16_t v)
+{
+    nlIOPut16(p, nlByteOrderSwap16HostToLittle(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 32-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPut32(void *p, uint32_t v)
+{
+    nlIOPut32(p, nlByteOrderSwap32HostToLittle(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 64-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPut64(void *p, uint64_t v)
+{
+    nlIOPut64(p, nlByteOrderSwap64HostToLittle(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 8-bit little endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOLittleEndianRead8(const void **p)
+{
+    return nlIORead8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 16-bit little endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOLittleEndianRead16(const void **p)
+{
+    return nlByteOrderSwap16LittleToHost(nlIORead16(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 32-bit little endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOLittleEndianRead32(const void **p)
+{
+    return nlByteOrderSwap32LittleToHost(nlIORead32(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to a pointer address, potentially
+ *                    unaligned, to read the 64-bit little endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOLittleEndianRead64(const void **p)
+{
+    return nlByteOrderSwap64LittleToHost(nlIORead64(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 8-bit value to in little endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWrite8(void **p, uint8_t v)
+{
+    nlIOWrite8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 16-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWrite16(void **p, uint16_t v)
+{
+    nlIOWrite16(p, nlByteOrderSwap16HostToLittle(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 32-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWrite32(void **p, uint32_t v)
+{
+    nlIOWrite32(p, nlByteOrderSwap32HostToLittle(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 64-bit value to in little endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWrite64(void **p, uint64_t v)
+{
+    nlIOWrite64(p, nlByteOrderSwap64HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 8-bit little endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOLittleEndianGetAligned8(const void *p)
+{
+    return nlIOGetAligned8(p);
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 16-bit little endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOLittleEndianGetAligned16(const void *p)
+{
+    return nlByteOrderSwap16LittleToHost(nlIOGetAligned16(p));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 32-bit little endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOLittleEndianGetAligned32(const void *p)
+{
+    return nlByteOrderSwap32LittleToHost(nlIOGetAligned32(p));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 64-bit little endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOLittleEndianGetAligned64(const void *p)
+{
+    return nlByteOrderSwap64LittleToHost(nlIOGetAligned64(p));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 8-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPutAligned8(void *p, uint8_t v)
+{
+    nlIOPutAligned8(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 16-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPutAligned16(void *p, uint16_t v)
+{
+    nlIOPutAligned16(p, nlByteOrderSwap16HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 32-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPutAligned32(void *p, uint32_t v)
+{
+    nlIOPutAligned32(p, nlByteOrderSwap32HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 64-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPutAligned64(void *p, uint64_t v)
+{
+    nlIOPutAligned64(p, nlByteOrderSwap64HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to read the 8-bit little endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOLittleEndianReadAligned8(const void **p)
+{
+    return nlIOReadAligned8(p);
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to read the 16-bit little endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOLittleEndianReadAligned16(const void **p)
+{
+    return nlByteOrderSwap16LittleToHost(nlIOReadAligned16(p));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to read the 32-bit little endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOLittleEndianReadAligned32(const void **p)
+{
+    return nlByteOrderSwap32LittleToHost(nlIOReadAligned32(p));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to read the 64-bit little endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOLittleEndianReadAligned64(const void **p)
+{
+    return nlByteOrderSwap64LittleToHost(nlIOReadAligned64(p));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to write the target system byte
+ *                    ordered 8-bit value to in little endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWriteAligned8(void **p, uint8_t v)
+{
+    nlIOWriteAligned8(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to write the target system byte
+ *                    ordered 16-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWriteAligned16(void **p, uint16_t v)
+{
+    nlIOWriteAligned16(p, nlByteOrderSwap16HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to write the target system byte
+ *                    ordered 32-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWriteAligned32(void **p, uint32_t v)
+{
+    nlIOWriteAligned32(p, nlByteOrderSwap32HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an aligned pointer address, 
+ *                    to write the target system byte
+ *                    ordered 64-bit value to in little endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWriteAligned64(void **p, uint64_t v)
+{
+    nlIOWriteAligned64(p, nlByteOrderSwap64HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 8-bit little endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOLittleEndianGetUnaligned8(const void *p)
+{
+    return nlIOGetUnaligned8(p);
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 16-bit little endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOLittleEndianGetUnaligned16(const void *p)
+{
+    return nlByteOrderSwap16LittleToHost(nlIOGetUnaligned16(p));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 32-bit little endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOLittleEndianGetUnaligned32(const void *p)
+{
+    return nlByteOrderSwap32LittleToHost(nlIOGetUnaligned32(p));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 64-bit little endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOLittleEndianGetUnaligned64(const void *p)
+{
+    return nlByteOrderSwap64LittleToHost(nlIOGetUnaligned64(p));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 8-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPutUnaligned8(void *p, uint8_t v)
+{
+    nlIOPutUnaligned8(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 16-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPutUnaligned16(void *p, uint16_t v)
+{
+    nlIOPutUnaligned16(p, nlByteOrderSwap16HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 32-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPutUnaligned32(void *p, uint32_t v)
+{
+    nlIOPutUnaligned32(p, nlByteOrderSwap32HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 64-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianPutUnaligned64(void *p, uint64_t v)
+{
+    nlIOPutUnaligned64(p, nlByteOrderSwap64HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to read the 8-bit little endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  nlIOLittleEndianReadUnaligned8(const void **p)
+{
+    return nlIOReadUnaligned8(p);
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to read the 16-bit little endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t nlIOLittleEndianReadUnaligned16(const void **p)
+{
+    return nlByteOrderSwap16LittleToHost(nlIOReadUnaligned16(p));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to read the 32-bit little endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t nlIOLittleEndianReadUnaligned32(const void **p)
+{
+    return nlByteOrderSwap32LittleToHost(nlIOReadUnaligned32(p));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to read the 64-bit little endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t nlIOLittleEndianReadUnaligned64(const void **p)
+{
+    return nlByteOrderSwap64LittleToHost(nlIOReadUnaligned64(p));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to write the target system byte
+ *                    ordered 8-bit value to in little endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWriteUnaligned8(void **p, uint8_t v)
+{
+    nlIOWriteUnaligned8(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to write the target system byte
+ *                    ordered 16-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWriteUnaligned16(void **p, uint16_t v)
+{
+    nlIOWriteUnaligned16(p, nlByteOrderSwap16HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to write the target system byte
+ *                    ordered 32-bit value to in little endian byte
+ *                    ordering and to then increment by 32-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWriteUnaligned32(void **p, uint32_t v)
+{
+    nlIOWriteUnaligned32(p, nlByteOrderSwap32HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A pointer to an unaligined pointer address, 
+ *                    to write the target system byte
+ *                    ordered 64-bit value to in little endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     nlIOLittleEndianWriteUnaligned64(void **p, uint64_t v)
+{
+    nlIOWriteUnaligned64(p, nlByteOrderSwap64HostToLittle(v));
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NLIO_BYTEORDER_LITTLE_H */
diff --git a/include/nlio-byteorder-little.hpp b/include/nlio-byteorder-little.hpp
new file mode 100644
index 0000000..7c3ec2e
--- /dev/null
+++ b/include/nlio-byteorder-little.hpp
@@ -0,0 +1,922 @@
+/**
+ *    Copyright 2013-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines C++ functions for safely performing simple,
+ *      memory-mapped accesses, potentially to unaligned, aligned, and
+ *      unaligned memory locations with byte reordering, specifically
+ *      for little endian target systems.
+ */
+
+#ifndef NLIO_BYTEORDER_LITTLE_HPP
+#define NLIO_BYTEORDER_LITTLE_HPP
+
+#include <nlio-base.hpp>
+#include <nlbyteorder.hpp>
+
+namespace nl
+{
+
+namespace IO
+{
+
+namespace LittleEndian
+{
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 8-bit little endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  Get8(const void *p)
+{
+    return IO::Get8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 16-bit little endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t Get16(const void *p)
+{
+    return ByteOrder::Swap16LittleToHost(IO::Get16(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 32-bit little endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t Get32(const void *p)
+{
+    return ByteOrder::Swap32LittleToHost(IO::Get32(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to read
+ *                    the 64-bit little endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t Get64(const void *p)
+{
+    return ByteOrder::Swap64LittleToHost(IO::Get64(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 8-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     Put8(void *p, uint8_t v)
+{
+    IO::Put8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 16-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     Put16(void *p, uint16_t v)
+{
+    IO::Put16(p, ByteOrder::Swap16HostToLittle(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 32-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     Put32(void *p, uint32_t v)
+{
+    IO::Put32(p, ByteOrder::Swap32HostToLittle(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A pointer address, potentially unaligned, to write
+ *                    the target system byte ordered 64-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     Put64(void *p, uint64_t v)
+{
+    IO::Put64(p, ByteOrder::Swap64HostToLittle(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 8-bit little endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  Read8(const void *&p)
+{
+    return IO::Read8(p);
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 16-bit little endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t Read16(const void *&p)
+{
+    return ByteOrder::Swap16LittleToHost(IO::Read16(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 32-bit little endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t Read32(const void *&p)
+{
+    return ByteOrder::Swap32LittleToHost(IO::Read32(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to a pointer address, potentially
+ *                    unaligned, to read the 64-bit little endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t Read64(const void *&p)
+{
+    return ByteOrder::Swap64LittleToHost(IO::Read64(p));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A reference to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 8-bit value to in little endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     Write8(void *&p, uint8_t v)
+{
+    IO::Write8(p, v);
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A reference to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 16-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     Write16(void *&p, uint16_t v)
+{
+    IO::Write16(p, ByteOrder::Swap16HostToLittle(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A reference to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 32-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     Write32(void *&p, uint32_t v)
+{
+    IO::Write32(p, ByteOrder::Swap32HostToLittle(v));
+}
+
+/**
+ * Perform a, potentially unaligned, memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      A reference to a pointer address, potentially
+ *                    unaligned, to write the target system byte
+ *                    ordered 64-bit value to in little endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     Write64(void *&p, uint64_t v)
+{
+    IO::Write64(p, ByteOrder::Swap64HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 8-bit little endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  GetAligned8(const void *p)
+{
+    return IO::GetAligned8(p);
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 16-bit little endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t GetAligned16(const void *p)
+{
+    return ByteOrder::Swap16LittleToHost(IO::GetAligned16(p));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 32-bit little endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t GetAligned32(const void *p)
+{
+    return ByteOrder::Swap32LittleToHost(IO::GetAligned32(p));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to read
+ *                    the 64-bit little endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t GetAligned64(const void *p)
+{
+    return ByteOrder::Swap64LittleToHost(IO::GetAligned64(p));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 8-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     PutAligned8(void *p, uint8_t v)
+{
+    IO::PutAligned8(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 16-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     PutAligned16(void *p, uint16_t v)
+{
+    IO::PutAligned16(p, ByteOrder::Swap16HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 32-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     PutAligned32(void *p, uint32_t v)
+{
+    IO::PutAligned32(p, ByteOrder::Swap32HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An aligned pointer address to write
+ *                    the target system byte ordered 64-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     PutAligned64(void *p, uint64_t v)
+{
+    IO::PutAligned64(p, ByteOrder::Swap64HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to read the 8-bit little endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  ReadAligned8(const void *&p)
+{
+    return IO::ReadAligned8(p);
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to read the 16-bit little endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t ReadAligned16(const void *&p)
+{
+    return ByteOrder::Swap16LittleToHost(IO::ReadAligned16(p));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to read the 32-bit little endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t ReadAligned32(const void *&p)
+{
+    return ByteOrder::Swap32LittleToHost(IO::ReadAligned32(p));
+}
+
+/**
+ * Perform an aligned memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to read the 64-bit little endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t ReadAligned64(const void *&p)
+{
+    return ByteOrder::Swap64LittleToHost(IO::ReadAligned64(p));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to write the target system byte
+ *                    ordered 8-bit value to in little endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     WriteAligned8(void *&p, uint8_t v)
+{
+    IO::WriteAligned8(p, v);
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to write the target system byte
+ *                    ordered 16-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     WriteAligned16(void *&p, uint16_t v)
+{
+    IO::WriteAligned16(p, ByteOrder::Swap16HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to write the target system byte
+ *                    ordered 32-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     WriteAligned32(void *&p, uint32_t v)
+{
+    IO::WriteAligned32(p, ByteOrder::Swap32HostToLittle(v));
+}
+
+/**
+ * Perform an aligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an aligned pointer address
+ *                    to write the target system byte
+ *                    ordered 64-bit value to in little endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     WriteAligned64(void *&p, uint64_t v)
+{
+    IO::WriteAligned64(p, ByteOrder::Swap64HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 8-bit little endian byte ordered value from.
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  GetUnaligned8(const void *p)
+{
+    return IO::GetUnaligned8(p);
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 16-bit little endian byte ordered value from.
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t GetUnaligned16(const void *p)
+{
+    return ByteOrder::Swap16LittleToHost(IO::GetUnaligned16(p));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 32-bit little endian byte ordered value from.
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t GetUnaligned32(const void *p)
+{
+    return ByteOrder::Swap32LittleToHost(IO::GetUnaligned32(p));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in target system byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to read
+ *                    the 64-bit little endian byte ordered value from.
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t GetUnaligned64(const void *p)
+{
+    return ByteOrder::Swap64LittleToHost(IO::GetUnaligned64(p));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 8-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     PutUnaligned8(void *p, uint8_t v)
+{
+    IO::PutUnaligned8(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 16-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     PutUnaligned16(void *p, uint16_t v)
+{
+    IO::PutUnaligned16(p, ByteOrder::Swap16HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 32-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     PutUnaligned32(void *p, uint32_t v)
+{
+    IO::PutUnaligned32(p, ByteOrder::Swap32HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[in]  p      An unaligned pointer address to write
+ *                    the target system byte ordered 64-bit value to in little
+ *                    endian byte ordering.
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     PutUnaligned64(void *p, uint64_t v)
+{
+    IO::PutUnaligned64(p, ByteOrder::Swap64HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 8-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 8-bits (1 byte).
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to read the 8-bit little endian byte
+ *                    ordered value from and to then increment by 8-
+ *                    bits (1 byte).
+ *
+ * @return The 8-bit value at the specified pointer address.
+ */
+static inline uint8_t  ReadUnaligned8(const void *&p)
+{
+    return IO::ReadUnaligned8(p);
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 16-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 16-bits (2 bytes).
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to read the 16-bit little endian byte
+ *                    ordered value from and to then increment by 16-
+ *                    bits (2 bytes).
+ *
+ * @return The 16-bit value at the specified pointer address.
+ */
+static inline uint16_t ReadUnaligned16(const void *&p)
+{
+    return ByteOrder::Swap16LittleToHost(IO::ReadUnaligned16(p));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 32-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 32-bits (4 bytes).
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to read the 32-bit little endian byte
+ *                    ordered value from and to then increment by 32-
+ *                    bits (4 bytes).
+ *
+ * @return The 32-bit value at the specified pointer address.
+ */
+static inline uint32_t ReadUnaligned32(const void *&p)
+{
+    return ByteOrder::Swap32LittleToHost(IO::ReadUnaligned32(p));
+}
+
+/**
+ * Perform an unaligned memory read of the little endian
+ * byte ordered 64-bit value from the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to put
+ * the value in target system byte ordering, and increment the pointer
+ * by 64-bits (8 bytes).
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to read the 64-bit little endian byte
+ *                    ordered value from and to then increment by 64-
+ *                    bits (8 bytes).
+ *
+ * @return The 64-bit value at the specified pointer address.
+ */
+static inline uint64_t ReadUnaligned64(const void *&p)
+{
+    return ByteOrder::Swap64LittleToHost(IO::ReadUnaligned64(p));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 8-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to write the target system byte
+ *                    ordered 8-bit value to in little endian byte
+ *                    ordering and to then increment by 8-bits (1
+ *                    byte).
+ *
+ * @param[in]  v      The 8-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned8(void *&p, uint8_t v)
+{
+    IO::WriteUnaligned8(p, v);
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 16-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to write the target system byte
+ *                    ordered 16-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (2
+ *                    bytes).
+ *
+ * @param[in]  v      The 16-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned16(void *&p, uint16_t v)
+{
+    IO::WriteUnaligned16(p, ByteOrder::Swap16HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 32-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to write the target system byte
+ *                    ordered 32-bit value to in little endian byte
+ *                    ordering and to then increment by 16-bits (4
+ *                    bytes).
+ *
+ * @param[in]  v      The 32-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned32(void *&p, uint32_t v)
+{
+    IO::WriteUnaligned32(p, ByteOrder::Swap32HostToLittle(v));
+}
+
+/**
+ * Perform an unaligned memory write of the target system
+ * byte ordered 64-bit value to the specified pointer address,
+ * perform byte reordering, as necessary, for the target system to
+ * put the value in little endian byte ordering.
+ *
+ * @param[inout]  p   A reference to an unaligned pointer address
+ *                    to write the target system byte
+ *                    ordered 64-bit value to in little endian byte
+ *                    ordering and to then increment by 64-bits (8
+ *                    bytes).
+ *
+ * @param[in]  v      The 64-bit value to write.
+ *
+ */
+static inline void     WriteUnaligned64(void *&p, uint64_t v)
+{
+    IO::WriteUnaligned64(p, ByteOrder::Swap64HostToLittle(v));
+}
+
+}; // namespace LittleEndian
+
+}; // namespace IO
+
+}; // namespace nl
+
+#endif // NLIO_BYTEORDER_LITTLE_HPP
diff --git a/include/nlio-byteorder.h b/include/nlio-byteorder.h
new file mode 100644
index 0000000..9e67001
--- /dev/null
+++ b/include/nlio-byteorder.h
@@ -0,0 +1,33 @@
+/**
+ *    Copyright 2013-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines C functions for safely performing simple,
+ *      memory-mapped accesses, potentially to unaligned memory
+ *      locations with byte reordering.
+ */
+
+#ifndef NLIO_BYTEORDER_H
+#define NLIO_BYTEORDER_H
+
+#include <nlio-base.h>
+#include <nlbyteorder.h>
+
+#include <nlio-byteorder-big.h>
+#include <nlio-byteorder-little.h>
+
+#endif /* NLIO_BYTEORDER_H */
diff --git a/include/nlio-byteorder.hpp b/include/nlio-byteorder.hpp
new file mode 100644
index 0000000..e44256b
--- /dev/null
+++ b/include/nlio-byteorder.hpp
@@ -0,0 +1,33 @@
+/**
+ *    Copyright 2013-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines C++ functions for safely performing simple,
+ *      memory-mapped accesses, potentially to unaligned memory
+ *      locations with byte reordering.
+ */
+
+#ifndef NLIO_BYTEORDER_HPP
+#define NLIO_BYTEORDER_HPP
+
+#include <nlio-base.hpp>
+#include <nlbyteorder.hpp>
+
+#include <nlio-byteorder-big.hpp>
+#include <nlio-byteorder-little.hpp>
+
+#endif // NLIO_BYTEORDER_HPP
diff --git a/include/nlio-config.h.in b/include/nlio-config.h.in
new file mode 100644
index 0000000..06cf758
--- /dev/null
+++ b/include/nlio-config.h.in
@@ -0,0 +1,133 @@
+/* include/nlio-config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if your C++ compiler doesn't accept -c and -o together. */
+#undef CXX_NO_MINUS_C_MINUS_O
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the <endian.h> header file. */
+#undef HAVE_ENDIAN_H
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the <machine/endian.h> header file. */
+#undef HAVE_MACHINE_ENDIAN_H
+
+/* Define to 1 if you have the `memcpy' function. */
+#undef HAVE_MEMCPY
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the <nlunit-test.h> header file. */
+#undef HAVE_NLUNIT_TEST_H
+
+/* Define to 1 if stdbool.h conforms to C99. */
+#undef HAVE_STDBOOL_H
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to 1 if the system has the type `_Bool'. */
+#undef HAVE__BOOL
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#undef LT_OBJDIR
+
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+#undef NO_MINUS_C_MINUS_O
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Version number of package */
+#undef VERSION
+
+/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+#undef _UINT32_T
+
+/* Define for Solaris 2.5.1 so the uint64_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+#undef _UINT64_T
+
+/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+#undef _UINT8_T
+
+/* Define to the type of a signed integer type of width exactly 16 bits if
+   such a type exists and the standard includes do not define it. */
+#undef int16_t
+
+/* Define to the type of a signed integer type of width exactly 32 bits if
+   such a type exists and the standard includes do not define it. */
+#undef int32_t
+
+/* Define to the type of a signed integer type of width exactly 64 bits if
+   such a type exists and the standard includes do not define it. */
+#undef int64_t
+
+/* Define to the type of a signed integer type of width exactly 8 bits if such
+   a type exists and the standard includes do not define it. */
+#undef int8_t
+
+/* Define to the type of an unsigned integer type of width exactly 16 bits if
+   such a type exists and the standard includes do not define it. */
+#undef uint16_t
+
+/* Define to the type of an unsigned integer type of width exactly 32 bits if
+   such a type exists and the standard includes do not define it. */
+#undef uint32_t
+
+/* Define to the type of an unsigned integer type of width exactly 64 bits if
+   such a type exists and the standard includes do not define it. */
+#undef uint64_t
+
+/* Define to the type of an unsigned integer type of width exactly 8 bits if
+   such a type exists and the standard includes do not define it. */
+#undef uint8_t
diff --git a/include/nlio-private.h b/include/nlio-private.h
new file mode 100644
index 0000000..22dc4d0
--- /dev/null
+++ b/include/nlio-private.h
@@ -0,0 +1,50 @@
+/**
+ *    Copyright 2017 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file defines private macros and interfaces.
+ */
+
+#ifndef NLIO_PRIVATE_H
+#define NLIO_PRIVATE_H
+
+/*
+ * If we are compiling under clang, GCC, or any such compatible
+ * compiler, in which -fno-builtins or -ffreestanding might be
+ * asserted, thereby eliminating built-in function optimization, we
+ * may STILL want to leverage built-ins.
+ *
+ * Provide an internal convenience macro to do so.
+ */
+
+/**
+ *  @def __nlIOHasBuiltin
+ *
+ *  @brief
+ *     Determines whether or not the compiler in effect has support
+ *     for the specified built-in function.
+ *
+ */
+#ifdef __clang__
+#define __nlIOHasBuiltin(...) __has_builtin(__VA_ARGS__)
+#elif defined __GNUC__
+#define __nlIOHasBuiltin(...) 1
+#else
+#define __nlIOHasBuiltin(...) 0
+#endif /* __clang__ */
+
+#endif /* NLIO_PRIVATE_H */
diff --git a/include/nlio.h b/include/nlio.h
new file mode 100644
index 0000000..b706826
--- /dev/null
+++ b/include/nlio.h
@@ -0,0 +1,38 @@
+/**
+ *    Copyright 2013-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file is an umbrella header for the C language definitions
+ *      of functions for safely performing simple, memory-mapped
+ *      accesses, potentially to unaligned memory locations, with or
+ *      without byte reordering.
+ */
+
+#ifndef NLIO_H
+#define NLIO_H
+
+#include <nlio-base.h>
+#include <nlio-byteorder.h>
+
+#endif /* NLIO_H */
+
+
+
+
+
+
+
diff --git a/include/nlio.hpp b/include/nlio.hpp
new file mode 100644
index 0000000..47487f3
--- /dev/null
+++ b/include/nlio.hpp
@@ -0,0 +1,38 @@
+/**
+ *    Copyright 2013-2016 Nest Labs Inc. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      This file is an umbrella header for the C++ language
+ *      definitions of functions for safely performing simple,
+ *      memory-mapped accesses, potentially to unaligned memory
+ *      locations, with or without byte reordering.
+ */
+
+#ifndef NLIO_HPP
+#define NLIO_HPP
+
+#include <nlio-base.hpp>
+#include <nlio-byteorder.hpp>
+
+#endif // NLIO_HPP
+
+
+
+
+
+
+