diff --git a/applications/test/PackedList1/PackedListTest1.C b/applications/test/PackedList1/PackedListTest1.C
index 5e1902f382..461db54158 100644
--- a/applications/test/PackedList1/PackedListTest1.C
+++ b/applications/test/PackedList1/PackedListTest1.C
@@ -42,42 +42,42 @@ int main(int argc, char *argv[])
 
     Info<< "\ntest allocation with value\n";
     PackedList<3> list1(5,1);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest assign uniform value\n";
     list1 = 3;
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest assign uniform value (with overflow)\n";
     list1 = -1;
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest zero\n";
     list1 = 0;
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest set() with default argument (max_value)\n";
     list1.set(1);
     list1.set(3);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest unset() with in-range and out-of-range\n";
     list1.unset(3);
     list1.unset(100000);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest assign between references\n";
     list1[2] = 3;
     list1[4] = list1[2];
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest assign between references, with chaining\n";
     list1[0] = list1[4] = 1;
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest assign between references, with chaining and auto-vivify\n";
     list1[1] = list1[8] = list1[10] = list1[14] = 2;
-    list1.print(Info);
+    list1.print(Info, true);
 
 
     Info<< "\ntest operator== between references\n";
@@ -126,7 +126,7 @@ int main(int argc, char *argv[])
     {
         const PackedList<3>& constLst = list1;
         Info<< "\ntest operator[] const with out-of-range index\n";
-        constLst.print(Info);
+        constLst.print(Info, true);
         if (constLst[20])
         {
             Info<< "[20] is true (unexpected)\n";
@@ -136,7 +136,7 @@ int main(int argc, char *argv[])
             Info<< "[20] is false (expected) list size should be unchanged "
                 << "(const)\n";
         }
-        constLst.print(Info);
+        constLst.print(Info, true);
 
         Info<< "\ntest operator[] non-const with out-of-range index\n";
         if (list1[20])
@@ -148,7 +148,7 @@ int main(int argc, char *argv[])
             Info<< "[20] is false (expected) but list was resized?? "
                 << "(non-const)\n";
         }
-        list1.print(Info);
+        list1.print(Info, true);
     }
 
 
@@ -157,85 +157,85 @@ int main(int argc, char *argv[])
     {
         Info<< "[20] is false, as expected\n";
     }
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest resize with value (without reallocation)\n";
     list1.resize(8, list1.max_value());
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest flip() function\n";
     list1.flip();
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\nre-flip()\n";
     list1.flip();
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest set() function\n";
     list1.set(1, 5);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest assign bool\n";
     list1 = false;
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest assign bool\n";
     list1 = true;
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest resize without value (with reallocation)\n";
     list1.resize(12);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest resize with value (with reallocation)\n";
     list1.resize(25, list1.max_value());
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest resize smaller (should not touch allocation)\n";
     list1.resize(8);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest append() operation\n";
     list1.append(2);
     list1.append(3);
     list1.append(4);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest reserve() operation\n";
     list1.reserve(32);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest shrink() operation\n";
     list1.shrink();
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest setCapacity() operation\n";
     list1.setCapacity(15);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest setCapacity() operation\n";
     list1.setCapacity(100);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest operator[] assignment\n";
     list1[16] = 5;
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest operator[] assignment with auto-vivify\n";
     list1[36] = list1.max_value();
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest setCapacity smaller\n";
     list1.setCapacity(24);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest resize much smaller\n";
     list1.resize(150);
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest trim\n";
     list1.trim();
-    list1.print(Info);
+    list1.print(Info, true);
 
     // add in some misc values
     list1[31] = 1;
@@ -250,7 +250,7 @@ int main(int argc, char *argv[])
     Info<< "iterator:" << iter() << "\n";
     iter() = 5;
     iter.print(Info);
-    list1.print(Info);
+    list1.print(Info, true);
 
     iter = list1[31];
     Info<< "iterator:" << iter() << "\n";
@@ -259,7 +259,7 @@ int main(int argc, char *argv[])
 
     Info<< "\ntest get() method\n";
     Info<< "get(10):" << list1.get(10) << " and list[10]:" << list1[10] << "\n";
-    list1.print(Info);
+    list1.print(Info, true);
 
     Info<< "\ntest iterator indexing\n";
     Info<< "cend() ";
@@ -267,7 +267,7 @@ int main(int argc, char *argv[])
 
     {
         Info<< "\ntest assignment of iterator\n";
-        list1.print(Info);
+        list1.print(Info, true);
         Info<< "cend()\n";
         list1.end().print(Info);
         PackedList<3>::iterator cit = list1[100];
@@ -304,16 +304,16 @@ int main(int argc, char *argv[])
     Info<< "size after write:" << list1.size() << "\n";
     Info<< "list[45]:" << list1[45] << "\n";
     list1[49] = list1[100];
-    list1.print(Info);
+    list1.print(Info, true);
 
 
     Info<< "\ntest copy constructor + append\n";
     PackedList<3> list2(list1);
     list2.append(4);
     Info<< "source list:\n";
-    list1.print(Info);
+    list1.print(Info, true);
     Info<< "destination list:\n";
-    list2.print(Info);
+    list2.print(Info, true);
 
     Info<< "\ntest pattern that fills all bits\n";
     PackedList<4> list3(8, 8);
@@ -323,10 +323,12 @@ int main(int argc, char *argv[])
     list3[pos--] = list3.max_value();
     list3[pos--] = 0;
     list3[pos--] = list3.max_value();
-    list3.print(Info);
+    list3.print(Info, true);
 
     Info<< "removed final value: " << list3.remove() << endl;
-    list3.print(Info);
+    list3.print(Info, true);
+
+    Info<<"list: " << list3 << endl;
 
 
     List<bool> list4(16, false);
diff --git a/applications/test/PackedList3/PackedListTest3.C b/applications/test/PackedList3/PackedListTest3.C
index 5ff6ee8644..7b27ffda09 100644
--- a/applications/test/PackedList3/PackedListTest3.C
+++ b/applications/test/PackedList3/PackedListTest3.C
@@ -33,7 +33,6 @@ Description
 #include "StaticHashTable.H"
 #include "cpuTime.H"
 #include <vector>
-#include "PackedList.H"
 #include "PackedBoolList.H"
 
 using namespace Foam;
@@ -57,7 +56,7 @@ int main(int argc, char *argv[])
     {
         if ((i % nReport) == 0 && i)
         {
-            Info<< "i:" << i << " in " << timer.cpuTimeIncrement() << " s" 
+            Info<< "i:" << i << " in " << timer.cpuTimeIncrement() << " s"
                 <<endl;
         }
         packed[i] = 1;
diff --git a/applications/test/PackedList4/PackedListTest4.C b/applications/test/PackedList4/PackedListTest4.C
index 7271a3f1dd..d1e4e5b143 100644
--- a/applications/test/PackedList4/PackedListTest4.C
+++ b/applications/test/PackedList4/PackedListTest4.C
@@ -30,6 +30,7 @@ Description
 #include "uLabel.H"
 #include "IOstreams.H"
 #include "PackedBoolList.H"
+#include "IStringStream.H"
 
 using namespace Foam;
 
@@ -45,7 +46,7 @@ int main(int argc, char *argv[])
         list1[i] = i % 2;
     }
 
-    Info<< "\nalternative bit pattern\n";
+    Info<< "\nalternating bit pattern\n";
     list1.print(Info, true);
 
     PackedBoolList list2 = ~list1;
@@ -117,6 +118,39 @@ int main(int argc, char *argv[])
         (list3 -= list2Labels).print(Info, true);
     }
 
+
+    PackedBoolList list4
+    (
+        IStringStream
+        (
+            "(AB 05 10 0F F0)"
+        )()
+    );
+
+    Info<< "\ntest Istream constructor\n";
+
+    list4.print(Info, true);
+    Info<< list4 << " indices: " << list4.used()() <<endl;
+
+    Info<< "\nassign from labelList\n";
+    list4 = labelList
+    (
+        IStringStream
+        (
+            "(0 1 2 3 12 13 14 15 17 19 20 21)"
+        )()
+    );
+
+    list4.print(Info, true);
+    Info<< list4 << " indices: " << list4.used()() <<endl;
+
+    Info<< "\nread from Istream\n";
+    IStringStream("(0f 3a)")() >> list4;
+
+    list4.print(Info, true);
+    Info<< list4 << " indices: " << list4.used()() <<endl;
+
+
     return 0;
 }
 
diff --git a/src/OpenFOAM/Make/files b/src/OpenFOAM/Make/files
index bc4369cf48..30289870e3 100644
--- a/src/OpenFOAM/Make/files
+++ b/src/OpenFOAM/Make/files
@@ -67,7 +67,7 @@ containers/HashTables/HashTable/HashTableCore.C
 containers/HashTables/StaticHashTable/StaticHashTableCore.C
 containers/Lists/SortableList/ParSortableListName.C
 containers/Lists/PackedList/PackedListName.C
-containers/Lists/PackedList/APackedBoolList.C
+containers/Lists/PackedList/PackedBoolList.C
 containers/Lists/ListOps/ListOps.C
 containers/LinkedLists/linkTypes/SLListBase/SLListBase.C
 containers/LinkedLists/linkTypes/DLListBase/DLListBase.C
diff --git a/src/OpenFOAM/containers/Lists/List/ListIO.C b/src/OpenFOAM/containers/Lists/List/ListIO.C
index 984971ecc4..a70cc8f9e6 100644
--- a/src/OpenFOAM/containers/Lists/List/ListIO.C
+++ b/src/OpenFOAM/containers/Lists/List/ListIO.C
@@ -135,7 +135,7 @@ Foam::Istream& Foam::operator>>(Istream& is, List<T>& L)
                 << exit(FatalIOError);
         }
 
-        // Putback the openning bracket
+        // Putback the opening bracket
         is.putBack(firstToken);
 
         // Now read as a singly-linked list
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.C b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.C
index f393e144da..548d21414d 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.C
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.C
@@ -24,9 +24,51 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "PackedBoolList.H"
+#include "IOstreams.H"
+#include <cctype>
+
+// * * * * * * * * * * * * * * * Static Members * * * * * * * * * * * * * * * //
+
+// table-lookup instead of printf("%02x", char)
+//! @cond localScope
+static const char hexLookup[] =
+{
+    "000102030405060708090a0b0c0d0e0f"
+    "101112131415161718191a1b1c1d1e1f"
+    "202122232425262728292a2b2c2d2e2f"
+    "303132333435363738393a3b3c3d3e3f"
+    "404142434445464748494a4b4c4d4e4f"
+    "505152535455565758595a5b5c5d5e5f"
+    "606162636465666768696a6b6c6d6e6f"
+    "707172737475767778797a7b7c7d7e7f"
+    "808182838485868788898a8b8c8d8e8f"
+    "909192939495969798999a9b9c9d9e9f"
+    "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
+    "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
+    "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
+    "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
+    "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
+    "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"
+};
+
+
+// number of bytes required to pack nElem
+static inline unsigned int packedBytes(const Foam::label nElem)
+{
+    return (nElem + CHAR_BIT - 1) / CHAR_BIT;
+}
+//! @endcond
+
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
+Foam::PackedBoolList::PackedBoolList(Istream &is)
+:
+    PackedList<1>()
+{
+    is  >> *this;
+}
+
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
@@ -232,6 +274,286 @@ Foam::PackedBoolList::operator^=(const PackedList<1>& lst)
     return *this;
 }
 
+// * * * * * * * * * * * * * *  Friend Operators * * * * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>
+(
+    Istream& istr,
+    PackedBoolList& lst
+)
+{
+    // Takes into account that 'a' (or 'A') is 10
+    static const label alphaOffset = toupper('A') - 10;
+    // Takes into account that '0' is 0
+    static const label zeroOffset = int('0');
+
+    ISstream& is = dynamicCast<ISstream>(istr);
+
+    lst.clear();
+    is.fatalCheck("operator>>(Istream&, PackedBoolList&)");
+
+    token firstTok(is);
+    is.fatalCheck
+    (
+        "operator>>(Istream&, PackedBoolList&) : reading first token"
+    );
+
+    if (firstTok.isLabel())
+    {
+        const label sz = firstTok.labelToken();
+
+        // Set list length to that read
+        lst.resize(sz);
+
+        // Read list contents as ASCII
+
+        // Read beginning of contents
+        const char delimiter = is.readBeginList("PackedBoolList");
+
+        if (sz)
+        {
+            if (delimiter == token::BEGIN_LIST)
+            {
+                // number of bytes when packed:
+                unsigned int nBytes = packedBytes(lst.size());
+
+                for (label i=0, storeI=0; i < sz; ++storeI)
+                {
+                    PackedList<1>::StorageType& stored = lst.storage()[storeI];
+
+                    // byte-wise read
+                    for
+                    (
+                        unsigned byte=0;
+                        byte < sizeof(PackedList<1>::StorageType);
+                        ++byte
+                    )
+                    {
+                        PackedList<1>::StorageType result = 0;
+                        char c = 0;
+
+                        // Get next non-whitespace character
+                        while (is.get(c) && isspace(c))
+                        {}
+
+                        for (label nibble=0; nibble < 2; ++nibble)
+                        {
+                            if (!isxdigit(c))
+                            {
+                                FatalIOErrorIn
+                                (
+                                    "operator>>(Istream&, PackedBoolList&) : "
+                                    "reading first token",
+                                    is
+                                )
+                                    << "Illegal hex digit: '" << c << "'"
+                                    << exit(FatalIOError);
+                            }
+
+                            result <<= 4;
+
+                            if (isdigit(c))
+                            {
+                                result += int(c) - zeroOffset;
+                            }
+                            else
+                            {
+                                result += toupper(c) - alphaOffset;
+                            }
+
+                            // Get character for the lower part of the byte
+                            if (!nibble)
+                            {
+                                is.get(c);
+                            }
+                        }
+
+                        stored |= result << (byte*CHAR_BIT);
+
+                        if (!--nBytes)
+                        {
+                            break;
+                        }
+                    }
+                    i += PackedList<1>::packing();
+                }
+
+                // trim possible trailing junk
+                // mask off the final partial segment
+                {
+                    const unsigned int off = sz % PackedList<1>::packing();
+                    if (off)
+                    {
+                        const unsigned int seg = sz / PackedList<1>::packing();
+
+                        lst.storage()[seg] &= PackedList<1>::maskLower(off);
+                    }
+                }
+
+
+                // skip over all trailing whitespace and zeroes
+                char c = 0;
+                while (is.get(c) && (isspace(c) || c == '0'))
+                {}
+
+                // put back for later readEndList() to deal with
+                is.putback(c);
+            }
+            else
+            {
+                const label val = readLabel(is);
+
+                is.fatalCheck
+                (
+                    "operator>>(Istream&, PackedBoolList&) : "
+                    "reading the single entry"
+                );
+
+                lst = val;
+            }
+        }
+
+        // Read end of contents
+        is.readEndList("PackedList");
+    }
+    else if (firstTok.isPunctuation())
+    {
+        if (firstTok.pToken() != token::BEGIN_LIST)
+        {
+            FatalIOErrorIn
+            (
+                "operator>>(Istream&, PackedBoolList&)",
+                is
+            )
+                << "incorrect first token, expected '(', found "
+                << firstTok.info()
+                << exit(FatalIOError);
+        }
+
+        char c = '(';
+
+        for (label storeI=0; c && c != ')'; ++storeI)
+        {
+            lst.resize((storeI+1)*PackedList<1>::packing());
+
+            PackedList<1>::StorageType& stored = lst.storage()[storeI];
+
+            // byte-wise read
+            for
+            (
+                unsigned byte=0;
+                byte < sizeof(PackedList<1>::StorageType);
+                ++byte
+            )
+            {
+                PackedList<1>::StorageType result = 0;
+                c = 0;
+
+                // Get next non-whitespace character
+                while (is.get(c) && isspace(c))
+                {}
+
+                if (!c || c == ')')
+                {
+                    break;
+                }
+
+                for (label nibble=0; nibble < 2; ++nibble)
+                {
+                    if (!isxdigit(c))
+                    {
+                        FatalIOErrorIn
+                        (
+                            "operator>>(Istream&, PackedBoolList&)",
+                            is
+                        )
+                            << "Illegal hex digit: '" << c << "'"
+                            << exit(FatalIOError);
+                    }
+
+                    result *= 16;
+
+                    if (isdigit(c))
+                    {
+                        result += int(c) - zeroOffset;
+                    }
+                    else
+                    {
+                        result += toupper(c) - alphaOffset;
+                    }
+
+                    // Get character for the lower part of the byte
+                    if (!nibble)
+                    {
+                        is.get(c);
+                    }
+                }
+
+                stored |= result << (byte*CHAR_BIT);
+            }
+        }
+
+        // put back for later readEndList() to deal with
+        is.putback(c);
+
+        // Read end of contents
+        is.readEndList("PackedList");
+    }
+    else
+    {
+        FatalIOErrorIn
+        (
+            "operator>>(Istream&, PackedBoolList&)",
+            is
+        )
+            << "incorrect first token, expected <int> or '(', found "
+            << firstTok.info()
+            << exit(FatalIOError);
+    }
+
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const PackedBoolList& lst
+)
+{
+    const label sz = lst.size();
+
+    unsigned int nBytes = packedBytes(sz);
+
+    os  << sz << token::BEGIN_LIST;
+
+    for (label storeI=0; nBytes; ++storeI)
+    {
+        PackedList<1>::StorageType stored = lst.storage()[storeI];
+
+        for
+        (
+            unsigned byte=0;
+            byte < sizeof(PackedList<1>::StorageType);
+            ++byte
+        )
+        {
+            os  << hexLookup[((stored & 0xFF) << 1)]
+                << hexLookup[((stored & 0xFF) << 1) + 1];
+
+            if (!--nBytes)
+            {
+                break;
+            }
+            stored >>= 8;
+        }
+    }
+
+    os  << token::END_LIST;
+
+    return os;
+}
+
 
 // * * * * * * * * * * * * * *  Global Operators * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.H b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.H
index 1d2b19ac07..cf0ba7d6a5 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.H
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.H
@@ -27,6 +27,31 @@ Class
 Description
     A bit-packed bool list
 
+Note
+    The input/output format differs from that of Foam::PackedBoolList in
+    that it is also packed. The input/output is always byte-wise, with
+    the lowest bytes first.
+
+    Thus this label sequence
+    @code
+        0 1 2 3 12 13 14 15 17 19 20 21
+    @endcode
+    which has this bit representation:
+    @code
+        ..........111-1-1111--------1111
+    @endcode
+    and this internal representation
+    @code
+        0x003AF00F
+    @endcode
+    would be read/written in one of these formats:
+    @code
+        22(0f f0 3a)
+        22(0ff03a)
+    @endcode
+    Whitespace can be used to separate byte values, but must not appear
+    within a byte itself.
+
 SourceFiles
     PackedBoolListI.H
     PackedBoolList.C
@@ -47,6 +72,16 @@ SeeAlso
 namespace Foam
 {
 
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+// Forward declaration of friend functions and operators
+class PackedBoolList;
+Istream& operator>>(Istream&, PackedBoolList&);
+Ostream& operator<<(Ostream&, const PackedBoolList&);
+
+
 /*---------------------------------------------------------------------------*\
                        Class PackedBoolList Declaration
 \*---------------------------------------------------------------------------*/
@@ -55,7 +90,6 @@ class PackedBoolList
 :
     public PackedList<1>
 {
-
     // Private Member Functions
 
         //- Modulo is everything that is not in lst
@@ -72,7 +106,6 @@ class PackedBoolList
         template<class LabelListType>
         label unsetFromIndices(const LabelListType& indices);
 
-
 public:
 
     // Constructors
@@ -80,6 +113,9 @@ public:
         //- Construct null
         inline PackedBoolList();
 
+        //- Construct from Istream
+        PackedBoolList(Istream&);
+
         //- Construct with given size, initializes list to 0
         explicit inline PackedBoolList(const label size);
 
@@ -217,6 +253,10 @@ public:
             //- Remove entries from this list
             inline PackedBoolList& operator-=(const UIndirectList<label>&);
 
+    // IOstream Operators
+
+        friend Istream& operator>>(Istream&, PackedBoolList&);
+        friend Ostream& operator<<(Ostream&, const PackedBoolList&);
 };
 
 
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H
index f9a7f383e4..754590a864 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H
@@ -73,6 +73,14 @@ inline Foam::PackedBoolList::PackedBoolList(const Xfer<PackedList<1> >& lst)
 {}
 
 
+inline Foam::PackedBoolList::PackedBoolList(const UList<bool>& lst)
+:
+    PackedList<1>()
+{
+    operator=(lst);
+}
+
+
 inline Foam::PackedBoolList::PackedBoolList(const UList<label>& indices)
 :
     PackedList<1>(indices.size(), 0u)
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedList.C b/src/OpenFOAM/containers/Lists/PackedList/PackedList.C
index b077c1c54b..cb80e6db02 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedList.C
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedList.C
@@ -24,6 +24,8 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "PackedList.H"
+#include "IOstreams.H"
+
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -40,6 +42,16 @@ Foam::PackedList<nBits>::PackedList(const label size, const unsigned int val)
 }
 
 
+template<unsigned nBits>
+Foam::PackedList<nBits>::PackedList(Istream& is)
+:
+    StorageList(),
+    size_(0)
+{
+    is  >> *this;
+}
+
+
 template<unsigned nBits>
 Foam::PackedList<nBits>::PackedList(const UList<label>& lst)
 :
@@ -290,4 +302,197 @@ Foam::PackedList<nBits>::operator=(const UList<label>& lst)
 }
 
 
+// * * * * * * * * * * * * * *  Friend Operators * * * * * * * * * * * * * * //
+
+template<unsigned nBits>
+Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    PackedList<nBits>& lst
+)
+{
+    lst.clear();
+    is.fatalCheck("operator>>(Istream&, PackedList<nBits>&)");
+
+    token firstTok(is);
+    is.fatalCheck
+    (
+        "operator>>(Istream&, PackedList<nBits>&) : reading first token"
+    );
+
+    if (firstTok.isLabel())
+    {
+        const label sz = firstTok.labelToken();
+
+        // Set list length to that read
+        lst.setSize(sz);
+
+        {
+            // Read beginning of contents
+            const char delimiter = is.readBeginList("List");
+
+            if (sz)
+            {
+                unsigned int val;
+
+                if (delimiter == token::BEGIN_LIST)
+                {
+                    for (register label i=0; i<sz; ++i)
+                    {
+                        is  >> val;
+
+                        if (val > lst.max_value())
+                        {
+                            FatalIOErrorIn
+                            (
+                                "operator>>(Istream&, PackedList<nBits>&)",
+                                is
+                            )
+                                << "out-of-range value: "
+                                << val << " > " << lst.max_value()
+                                << exit(FatalIOError);
+                        }
+
+                        is.fatalCheck
+                        (
+                            "operator>>(Istream&, PackedList<nBits>&) : "
+                            "reading entry"
+                        );
+                    }
+                }
+                else
+                {
+                    is  >> val;
+
+                    is.fatalCheck
+                    (
+                        "operator>>(Istream&, PackedList<nBits>&) : "
+                        "reading the single entry"
+                    );
+
+                    if (val > lst.max_value())
+                    {
+                        FatalIOErrorIn
+                        (
+                            "operator>>(Istream&, PackedList<nBits>&)",
+                            is
+                        )
+                            << "out-of-range value: "
+                            << val << " > " << lst.max_value()
+                            << exit(FatalIOError);
+                    }
+
+                    // assign for all entries
+                    lst = val;
+                }
+            }
+
+            // Read end of contents
+            is.readEndList("PackedList<nBits>");
+        }
+    }
+    else if (firstTok.isPunctuation())
+    {
+        if (firstTok.pToken() != token::BEGIN_LIST)
+        {
+            FatalIOErrorIn
+            (
+                "operator>>(Istream&, PackedList<nBits>&)",
+                is
+            )
+                << "incorrect first token, expected '(', found "
+                << firstTok.info()
+                << exit(FatalIOError);
+        }
+
+        token nextTok(is);
+        is.fatalCheck("operator>>(Istream&, PackedList<nBits>&)");
+
+        unsigned int val;
+
+        while
+        (
+            !(nextTok.isPunctuation() && nextTok.pToken() == token::END_LIST)
+        )
+        {
+            is.putBack(nextTok);
+            is  >> val;
+            lst.append(val);
+
+            if (val > lst.max_value())
+            {
+                FatalIOErrorIn
+                (
+                    "operator>>(Istream&, PackedList<nBits>&)",
+                    is
+                )
+                    << "out-of-range value: "
+                    << val << " > " << lst.max_value()
+                    << exit(FatalIOError);
+            }
+
+            is  >> nextTok;
+            is.fatalCheck("operator>>(Istream&, PackedList<nBits>&)");
+        }
+    }
+    else
+    {
+        FatalIOErrorIn
+        (
+            "operator>>(Istream&, PackedList<nBits>&)",
+            is
+        )
+            << "incorrect first token, expected <int> or '(', found "
+            << firstTok.info()
+            << exit(FatalIOError);
+    }
+
+    return is;
+}
+
+
+template<unsigned nBits>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    PackedList<nBits>& lst
+)
+{
+    if (lst.size() < 11)
+    {
+        // Write size and start delimiter
+        os  << lst.size() << token::BEGIN_LIST;
+
+        // Write contents
+        forAll(lst, i)
+        {
+            if (i)
+            {
+                os  << token::SPACE;
+            }
+            os  << lst[i];
+        }
+
+        // Write end delimiter
+        os  << token::END_LIST;
+    }
+    else
+    {
+        // Write size and start delimiter
+        os  << nl << lst.size() << nl << token::BEGIN_LIST;
+
+        // Write contents
+        forAll(lst, i)
+        {
+            os  << nl << lst[i];
+        }
+
+        // Write end delimiter
+        os  << nl << token::END_LIST << nl;
+    }
+
+    return os;
+}
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedList.H b/src/OpenFOAM/containers/Lists/PackedList/PackedList.H
index 2adb939e4d..897544eb4d 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedList.H
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedList.H
@@ -96,11 +96,17 @@ SourceFiles
 namespace Foam
 {
 
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
 // Forward declaration of friend functions and operators
 template<unsigned nBits> class PackedList;
 
-// template<unsigned nBits>
-// Ostream& operator<<(Ostream&, const PackedList<nBits>&);
+template<unsigned nBits>
+Istream& operator>>(Istream&, PackedList<nBits>&);
+template<unsigned nBits>
+Ostream& operator<<(Ostream&, const PackedList<nBits>&);
 
 
 /*---------------------------------------------------------------------------*\
@@ -180,6 +186,9 @@ public:
         //- Construct with given size and value for all elements
         PackedList(const label size, const unsigned val);
 
+        //- Construct from Istream
+        PackedList(Istream&);
+
         //- Copy constructor
         inline PackedList(const PackedList<nBits>&);
 
@@ -516,6 +525,21 @@ public:
         //- const_iterator set to beyond the end of the PackedList
         inline const_iterator end() const;
 
+
+    // IOstream Operators
+
+        friend Istream& operator>> <nBits>
+        (
+            Istream&,
+            PackedList<nBits>&
+        );
+
+        friend Ostream& operator<< <nBits>
+        (
+            Ostream&,
+            const PackedList<nBits>&
+        );
+
 };
 
 
diff --git a/src/OpenFOAM/db/IOstreams/Sstreams/readHexLabel.C b/src/OpenFOAM/db/IOstreams/Sstreams/readHexLabel.C
index 4cf39c34a7..432ab8ac17 100644
--- a/src/OpenFOAM/db/IOstreams/Sstreams/readHexLabel.C
+++ b/src/OpenFOAM/db/IOstreams/Sstreams/readHexLabel.C
@@ -22,11 +22,12 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Description
-    Read of a non-delimited hex label
+    Read a non-delimited hex label
 
 \*---------------------------------------------------------------------------*/
 
 #include "readHexLabel.H"
+#include <cctype>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -55,7 +56,7 @@ Foam::label Foam::readHexLabel(ISstream& is)
                 << exit(FatalIOError);
         }
 
-        result *= 16;
+        result <<= 4;
 
         if (isdigit(c))
         {