diff --git a/build.xml b/build.xml
index 6bfcb1f..9a6d74b 100644
--- a/build.xml
+++ b/build.xml
@@ -119,11 +119,11 @@
   <property name="mavendist.poi.dir" location="build/maven-dist/poi"/>
   <property name="mavendist.oap.dir" location="build/maven-dist/org.apache.poi"/>
   <property name="jar.name" value="poi"/>
-  <property name="version.id" value="3.2-FINAL"/>
+  <property name="version.id" value="3.2-NIObackport"/>
   <property name="halt.on.test.failure" value="true"/>
-  <property name="jdk.version.source" value="1.3"
+  <property name="jdk.version.source" value="1.5"
     description="JDK version of source code"/>
-  <property name="jdk.version.class" value="1.3"
+  <property name="jdk.version.class" value="1.5"
     description="JDK version of generated class files"/>  
  
 
diff --git a/src/contrib/src/org/apache/poi/contrib/poibrowser/TreeReaderListener.java b/src/contrib/src/org/apache/poi/contrib/poibrowser/TreeReaderListener.java
index a98ec39..1c9e0d2 100644
--- a/src/contrib/src/org/apache/poi/contrib/poibrowser/TreeReaderListener.java
+++ b/src/contrib/src/org/apache/poi/contrib/poibrowser/TreeReaderListener.java
@@ -164,7 +164,7 @@
         {
             is.close();
         }
-        catch (IOException ex)
+        catch (Exception ex)
         {
             System.err.println
                 ("Unexpected exception while closing " +
diff --git a/src/java/org/apache/poi/POIDocument.java b/src/java/org/apache/poi/POIDocument.java
index 4d7e50c..6e1527e 100644
--- a/src/java/org/apache/poi/POIDocument.java
+++ b/src/java/org/apache/poi/POIDocument.java
@@ -20,6 +20,7 @@
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.Iterator;
 import java.util.List;
@@ -47,27 +48,28 @@
  */
 public abstract class POIDocument {
 	/** Holds metadata on our document */
-	protected SummaryInformation sInf;
+	private SummaryInformation sInf;
 	/** Holds further metadata on our document */
-	protected DocumentSummaryInformation dsInf;
-	/** The open POIFS FileSystem that contains our document */
-	protected POIFSFileSystem filesystem;
+	private DocumentSummaryInformation dsInf;
 	/**	The directory that our document lives in */
 	protected DirectoryNode directory;
 	
 	/** For our own logging use */
-	protected POILogger logger = POILogFactory.getLogger(this.getClass());
+	private final static POILogger logger = POILogFactory.getLogger(POIDocument.class);
 
     /* Have the property streams been read yet? (Only done on-demand) */
-    protected boolean initialized = false;
+    private boolean initialized = false;
     
 
-    protected POIDocument(DirectoryNode dir, POIFSFileSystem fs) {
-    	this.filesystem = fs;
+    protected POIDocument(DirectoryNode dir) {
     	this.directory = dir;
     }
+    @Deprecated
+    protected POIDocument(DirectoryNode dir, POIFSFileSystem fs) {
+       this.directory = dir;
+     }
     protected POIDocument(POIFSFileSystem fs) {
-    	this(fs.getRoot(), fs);
+    	this(fs.getRoot());
     }
 
 	/**
@@ -85,6 +87,25 @@
         if(!initialized) readProperties();
         return sInf;
     }
+	
+	/**
+	 * Will create whichever of SummaryInformation
+	 *  and DocumentSummaryInformation (HPSF) properties
+	 *  are not already part of your document.
+	 * This is normally useful when creating a new
+	 *  document from scratch.
+	 * If the information properties are already there,
+	 *  then nothing will happen.
+	 */
+	public void createInformationProperties() {
+        if(!initialized) readProperties();
+		if(sInf == null) {
+			sInf = PropertySetFactory.newSummaryInformation();
+		}
+		if(dsInf == null) {
+			dsInf = PropertySetFactory.newDocumentSummaryInformation();
+		}
+	}
 
 	/**
 	 * Find, and create objects for, the standard
@@ -120,28 +141,31 @@
 	 *  if it wasn't found
 	 */
 	protected PropertySet getPropertySet(String setName) {
-		DocumentInputStream dis;
-		try {
-			// Find the entry, and get an input stream for it
-			dis = directory.createDocumentInputStream(setName);
-		} catch(IOException ie) {
-			// Oh well, doesn't exist
-			logger.log(POILogger.WARN, "Error getting property set with name " + setName + "\n" + ie);
-			return null;
-		}
+	   //directory can be null when creating new documents
+	   if(directory == null) return null;
 
-		try {
-			// Create the Property Set
-			PropertySet set = PropertySetFactory.create(dis);
-			return set;
-		} catch(IOException ie) {
-			// Must be corrupt or something like that
-			logger.log(POILogger.WARN, "Error creating property set with name " + setName + "\n" + ie);
-		} catch(org.apache.poi.hpsf.HPSFException he) {
-			// Oh well, doesn't exist
-			logger.log(POILogger.WARN, "Error creating property set with name " + setName + "\n" + he);
-		}
-		return null;
+	   DocumentInputStream dis;
+	   try {
+	      // Find the entry, and get an input stream for it
+	      dis = directory.createDocumentInputStream( directory.getEntry(setName) );
+	   } catch(IOException ie) {
+	      // Oh well, doesn't exist
+	      logger.log(POILogger.WARN, "Error getting property set with name " + setName + "\n" + ie);
+	      return null;
+	   }
+
+	   try {
+	      // Create the Property Set
+	      PropertySet set = PropertySetFactory.create(dis);
+	      return set;
+	   } catch(IOException ie) {
+	      // Must be corrupt or something like that
+	      logger.log(POILogger.WARN, "Error creating property set with name " + setName + "\n" + ie);
+	   } catch(org.apache.poi.hpsf.HPSFException he) {
+	      // Oh well, doesn't exist
+	      logger.log(POILogger.WARN, "Error creating property set with name " + setName + "\n" + he);
+	   }
+	   return null;
 	}
 	
 	/**
@@ -157,14 +181,16 @@
 	 * @param writtenEntries a list of POIFS entries to add the property names too
 	 */
 	protected void writeProperties(POIFSFileSystem outFS, List writtenEntries) throws IOException {
-        if(sInf != null) {
-			writePropertySet(SummaryInformation.DEFAULT_STREAM_NAME,sInf,outFS);
+        SummaryInformation si = getSummaryInformation();
+        if(si != null) {
+			writePropertySet(SummaryInformation.DEFAULT_STREAM_NAME, si, outFS);
 			if(writtenEntries != null) {
 				writtenEntries.add(SummaryInformation.DEFAULT_STREAM_NAME);
 			}
 		}
-		if(dsInf != null) {
-			writePropertySet(DocumentSummaryInformation.DEFAULT_STREAM_NAME,dsInf,outFS);
+        DocumentSummaryInformation dsi = getDocumentSummaryInformation();
+        if(dsi != null) {
+			writePropertySet(DocumentSummaryInformation.DEFAULT_STREAM_NAME, dsi, outFS);
 			if(writtenEntries != null) {
 				writtenEntries.add(DocumentSummaryInformation.DEFAULT_STREAM_NAME);
 			}
diff --git a/src/java/org/apache/poi/hpsf/ClassID.java b/src/java/org/apache/poi/hpsf/ClassID.java
index 7044aca..dd623b8 100644
--- a/src/java/org/apache/poi/hpsf/ClassID.java
+++ b/src/java/org/apache/poi/hpsf/ClassID.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import org.apache.poi.util.HexDump;
@@ -27,8 +27,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2002-02-09
  */
 public class ClassID
 {
diff --git a/src/java/org/apache/poi/hpsf/Constants.java b/src/java/org/apache/poi/hpsf/Constants.java
index a2a2f7b..05bc2fd 100644
--- a/src/java/org/apache/poi/hpsf/Constants.java
+++ b/src/java/org/apache/poi/hpsf/Constants.java
@@ -22,8 +22,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @since 2004-06-20
- * @version $Id$
  */
 public class Constants
 {
diff --git a/src/java/org/apache/poi/hpsf/CustomProperties.java b/src/java/org/apache/poi/hpsf/CustomProperties.java
index 420fc2f..83858eb 100644
--- a/src/java/org/apache/poi/hpsf/CustomProperties.java
+++ b/src/java/org/apache/poi/hpsf/CustomProperties.java
@@ -33,7 +33,7 @@
  * name is the key that maps to a typed value. This implementation hides
  * property IDs from the developer and regards the property names as keys to
  * typed values.</p>
- * 
+ *
  * <p>While this class provides a simple API to custom properties, it ignores
  * the fact that not names, but IDs are the real keys to properties. Under the
  * hood this class maintains a 1:1 relationship between IDs and names. Therefore
@@ -41,71 +41,68 @@
  * mapping to the same name or with properties without a name: the result will
  * contain only a subset of the original properties. If you really need to deal
  * such property sets, use HPSF's low-level access methods.</p>
- * 
+ *
  * <p>An application can call the {@link #isPure} method to check whether a
  * property set parsed by {@link CustomProperties} is still pure (i.e.
  * unmodified) or whether one or more properties have been dropped.</p>
- * 
+ *
  * <p>This class is not thread-safe; concurrent access to instances of this
- * class must be syncronized.</p>
- * 
+ * class must be synchronized.</p>
+ *
+ * <p>While this class is roughly HashMap<Long,CustomProperty>, that's the
+ *  internal representation. To external calls, it should appear as
+ *  HashMap<String,Object> mapping between Names and Custom Property Values.</p>
+ *
  * @author Rainer Klute <a
  *         href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @since 2006-02-09
- * @version $Id$
  */
-public class CustomProperties extends HashMap
+@SuppressWarnings("serial")
+public class CustomProperties extends HashMap<Object,CustomProperty>
 {
 
     /**
      * <p>Maps property IDs to property names.</p>
      */
-    private Map dictionaryIDToName = new HashMap();
+    private Map<Long,String> dictionaryIDToName = new HashMap<Long,String>();
 
     /**
      * <p>Maps property names to property IDs.</p>
      */
-    private Map dictionaryNameToID = new HashMap();
-    
+    private Map<String,Long> dictionaryNameToID = new HashMap<String,Long>();
+
     /**
      * <p>Tells whether this object is pure or not.</p>
      */
     private boolean isPure = true;
 
 
-
     /**
      * <p>Puts a {@link CustomProperty} into this map. It is assumed that the
      * {@link CustomProperty} already has a valid ID. Otherwise use
      * {@link #put(CustomProperty)}.</p>
      */
-    public Object put(final Object name, final Object customProperty) throws ClassCastException
+    public CustomProperty put(final String name, final CustomProperty cp)
     {
-        final CustomProperty cp = (CustomProperty) customProperty;
         if (name == null)
         {
             /* Ignoring a property without a name. */
             isPure = false;
             return null;
         }
-        if (!(name instanceof String))
-            throw new ClassCastException("The name of a custom property must " +
-                    "be a java.lang.String, but it is a " +
-                    name.getClass().getName());
         if (!(name.equals(cp.getName())))
             throw new IllegalArgumentException("Parameter \"name\" (" + name +
                     ") and custom property's name (" + cp.getName() +
                     ") do not match.");
 
         /* Register name and ID in the dictionary. Mapping in both directions is possible. If there is already a  */
-        final Long idKey = new Long(cp.getID());
-        final Object oldID = dictionaryNameToID.get(name);
+        final Long idKey = Long.valueOf(cp.getID());
+        final Long oldID = dictionaryNameToID.get(name);
         dictionaryIDToName.remove(oldID);
         dictionaryNameToID.put(name, idKey);
         dictionaryIDToName.put(idKey, name);
 
         /* Put the custom property into this map. */
-        final Object oldCp = super.remove(oldID);
+        final CustomProperty oldCp = super.remove(oldID);
         super.put(idKey, cp);
         return oldCp;
     }
@@ -115,16 +112,16 @@
     /**
      * <p>Puts a {@link CustomProperty} that has not yet a valid ID into this
      * map. The method will allocate a suitable ID for the custom property:</p>
-     * 
+     *
      * <ul>
-     * 
+     *
      * <li><p>If there is already a property with the same name, take the ID
      * of that property.</p></li>
-     * 
+     *
      * <li><p>Otherwise find the highest ID and use its value plus one.</p></li>
-     * 
+     *
      * </ul>
-     * 
+     *
      * @param customProperty
      * @return If the was already a property with the same name, the
      * @throws ClassCastException
@@ -140,9 +137,9 @@
         else
         {
             long max = 1;
-            for (final Iterator i = dictionaryIDToName.keySet().iterator(); i.hasNext();)
+            for (final Iterator<Long> i = dictionaryIDToName.keySet().iterator(); i.hasNext();)
             {
-                final long id = ((Long) i.next()).longValue();
+                final long id = i.next().longValue();
                 if (id > max)
                     max = id;
             }
@@ -155,7 +152,7 @@
 
     /**
      * <p>Removes a custom property.</p>
-     * @param name The name of the custom property to remove 
+     * @param name The name of the custom property to remove
      * @return The removed property or <code>null</code> if the specified property was not found.
      *
      * @see java.util.HashSet#remove(java.lang.Object)
@@ -172,7 +169,7 @@
 
     /**
      * <p>Adds a named string property.</p>
-     * 
+     *
      * @param name The property's name.
      * @param value The property's value.
      * @return the property that was stored under the specified name before, or
@@ -260,10 +257,10 @@
         return put(cp);
     }
 
-    
+
     /**
      * <p>Gets a named value from the custom properties.</p>
-     * 
+     *
      * @param name the name of the value to get
      * @return the value or <code>null</code> if a value with the specified
      *         name is not found in the custom properties.
@@ -294,18 +291,34 @@
         final CustomProperty cp = new CustomProperty(p, name);
         return put(cp);
     }
-    
+
+    /**
+     * Returns a set of all the names of our
+     *  custom properties. Equivalent to 
+     *  {@link #nameSet()}
+     */
+    public Set keySet() {
+        return dictionaryNameToID.keySet();
+    }
+
     /**
      * Returns a set of all the names of our
      *  custom properties
      */
-    public Set keySet() {
-    	return dictionaryNameToID.keySet();
-	}
+    public Set<String> nameSet() {
+        return dictionaryNameToID.keySet();
+    }
+
+    /**
+     * Returns a set of all the IDs of our
+     *  custom properties
+     */
+    public Set<String> idSet() {
+        return dictionaryNameToID.keySet();
+    }
 
 
-
-	/**
+    /**
      * <p>Sets the codepage.</p>
      *
      * @param codepage the codepage
@@ -315,7 +328,7 @@
         final MutableProperty p = new MutableProperty();
         p.setID(PropertyIDMap.PID_CODEPAGE);
         p.setType(Variant.VT_I2);
-        p.setValue(new Integer(codepage));
+        p.setValue(Integer.valueOf(codepage));
         put(new CustomProperty(p));
     }
 
@@ -324,17 +337,47 @@
     /**
      * <p>Gets the dictionary which contains IDs and names of the named custom
      * properties.
-     * 
+     *
      * @return the dictionary.
      */
-    Map getDictionary()
+    Map<Long,String> getDictionary()
     {
         return dictionaryIDToName;
     }
 
 
-
     /**
+     * Checks against both String Name and Long ID
+     */
+   public boolean containsKey(Object key) {
+      if(key instanceof Long) {
+         return super.containsKey((Long)key);
+      }
+      if(key instanceof String) {
+         return super.containsKey((Long)dictionaryNameToID.get(key));
+      }
+      return false;
+   }
+
+   /**
+    * Checks against both the property, and its values. 
+    */
+   public boolean containsValue(Object value) {
+      if(value instanceof CustomProperty) {
+         return super.containsValue((CustomProperty)value);
+      } else {
+         for(CustomProperty cp : super.values()) {
+            if(cp.getValue() == value) {
+               return true;
+            }
+         }
+      }
+      return false;
+   }
+
+
+
+   /**
      * <p>Gets the codepage.</p>
      *
      * @return the codepage or -1 if the codepage is undefined.
@@ -342,9 +385,9 @@
     public int getCodepage()
     {
         int codepage = -1;
-        for (final Iterator i = this.values().iterator(); codepage == -1 && i.hasNext();)
+        for (final Iterator<CustomProperty> i = this.values().iterator(); codepage == -1 && i.hasNext();)
         {
-            final CustomProperty cp = (CustomProperty) i.next();
+            final CustomProperty cp = i.next();
             if (cp.getID() == PropertyIDMap.PID_CODEPAGE)
                 codepage = ((Integer) cp.getValue()).intValue();
         }
@@ -357,7 +400,7 @@
      * <p>Tells whether this {@link CustomProperties} instance is pure or one or
      * more properties of the underlying low-level property set has been
      * dropped.</p>
-     * 
+     *
      * @return <code>true</code> if the {@link CustomProperties} is pure, else
      *         <code>false</code>.
      */
@@ -375,5 +418,4 @@
     {
         this.isPure = isPure;
     }
-
 }
diff --git a/src/java/org/apache/poi/hpsf/CustomProperty.java b/src/java/org/apache/poi/hpsf/CustomProperty.java
index 4bd1f8e..994adf7 100644
--- a/src/java/org/apache/poi/hpsf/CustomProperty.java
+++ b/src/java/org/apache/poi/hpsf/CustomProperty.java
@@ -18,15 +18,13 @@
 package org.apache.poi.hpsf;
 
 /**
- * <p>This class represents custum properties in the document summary
+ * <p>This class represents custom properties in the document summary
  * information stream. The difference to normal properties is that custom
  * properties have an optional name. If the name is not <code>null</code> it
  * will be maintained in the section's dictionary.</p>
  * 
  * @author Rainer Klute <a
  *         href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @since 2006-02-09
- * @version $Id$
  */
 public class CustomProperty extends MutableProperty
 {
diff --git a/src/java/org/apache/poi/hpsf/DocumentSummaryInformation.java b/src/java/org/apache/poi/hpsf/DocumentSummaryInformation.java
index 62c6127..0e98396 100644
--- a/src/java/org/apache/poi/hpsf/DocumentSummaryInformation.java
+++ b/src/java/org/apache/poi/hpsf/DocumentSummaryInformation.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.util.Iterator;
@@ -32,8 +32,6 @@
  * @author Drew Varner (Drew.Varner closeTo sc.edu)
  * @author robert_flaherty@hyperion.com
  * @see SummaryInformation
- * @version $Id$
- * @since 2002-02-09
  */
 public class DocumentSummaryInformation extends SpecialPropertySet
 {
@@ -569,9 +567,8 @@
 
     /**
      * <p>Gets the custom properties.</p>
-     * 
+     *
      * @return The custom properties.
-     * @since 2006-02-09
      */
     public CustomProperties getCustomProperties()
     {
@@ -580,7 +577,7 @@
         {
             cps = new CustomProperties();
             final Section section = (Section) getSections().get(1);
-            final Map dictionary = section.getDictionary();
+            final Map<Long,String> dictionary = section.getDictionary();
             final Property[] properties = section.getProperties();
             int propertyCount = 0;
             for (int i = 0; i < properties.length; i++)
@@ -591,7 +588,7 @@
                 {
                     propertyCount++;
                     final CustomProperty cp = new CustomProperty(p,
-                            (String) dictionary.get(new Long(id)));
+                            dictionary.get(Long.valueOf(id)));
                     cps.put(cp.getName(), cp);
                 }
             }
@@ -603,15 +600,14 @@
 
     /**
      * <p>Sets the custom properties.</p>
-     * 
+     *
      * @param customProperties The custom properties
-     * @since 2006-02-07
      */
     public void setCustomProperties(final CustomProperties customProperties)
     {
         ensureSection2();
         final MutableSection section = (MutableSection) getSections().get(1);
-        final Map dictionary = customProperties.getDictionary();
+        final Map<Long,String> dictionary = customProperties.getDictionary();
         section.clear();
 
         /* Set the codepage. If both custom properties and section have a
@@ -625,9 +621,9 @@
         customProperties.setCodepage(cpCodepage);
         section.setCodepage(cpCodepage);
         section.setDictionary(dictionary);
-        for (final Iterator i = customProperties.values().iterator(); i.hasNext();)
+        for (final Iterator<CustomProperty> i = customProperties.values().iterator(); i.hasNext();)
         {
-            final Property p = (Property) i.next();
+            final Property p = i.next();
             section.setProperty(p);
         }
     }
@@ -652,8 +648,6 @@
 
     /**
      * <p>Removes the custom properties.</p>
-     * 
-     * @since 2006-02-08
      */
     public void removeCustomProperties()
     {
@@ -676,5 +670,4 @@
     {
         throw new UnsupportedOperationException(msg + " is not yet implemented.");
     }
-
 }
diff --git a/src/java/org/apache/poi/hpsf/HPSFException.java b/src/java/org/apache/poi/hpsf/HPSFException.java
index e8a8a57..f0f12db 100644
--- a/src/java/org/apache/poi/hpsf/HPSFException.java
+++ b/src/java/org/apache/poi/hpsf/HPSFException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -24,8 +24,6 @@
  * 
  * @author Rainer Klute <a
  *         href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2002-02-09
  */
 public class HPSFException extends Exception
 {
diff --git a/src/java/org/apache/poi/hpsf/HPSFRuntimeException.java b/src/java/org/apache/poi/hpsf/HPSFRuntimeException.java
index 3f2419f..79825eb 100644
--- a/src/java/org/apache/poi/hpsf/HPSFRuntimeException.java
+++ b/src/java/org/apache/poi/hpsf/HPSFRuntimeException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.PrintStream;
@@ -27,8 +27,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2002-02-09
  */
 public class HPSFRuntimeException extends RuntimeException
 {
diff --git a/src/java/org/apache/poi/hpsf/IllegalPropertySetDataException.java b/src/java/org/apache/poi/hpsf/IllegalPropertySetDataException.java
index 2f6dde3..3217af9 100644
--- a/src/java/org/apache/poi/hpsf/IllegalPropertySetDataException.java
+++ b/src/java/org/apache/poi/hpsf/IllegalPropertySetDataException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -26,8 +26,6 @@
  * thrown.</p>
  *
  * @author Drew Varner(Drew.Varner atDomain sc.edu)
- * @version $Id$
- * @since 2002-05-26
  */
 public class IllegalPropertySetDataException extends HPSFRuntimeException
 {
diff --git a/src/java/org/apache/poi/hpsf/IllegalVariantTypeException.java b/src/java/org/apache/poi/hpsf/IllegalVariantTypeException.java
index 0292510..f72bb44 100644
--- a/src/java/org/apache/poi/hpsf/IllegalVariantTypeException.java
+++ b/src/java/org/apache/poi/hpsf/IllegalVariantTypeException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import org.apache.poi.util.HexDump;
@@ -25,8 +25,6 @@
  * 
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @since 2004-06-21
- * @version $Id$
  */
 public class IllegalVariantTypeException extends VariantTypeException
 {
diff --git a/src/java/org/apache/poi/hpsf/MarkUnsupportedException.java b/src/java/org/apache/poi/hpsf/MarkUnsupportedException.java
index 1ff38f7..c1c5dc8 100644
--- a/src/java/org/apache/poi/hpsf/MarkUnsupportedException.java
+++ b/src/java/org/apache/poi/hpsf/MarkUnsupportedException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -23,8 +23,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2002-02-09
  */
 public class MarkUnsupportedException extends HPSFException
 {
diff --git a/src/java/org/apache/poi/hpsf/MissingSectionException.java b/src/java/org/apache/poi/hpsf/MissingSectionException.java
index ccef805..35df686 100644
--- a/src/java/org/apache/poi/hpsf/MissingSectionException.java
+++ b/src/java/org/apache/poi/hpsf/MissingSectionException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -26,8 +26,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id: NoSingleSectionException.java 353545 2004-04-09 13:05:39Z glens $
- * @since 2006-02-08
  */
 public class MissingSectionException extends HPSFRuntimeException
 {
diff --git a/src/java/org/apache/poi/hpsf/MutableProperty.java b/src/java/org/apache/poi/hpsf/MutableProperty.java
index 6128f61..401ac23 100644
--- a/src/java/org/apache/poi/hpsf/MutableProperty.java
+++ b/src/java/org/apache/poi/hpsf/MutableProperty.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.IOException;
@@ -28,8 +28,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @since 2003-08-03
- * @version $Id$
  */
 public class MutableProperty extends Property
 {
diff --git a/src/java/org/apache/poi/hpsf/MutablePropertySet.java b/src/java/org/apache/poi/hpsf/MutablePropertySet.java
index 5ecbfee..3fb13af 100644
--- a/src/java/org/apache/poi/hpsf/MutablePropertySet.java
+++ b/src/java/org/apache/poi/hpsf/MutablePropertySet.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.ByteArrayInputStream;
@@ -33,8 +33,6 @@
 import org.apache.poi.util.LittleEndian;
 import org.apache.poi.util.LittleEndianConsts;
 
-
-
 /**
  * <p>Adds writing support to the {@link PropertySet} class.</p>
  *
@@ -43,8 +41,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2003-02-19
  */
 public class MutablePropertySet extends PropertySet
 {
@@ -79,10 +75,10 @@
 
     /**
      * <p>Constructs a <code>MutablePropertySet</code> by doing a deep copy of
-     * an existing <code>PropertySet</code>. All nested elements, i.e. 
+     * an existing <code>PropertySet</code>. All nested elements, i.e.
      * <code>Section</code>s and <code>Property</code> instances, will be their
      * mutable counterparts in the new <code>MutablePropertySet</code>.</p>
-     * 
+     *
      * @param ps The property set to copy
      */
     public MutablePropertySet(final PropertySet ps)
@@ -194,7 +190,7 @@
 
     /**
      * <p>Writes the property set to an output stream.</p>
-     * 
+     *
      * @param out the output stream to write the section to
      * @exception IOException if an error when writing to the output stream
      * occurs
@@ -236,10 +232,10 @@
             catch (HPSFRuntimeException ex)
             {
                 final Throwable cause = ex.getReason();
-                if (cause instanceof UnsupportedEncodingException)
+                if (cause instanceof UnsupportedEncodingException) {
                     throw new IllegalPropertySetDataException(cause);
-                else
-                    throw ex;
+                }
+                throw ex;
             }
         }
 
@@ -263,7 +259,7 @@
      * the {@link MutablePropertySet} only.</p>
      *
      * @return the contents of this property set stream
-     * 
+     *
      * @throws WritingNotSupportedException if HPSF does not yet support writing
      * of a property's variant type.
      * @throws IOException if an I/O exception occurs.
@@ -284,7 +280,7 @@
      * @param dir The directory in the POI filesystem to write the document to.
      * @param name The document's name. If there is already a document with the
      * same name in the directory the latter will be overwritten.
-     * 
+     *
      * @throws WritingNotSupportedException
      * @throws IOException
      */
diff --git a/src/java/org/apache/poi/hpsf/MutableSection.java b/src/java/org/apache/poi/hpsf/MutableSection.java
index 1ba4221..3f7c01b 100644
--- a/src/java/org/apache/poi/hpsf/MutableSection.java
+++ b/src/java/org/apache/poi/hpsf/MutableSection.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.ByteArrayOutputStream;
@@ -37,9 +37,6 @@
  *
  * <p>Please be aware that this class' functionality will be merged into the
  * {@link Section} class at a later time, so the API will change.</p>
- *
- * @version $Id$
- * @since 2002-02-20
  */
 public class MutableSection extends Section
 {
@@ -56,7 +53,7 @@
      * decision has been taken when specifying the "properties" field
      * as an Property[]. It should have been a {@link java.util.List}.</p>
      */
-    private List preprops;
+    private List<Property> preprops;
 
 
 
@@ -77,17 +74,17 @@
         dirty = true;
         formatID = null;
         offset = -1;
-        preprops = new LinkedList();
+        preprops = new LinkedList<Property>();
     }
 
 
 
     /**
-     * <p>Constructs a <code>MutableSection</code> by doing a deep copy of an 
-     * existing <code>Section</code>. All nested <code>Property</code> 
+     * <p>Constructs a <code>MutableSection</code> by doing a deep copy of an
+     * existing <code>Section</code>. All nested <code>Property</code>
      * instances, will be their mutable counterparts in the new
      * <code>MutableSection</code>.</p>
-     * 
+     *
      * @param s The section set to copy
      */
     public MutableSection(final Section s)
@@ -148,7 +145,7 @@
     public void setProperties(final Property[] properties)
     {
         this.properties = properties;
-        preprops = new LinkedList();
+        preprops = new LinkedList<Property>();
         for (int i = 0; i < properties.length; i++)
             preprops.add(properties[i]);
         dirty = true;
@@ -185,7 +182,7 @@
      */
     public void setProperty(final int id, final int value)
     {
-        setProperty(id, Variant.VT_I4, new Integer(value));
+        setProperty(id, Variant.VT_I4, Integer.valueOf(value));
         dirty = true;
     }
 
@@ -202,7 +199,7 @@
      */
     public void setProperty(final int id, final long value)
     {
-        setProperty(id, Variant.VT_I8, new Long(value));
+        setProperty(id, Variant.VT_I8, Long.valueOf(value));
         dirty = true;
     }
 
@@ -219,7 +216,7 @@
      */
     public void setProperty(final int id, final boolean value)
     {
-        setProperty(id, Variant.VT_BOOL, new Boolean(value));
+        setProperty(id, Variant.VT_BOOL, Boolean.valueOf(value));
         dirty = true;
     }
 
@@ -279,8 +276,8 @@
      */
     public void removeProperty(final long id)
     {
-        for (final Iterator i = preprops.iterator(); i.hasNext();)
-            if (((Property) i.next()).getID() == id)
+        for (final Iterator<Property> i = preprops.iterator(); i.hasNext();)
+            if (i.next().getID() == id)
             {
                 i.remove();
                 break;
@@ -303,7 +300,7 @@
      */
     protected void setPropertyBooleanValue(final int id, final boolean value)
     {
-        setProperty(id, Variant.VT_BOOL, new Boolean(value));
+        setProperty(id, Variant.VT_BOOL, Boolean.valueOf(value));
     }
 
 
@@ -342,10 +339,10 @@
      * properties) and the properties themselves.</p>
      *
      * @return the section's length in bytes.
-     * @throws WritingNotSupportedException 
-     * @throws IOException 
+     * @throws WritingNotSupportedException
+     * @throws IOException
      */
-    private int calcSize() throws WritingNotSupportedException, IOException 
+    private int calcSize() throws WritingNotSupportedException, IOException
     {
         final ByteArrayOutputStream out = new ByteArrayOutputStream();
         write(out);
@@ -360,7 +357,7 @@
 
     /**
      * <p>Writes this section into an output stream.</p>
-     * 
+     *
      * <p>Internally this is done by writing into three byte array output
      * streams: one for the properties, one for the property list and one for
      * the section as such. The two former are appended to the latter when they
@@ -393,7 +390,7 @@
          * "propertyListStream". */
         final ByteArrayOutputStream propertyListStream =
             new ByteArrayOutputStream();
- 
+
         /* Maintain the current position in the list. */
         int position = 0;
 
@@ -421,17 +418,15 @@
                  * dictionary is present. In order to cope with this problem we
                  * add the codepage property and set it to Unicode. */
                 setProperty(PropertyIDMap.PID_CODEPAGE, Variant.VT_I2,
-                            new Integer(Constants.CP_UNICODE));
+                            Integer.valueOf(Constants.CP_UNICODE));
             codepage = getCodepage();
         }
 
         /* Sort the property list by their property IDs: */
-        Collections.sort(preprops, new Comparator()
+        Collections.sort(preprops, new Comparator<Property>()
             {
-                public int compare(final Object o1, final Object o2)
+                public int compare(final Property p1, final Property p2)
                 {
-                    final Property p1 = (Property) o1;
-                    final Property p2 = (Property) o2;
                     if (p1.getID() < p2.getID())
                         return -1;
                     else if (p1.getID() == p2.getID())
@@ -443,11 +438,11 @@
 
         /* Write the properties and the property list into their respective
          * streams: */
-        for (final ListIterator i = preprops.listIterator(); i.hasNext();)
+        for (final ListIterator<Property> i = preprops.listIterator(); i.hasNext();)
         {
             final MutableProperty p = (MutableProperty) i.next();
             final long id = p.getID();
-            
+
             /* Write the property list entry. */
             TypeWriter.writeUIntToStream(propertyListStream, p.getID());
             TypeWriter.writeUIntToStream(propertyListStream, position);
@@ -475,17 +470,17 @@
         /* Write the section: */
         byte[] pb1 = propertyListStream.toByteArray();
         byte[] pb2 = propertyStream.toByteArray();
-        
+
         /* Write the section's length: */
         TypeWriter.writeToStream(out, LittleEndian.INT_SIZE * 2 +
                                       pb1.length + pb2.length);
-        
+
         /* Write the section's number of properties: */
         TypeWriter.writeToStream(out, getPropertyCount());
-        
+
         /* Write the property list: */
         out.write(pb1);
-        
+
         /* Write the properties: */
         out.write(pb2);
 
@@ -505,14 +500,14 @@
      * @exception IOException if an I/O exception occurs.
      */
     private static int writeDictionary(final OutputStream out,
-                                       final Map dictionary, final int codepage)
+                                       final Map<Long,String> dictionary, final int codepage)
         throws IOException
     {
         int length = TypeWriter.writeUIntToStream(out, dictionary.size());
-        for (final Iterator i = dictionary.keySet().iterator(); i.hasNext();)
+        for (final Iterator<Long> i = dictionary.keySet().iterator(); i.hasNext();)
         {
-            final Long key = (Long) i.next();
-            final String value = (String) dictionary.get(key);
+            final Long key = i.next();
+            final String value = dictionary.get(key);
 
             if (codepage == Constants.CP_UNICODE)
             {
@@ -565,7 +560,7 @@
      * <p>Overwrites the super class' method to cope with a redundancy:
      * the property count is maintained in a separate member variable, but
      * shouldn't.</p>
-     * 
+     *
      * @return The number of properties in this section
      */
     public int getPropertyCount()
@@ -577,7 +572,7 @@
 
     /**
      * <p>Gets this section's properties.</p>
-     * 
+     *
      * @return this section's properties.
      */
     public Property[] getProperties()
@@ -590,7 +585,7 @@
 
     /**
      * <p>Gets a property.</p>
-     * 
+     *
      * @param id The ID of the property to get
      * @return The property or <code>null</code> if there is no such property
      */
@@ -614,27 +609,17 @@
      * method.</p>
      *
      * @param dictionary The dictionary
-     * 
+     *
      * @exception IllegalPropertySetDataException if the dictionary's key and
      * value types are not correct.
-     * 
+     *
      * @see Section#getDictionary()
      */
-    public void setDictionary(final Map dictionary)
+    public void setDictionary(final Map<Long,String> dictionary)
         throws IllegalPropertySetDataException
     {
         if (dictionary != null)
         {
-            for (final Iterator i = dictionary.keySet().iterator();
-                 i.hasNext();)
-                if (!(i.next() instanceof Long))
-                    throw new IllegalPropertySetDataException
-                        ("Dictionary keys must be of type Long.");
-            for (final Iterator i = dictionary.values().iterator();
-                 i.hasNext();)
-                if (!(i.next() instanceof String))
-                    throw new IllegalPropertySetDataException
-                        ("Dictionary values must be of type String.");
             this.dictionary = dictionary;
 
             /* Set the dictionary property (ID 0). Please note that the second
@@ -649,7 +634,7 @@
                 (Integer) getProperty(PropertyIDMap.PID_CODEPAGE);
             if (codepage == null)
                 setProperty(PropertyIDMap.PID_CODEPAGE, Variant.VT_I2,
-                            new Integer(Constants.CP_UNICODE));
+                            Integer.valueOf(Constants.CP_UNICODE));
         }
         else
             /* Setting the dictionary to null means to remove property 0.
@@ -661,7 +646,7 @@
 
     /**
      * <p>Sets a property.</p>
-     * 
+     *
      * @param id The property ID.
      * @param value The property's value. The value's class must be one of those
      *        supported by HPSF.
@@ -710,7 +695,6 @@
     public void setCodepage(final int codepage)
     {
         setProperty(PropertyIDMap.PID_CODEPAGE, Variant.VT_I2,
-                new Integer(codepage));
+                Integer.valueOf(codepage));
     }
-
 }
diff --git a/src/java/org/apache/poi/hpsf/NoFormatIDException.java b/src/java/org/apache/poi/hpsf/NoFormatIDException.java
index 2e9f8f8..507aab3 100644
--- a/src/java/org/apache/poi/hpsf/NoFormatIDException.java
+++ b/src/java/org/apache/poi/hpsf/NoFormatIDException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -25,8 +25,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2002-09-03
  */
 public class NoFormatIDException extends HPSFRuntimeException
 {
diff --git a/src/java/org/apache/poi/hpsf/NoPropertySetStreamException.java b/src/java/org/apache/poi/hpsf/NoPropertySetStreamException.java
index 4bf1f93..cd580fa 100644
--- a/src/java/org/apache/poi/hpsf/NoPropertySetStreamException.java
+++ b/src/java/org/apache/poi/hpsf/NoPropertySetStreamException.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -27,8 +26,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2002-02-09
  */
 public class NoPropertySetStreamException extends HPSFException
 {
diff --git a/src/java/org/apache/poi/hpsf/NoSingleSectionException.java b/src/java/org/apache/poi/hpsf/NoSingleSectionException.java
index e2feb74..46aa332 100644
--- a/src/java/org/apache/poi/hpsf/NoSingleSectionException.java
+++ b/src/java/org/apache/poi/hpsf/NoSingleSectionException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -28,8 +28,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2002-02-09
  */
 public class NoSingleSectionException extends HPSFRuntimeException
 {
diff --git a/src/java/org/apache/poi/hpsf/Property.java b/src/java/org/apache/poi/hpsf/Property.java
index 16b4f7e..c06a807 100644
--- a/src/java/org/apache/poi/hpsf/Property.java
+++ b/src/java/org/apache/poi/hpsf/Property.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.UnsupportedEncodingException;
@@ -46,7 +46,7 @@
  * over time but largely depends on your feedback so that the POI team knows
  * which variant types are really needed. So please feel free to submit error
  * reports or patches for the types you need.</p>
- * 
+ *
  * <p>Microsoft documentation: <a
  * href="http://msdn.microsoft.com/library/en-us/stg/stg/property_set_display_name_dictionary.asp?frame=true">
  * Property Set Display Name Dictionary</a>.
@@ -56,8 +56,6 @@
  * @author Drew Varner (Drew.Varner InAndAround sc.edu)
  * @see Section
  * @see Variant
- * @version $Id$
- * @since 2002-02-09
  */
 public class Property
 {
@@ -112,7 +110,7 @@
 
     /**
      * <p>Creates a property.</p>
-     * 
+     *
      * @param id the property's ID.
      * @param type the property's type, see {@link Variant}.
      * @param value the property's value. Only certain types are allowed, see
@@ -185,7 +183,7 @@
 
     /**
      * <p>Reads a dictionary.</p>
-     * 
+     *
      * @param src The byte array containing the bytes making out the dictionary.
      * @param offset At this offset within <var>src </var> the dictionary
      *        starts.
@@ -219,7 +217,7 @@
             for (int i = 0; i < nrEntries; i++)
             {
                 /* The key. */
-                final Long id = new Long(LittleEndian.getUInt(src, o));
+                final Long id = Long.valueOf(LittleEndian.getUInt(src, o));
                 o += LittleEndian.INT_SIZE;
 
                 /* The value (a string). The length is the either the
@@ -298,7 +296,7 @@
      * 4.</p>
      *
      * @return the property's size in bytes
-     * 
+     *
      * @exception WritingNotSupportedException if HPSF does not yet support the
      * property's variant type.
      */
@@ -339,13 +337,14 @@
      * ID == 0 is a special case: It does not have a type, and its value is the
      * section's dictionary. Another special case are strings: Two properties
      * may have the different types Variant.VT_LPSTR and Variant.VT_LPWSTR;</p>
-     * 
+     *
      * @see Object#equals(java.lang.Object)
      */
     public boolean equals(final Object o)
     {
-        if (!(o instanceof Property))
+        if (!(o instanceof Property)) {
             return false;
+        }
         final Property p = (Property) o;
         final Object pValue = p.getValue();
         final long pId = p.getID();
@@ -357,8 +356,8 @@
             return false;
 
         /* It's clear now that both values are non-null. */
-        final Class valueClass = value.getClass();
-        final Class pValueClass = pValue.getClass();
+        final Class<?> valueClass = value.getClass();
+        final Class<?> pValueClass = pValue.getClass();
         if (!(valueClass.isAssignableFrom(pValueClass)) &&
             !(pValueClass.isAssignableFrom(valueClass)))
             return false;
@@ -375,10 +374,10 @@
     {
         if (t1 == t2 ||
             (t1 == Variant.VT_LPSTR && t2 == Variant.VT_LPWSTR) ||
-            (t2 == Variant.VT_LPSTR && t1 == Variant.VT_LPWSTR))
+            (t2 == Variant.VT_LPSTR && t1 == Variant.VT_LPWSTR)) {
             return true;
-        else
-            return false;
+        }
+        return false;
     }
 
 
diff --git a/src/java/org/apache/poi/hpsf/PropertySet.java b/src/java/org/apache/poi/hpsf/PropertySet.java
index b39ba08..df91828 100644
--- a/src/java/org/apache/poi/hpsf/PropertySet.java
+++ b/src/java/org/apache/poi/hpsf/PropertySet.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.IOException;
@@ -57,8 +57,6 @@
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
  * @author Drew Varner (Drew.Varner hanginIn sc.edu)
- * @version $Id$
- * @since 2002-02-09
  */
 public class PropertySet
 {
diff --git a/src/java/org/apache/poi/hpsf/PropertySetFactory.java b/src/java/org/apache/poi/hpsf/PropertySetFactory.java
index 1cd3dcd..3d2611e 100644
--- a/src/java/org/apache/poi/hpsf/PropertySetFactory.java
+++ b/src/java/org/apache/poi/hpsf/PropertySetFactory.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.InputStream;
@@ -30,8 +30,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2002-02-09
  */
 public class PropertySetFactory
 {
diff --git a/src/java/org/apache/poi/hpsf/ReadingNotSupportedException.java b/src/java/org/apache/poi/hpsf/ReadingNotSupportedException.java
index f325543..a66dc7c 100644
--- a/src/java/org/apache/poi/hpsf/ReadingNotSupportedException.java
+++ b/src/java/org/apache/poi/hpsf/ReadingNotSupportedException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -26,8 +26,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @since 2003-08-08
- * @version $Id$
  */
 public class ReadingNotSupportedException
     extends UnsupportedVariantTypeException
diff --git a/src/java/org/apache/poi/hpsf/Section.java b/src/java/org/apache/poi/hpsf/Section.java
index 76824e7..2c49f02 100644
--- a/src/java/org/apache/poi/hpsf/Section.java
+++ b/src/java/org/apache/poi/hpsf/Section.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.UnsupportedEncodingException;
@@ -34,8 +34,6 @@
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
  * @author Drew Varner (Drew.Varner allUpIn sc.edu)
- * @version $Id$
- * @since 2002-02-09
  */
 public class Section
 {
@@ -44,7 +42,7 @@
      * <p>Maps property IDs to section-private PID strings. These
      * strings can be found in the property with ID 0.</p>
      */
-    protected Map dictionary;
+    protected Map<Long,String> dictionary;
 
     /**
      * <p>The section's format ID, {@link #getFormatID}.</p>
@@ -148,7 +146,7 @@
      * @param src Contains the complete property set stream.
      * @param offset The position in the stream that points to the
      * section's format ID.
-     * 
+     *
      * @exception UnsupportedEncodingException if the section's codepage is not
      * supported.
      */
@@ -185,7 +183,7 @@
         /*
          * Read the properties. The offset is positioned at the first
          * entry of the property list. There are two problems:
-         * 
+         *
          * 1. For each property we have to find out its length. In the
          *    property list we find each property's ID and its offset relative
          *    to the section's beginning. Unfortunately the properties in the
@@ -193,8 +191,8 @@
          *    possible to calculate the length as
          *    (offset of property(i+1) - offset of property(i)). Before we can
          *    that we first have to sort the property list by ascending offsets.
-         * 
-         * 2. We have to read the property with ID 1 before we read other 
+         *
+         * 2. We have to read the property with ID 1 before we read other
          *    properties, at least before other properties containing strings.
          *    The reason is that property 1 specifies the codepage. If it is
          *    1200, all strings are in Unicode. In other words: Before we can
@@ -207,10 +205,10 @@
          *    seconds pass reads the other properties.
          */
         properties = new Property[propertyCount];
-        
+
         /* Pass 1: Read the property list. */
         int pass1Offset = o1;
-        final List propertyList = new ArrayList(propertyCount);
+        final List<PropertyListEntry> propertyList = new ArrayList<PropertyListEntry>(propertyCount);
         PropertyListEntry ple;
         for (int i = 0; i < properties.length; i++)
         {
@@ -234,34 +232,22 @@
         /* Calculate the properties' lengths. */
         for (int i = 0; i < propertyCount - 1; i++)
         {
-            final PropertyListEntry ple1 =
-                (PropertyListEntry) propertyList.get(i);
-            final PropertyListEntry ple2 =
-                (PropertyListEntry) propertyList.get(i + 1);
+            PropertyListEntry ple1 = propertyList.get(i);
+            PropertyListEntry ple2 = propertyList.get(i + 1);
             ple1.length = ple2.offset - ple1.offset;
         }
         if (propertyCount > 0)
         {
-            ple = (PropertyListEntry) propertyList.get(propertyCount - 1);
+            ple = propertyList.get(propertyCount - 1);
             ple.length = size - ple.offset;
-            if (ple.length <= 0)
-            {
-                final StringBuffer b = new StringBuffer();
-                b.append("The property set claims to have a size of ");
-                b.append(size);
-                b.append(" bytes. However, it exceeds ");
-                b.append(ple.offset);
-                b.append(" bytes.");
-                throw new IllegalPropertySetDataException(b.toString());
-            }
         }
 
         /* Look for the codepage. */
         int codepage = -1;
-        for (final Iterator i = propertyList.iterator();
+        for (final Iterator<PropertyListEntry> i = propertyList.iterator();
              codepage == -1 && i.hasNext();)
         {
-            ple = (PropertyListEntry) i.next();
+            ple = i.next();
 
             /* Read the codepage if the property ID is 1. */
             if (ple.id == PropertyIDMap.PID_CODEPAGE)
@@ -285,14 +271,14 @@
         /* Pass 2: Read all properties - including the codepage property,
          * if available. */
         int i1 = 0;
-        for (final Iterator i = propertyList.iterator(); i.hasNext();)
+        for (final Iterator<PropertyListEntry> i = propertyList.iterator(); i.hasNext();)
         {
-            ple = (PropertyListEntry) i.next();
+            ple = i.next();
             Property p = new Property(ple.id, src,
                     this.offset + ple.offset,
                     ple.length, codepage);
             if (p.getID() == PropertyIDMap.PID_CODEPAGE)
-                p = new Property(p.getID(), p.getType(), new Integer(codepage));
+                p = new Property(p.getID(), p.getType(), Integer.valueOf(codepage));
             properties[i1++] = p;
         }
 
@@ -308,7 +294,7 @@
      * <p>Represents an entry in the property list and holds a property's ID and
      * its offset from the section's beginning.</p>
      */
-    class PropertyListEntry implements Comparable
+    class PropertyListEntry implements Comparable<PropertyListEntry>
     {
         int id;
         int offset;
@@ -321,11 +307,9 @@
          *
          * @see Comparable#compareTo(java.lang.Object)
          */
-        public int compareTo(final Object o)
+        public int compareTo(final PropertyListEntry o)
         {
-            if (!(o instanceof PropertyListEntry))
-                throw new ClassCastException(o.toString());
-            final int otherOffset = ((PropertyListEntry) o).offset;
+            final int otherOffset = o.offset;
             if (offset < otherOffset)
                 return -1;
             else if (offset == otherOffset)
@@ -414,11 +398,11 @@
     protected boolean getPropertyBooleanValue(final int id)
     {
         final Boolean b = (Boolean) getProperty(id);
-        if (b != null)
-            return b.booleanValue();
-        else
+        if (b == null) {
             return false;
         }
+        return b.booleanValue();
+        }
 
 
 
@@ -464,7 +448,7 @@
     {
         String s = null;
         if (dictionary != null)
-            s = (String) dictionary.get(new Long(pid));
+            s = (String) dictionary.get(Long.valueOf(pid));
         if (s == null)
             s = SectionIDMap.getPIDString(getFormatID().getBytes(), pid);
         if (s == null)
@@ -477,23 +461,23 @@
     /**
      * <p>Checks whether this section is equal to another object. The result is
      * <code>false</code> if one of the the following conditions holds:</p>
-     * 
+     *
      * <ul>
-     * 
+     *
      * <li><p>The other object is not a {@link Section}.</p></li>
-     * 
+     *
      * <li><p>The format IDs of the two sections are not equal.</p></li>
-     *   
+     *
      * <li><p>The sections have a different number of properties. However,
      * properties with ID 1 (codepage) are not counted.</p></li>
-     * 
+     *
      * <li><p>The other object is not a {@link Section}.</p></li>
-     * 
+     *
      * <li><p>The properties have different values. The order of the properties
      * is irrelevant.</p></li>
-     * 
+     *
      * </ul>
-     * 
+     *
      * @param o The object to compare this section with
      * @return <code>true</code> if the objects are equal, <code>false</code> if
      * not
@@ -506,7 +490,7 @@
         if (!s.getFormatID().equals(getFormatID()))
             return false;
 
-        /* Compare all properties except 0 and 1 as they must be handled 
+        /* Compare all properties except 0 and 1 as they must be handled
          * specially. */
         Property[] pa1 = new Property[getProperties().length];
         Property[] pa2 = new Property[s.getProperties().length];
@@ -561,10 +545,10 @@
             dictionaryEqual = p10.getValue().equals(p20.getValue());
         else if (p10 != null || p20 != null)
             dictionaryEqual = false;
-        if (!dictionaryEqual)
-            return false;
-        else
+        if (dictionaryEqual) {
             return Util.equals(pa1, pa2);
+        }
+        return false;
     }
 
 
@@ -573,7 +557,7 @@
      * <p>Removes a field from a property array. The resulting array is
      * compactified and returned.</p>
      *
-     * @param pa The property array. 
+     * @param pa The property array.
      * @param i The index of the field to be removed.
      * @return the compactified array.
      */
@@ -644,7 +628,7 @@
      * @return the dictionary or <code>null</code> if the section does not have
      * a dictionary.
      */
-    public Map getDictionary()
+    public Map<Long,String> getDictionary()
     {
         return dictionary;
     }
diff --git a/src/java/org/apache/poi/hpsf/SpecialPropertySet.java b/src/java/org/apache/poi/hpsf/SpecialPropertySet.java
index f415bd5..2d04ef6 100644
--- a/src/java/org/apache/poi/hpsf/SpecialPropertySet.java
+++ b/src/java/org/apache/poi/hpsf/SpecialPropertySet.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.IOException;
@@ -53,8 +53,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2002-02-09
  */
 public abstract class SpecialPropertySet extends MutablePropertySet
 {
diff --git a/src/java/org/apache/poi/hpsf/SummaryInformation.java b/src/java/org/apache/poi/hpsf/SummaryInformation.java
index a143e2b..31eaa60 100644
--- a/src/java/org/apache/poi/hpsf/SummaryInformation.java
+++ b/src/java/org/apache/poi/hpsf/SummaryInformation.java
@@ -24,15 +24,12 @@
 /**
  * <p>Convenience class representing a Summary Information stream in a
  * Microsoft Office document.</p>
- * 
+ *
  * @author Rainer Klute <a
  *         href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
  * @see DocumentSummaryInformation
- * @version $Id$
- * @since 2002-02-09
  */
-public class SummaryInformation extends SpecialPropertySet
-{
+public final class SummaryInformation extends SpecialPropertySet {
 
     /**
      * <p>The document name a summary information stream usually has in a POIFS
@@ -48,7 +45,7 @@
     /**
      * <p>Creates a {@link SummaryInformation} from a given {@link
      * PropertySet}.</p>
-     * 
+     *
      * @param ps A property set which should be created from a summary
      *        information stream.
      * @throws UnexpectedPropertySetTypeException if <var>ps</var> does not
@@ -67,7 +64,7 @@
 
     /**
      * <p>Returns the title (or <code>null</code>).</p>
-     * 
+     *
      * @return The title or <code>null</code>
      */
     public String getTitle()
@@ -79,7 +76,7 @@
 
     /**
      * <p>Sets the title.</p>
-     * 
+     *
      * @param title The title to set.
      */
     public void setTitle(final String title)
@@ -103,7 +100,7 @@
 
     /**
      * <p>Returns the subject (or <code>null</code>).</p>
-     * 
+     *
      * @return The subject or <code>null</code>
      */
     public String getSubject()
@@ -115,7 +112,7 @@
 
     /**
      * <p>Sets the subject.</p>
-     * 
+     *
      * @param subject The subject to set.
      */
     public void setSubject(final String subject)
@@ -139,7 +136,7 @@
 
     /**
      * <p>Returns the author (or <code>null</code>).</p>
-     * 
+     *
      * @return The author or <code>null</code>
      */
     public String getAuthor()
@@ -151,7 +148,7 @@
 
     /**
      * <p>Sets the author.</p>
-     * 
+     *
      * @param author The author to set.
      */
     public void setAuthor(final String author)
@@ -175,7 +172,7 @@
 
     /**
      * <p>Returns the keywords (or <code>null</code>).</p>
-     * 
+     *
      * @return The keywords or <code>null</code>
      */
     public String getKeywords()
@@ -187,7 +184,7 @@
 
     /**
      * <p>Sets the keywords.</p>
-     * 
+     *
      * @param keywords The keywords to set.
      */
     public void setKeywords(final String keywords)
@@ -211,7 +208,7 @@
 
     /**
      * <p>Returns the comments (or <code>null</code>).</p>
-     * 
+     *
      * @return The comments or <code>null</code>
      */
     public String getComments()
@@ -223,7 +220,7 @@
 
     /**
      * <p>Sets the comments.</p>
-     * 
+     *
      * @param comments The comments to set.
      */
     public void setComments(final String comments)
@@ -247,7 +244,7 @@
 
     /**
      * <p>Returns the template (or <code>null</code>).</p>
-     * 
+     *
      * @return The template or <code>null</code>
      */
     public String getTemplate()
@@ -259,7 +256,7 @@
 
     /**
      * <p>Sets the template.</p>
-     * 
+     *
      * @param template The template to set.
      */
     public void setTemplate(final String template)
@@ -283,7 +280,7 @@
 
     /**
      * <p>Returns the last author (or <code>null</code>).</p>
-     * 
+     *
      * @return The last author or <code>null</code>
      */
     public String getLastAuthor()
@@ -295,7 +292,7 @@
 
     /**
      * <p>Sets the last author.</p>
-     * 
+     *
      * @param lastAuthor The last author to set.
      */
     public void setLastAuthor(final String lastAuthor)
@@ -319,7 +316,7 @@
 
     /**
      * <p>Returns the revision number (or <code>null</code>). </p>
-     * 
+     *
      * @return The revision number or <code>null</code>
      */
     public String getRevNumber()
@@ -331,7 +328,7 @@
 
     /**
      * <p>Sets the revision number.</p>
-     * 
+     *
      * @param revNumber The revision number to set.
      */
     public void setRevNumber(final String revNumber)
@@ -356,24 +353,24 @@
     /**
      * <p>Returns the total time spent in editing the document (or
      * <code>0</code>).</p>
-     * 
+     *
      * @return The total time spent in editing the document or 0 if the {@link
      *         SummaryInformation} does not contain this information.
      */
     public long getEditTime()
     {
         final Date d = (Date) getProperty(PropertyIDMap.PID_EDITTIME);
-        if (d == null)
+        if (d == null) {
             return 0;
-        else
-            return Util.dateToFileTime(d);
+        }
+        return Util.dateToFileTime(d);
     }
 
 
 
     /**
      * <p>Sets the total time spent in editing the document.</p>
-     * 
+     *
      * @param time The time to set.
      */
     public void setEditTime(final long time)
@@ -398,7 +395,7 @@
 
     /**
      * <p>Returns the last printed time (or <code>null</code>).</p>
-     * 
+     *
      * @return The last printed time or <code>null</code>
      */
     public Date getLastPrinted()
@@ -410,7 +407,7 @@
 
     /**
      * <p>Sets the lastPrinted.</p>
-     * 
+     *
      * @param lastPrinted The lastPrinted to set.
      */
     public void setLastPrinted(final Date lastPrinted)
@@ -435,7 +432,7 @@
 
     /**
      * <p>Returns the creation time (or <code>null</code>).</p>
-     * 
+     *
      * @return The creation time or <code>null</code>
      */
     public Date getCreateDateTime()
@@ -447,7 +444,7 @@
 
     /**
      * <p>Sets the creation time.</p>
-     * 
+     *
      * @param createDateTime The creation time to set.
      */
     public void setCreateDateTime(final Date createDateTime)
@@ -472,7 +469,7 @@
 
     /**
      * <p>Returns the last save time (or <code>null</code>).</p>
-     * 
+     *
      * @return The last save time or <code>null</code>
      */
     public Date getLastSaveDateTime()
@@ -484,7 +481,7 @@
 
     /**
      * <p>Sets the total time spent in editing the document.</p>
-     * 
+     *
      * @param time The time to set.
      */
     public void setLastSaveDateTime(final Date time)
@@ -511,7 +508,7 @@
     /**
      * <p>Returns the page count or 0 if the {@link SummaryInformation} does
      * not contain a page count.</p>
-     * 
+     *
      * @return The page count or 0 if the {@link SummaryInformation} does not
      *         contain a page count.
      */
@@ -524,7 +521,7 @@
 
     /**
      * <p>Sets the page count.</p>
-     * 
+     *
      * @param pageCount The page count to set.
      */
     public void setPageCount(final int pageCount)
@@ -549,7 +546,7 @@
     /**
      * <p>Returns the word count or 0 if the {@link SummaryInformation} does
      * not contain a word count.</p>
-     * 
+     *
      * @return The word count or <code>null</code>
      */
     public int getWordCount()
@@ -561,7 +558,7 @@
 
     /**
      * <p>Sets the word count.</p>
-     * 
+     *
      * @param wordCount The word count to set.
      */
     public void setWordCount(final int wordCount)
@@ -586,7 +583,7 @@
     /**
      * <p>Returns the character count or 0 if the {@link SummaryInformation}
      * does not contain a char count.</p>
-     * 
+     *
      * @return The character count or <code>null</code>
      */
     public int getCharCount()
@@ -598,7 +595,7 @@
 
     /**
      * <p>Sets the character count.</p>
-     * 
+     *
      * @param charCount The character count to set.
      */
     public void setCharCount(final int charCount)
@@ -624,12 +621,12 @@
      * <p>Returns the thumbnail (or <code>null</code>) <strong>when this
      * method is implemented. Please note that the return type is likely to
      * change!</strong></p>
-     * 
+     *
      * <p><strong>Hint to developers:</strong> Drew Varner &lt;Drew.Varner
      * -at- sc.edu&gt; said that this is an image in WMF or Clipboard (BMP?)
      * format. However, we won't do any conversion into any image type but
      * instead just return a byte array.</p>
-     * 
+     *
      * @return The thumbnail or <code>null</code>
      */
     public byte[] getThumbnail()
@@ -641,7 +638,7 @@
 
     /**
      * <p>Sets the thumbnail.</p>
-     * 
+     *
      * @param thumbnail The thumbnail to set.
      */
     public void setThumbnail(final byte[] thumbnail)
@@ -666,7 +663,7 @@
 
     /**
      * <p>Returns the application name (or <code>null</code>).</p>
-     * 
+     *
      * @return The application name or <code>null</code>
      */
     public String getApplicationName()
@@ -678,7 +675,7 @@
 
     /**
      * <p>Sets the application name.</p>
-     * 
+     *
      * @param applicationName The application name to set.
      */
     public void setApplicationName(final String applicationName)
@@ -702,24 +699,24 @@
 
     /**
      * <p>Returns a security code which is one of the following values:</p>
-     * 
+     *
      * <ul>
-     * 
+     *
      * <li><p>0 if the {@link SummaryInformation} does not contain a
      * security field or if there is no security on the document. Use
      * {@link PropertySet#wasNull()} to distinguish between the two
      * cases!</p></li>
-     * 
+     *
      * <li><p>1 if the document is password protected</p></li>
-     * 
+     *
      * <li><p>2 if the document is read-only recommended</p></li>
-     * 
+     *
      * <li><p>4 if the document is read-only enforced</p></li>
-     * 
+     *
      * <li><p>8 if the document is locked for annotations</p></li>
-     * 
+     *
      * </ul>
-     * 
+     *
      * @return The security code or <code>null</code>
      */
     public int getSecurity()
@@ -731,7 +728,7 @@
 
     /**
      * <p>Sets the security code.</p>
-     * 
+     *
      * @param security The security code to set.
      */
     public void setSecurity(final int security)
diff --git a/src/java/org/apache/poi/hpsf/Thumbnail.java b/src/java/org/apache/poi/hpsf/Thumbnail.java
index 9959a64..c39abe0 100644
--- a/src/java/org/apache/poi/hpsf/Thumbnail.java
+++ b/src/java/org/apache/poi/hpsf/Thumbnail.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import org.apache.poi.util.LittleEndian;
@@ -24,11 +24,8 @@
  *
  * @author Drew Varner (Drew.Varner inOrAround sc.edu)
  * @see SummaryInformation#getThumbnail()
- * @version $Id$
- * @since 2002-04-29
  */
-public class Thumbnail
-{
+public final class Thumbnail {
 
     /**
      * <p>Offset in bytes where the Clipboard Format Tag starts in the
@@ -130,7 +127,7 @@
      * <p>A <code>byte[]</code> to hold a thumbnail image in ({@link
      * Variant#VT_CF VT_CF}) format.</p>
      */
-    private byte[] thumbnailData = null;
+    private byte[] _thumbnailData = null;
 
 
 
@@ -156,7 +153,7 @@
      */
     public Thumbnail(final byte[] thumbnailData)
     {
-        this.thumbnailData = thumbnailData;
+        this._thumbnailData = thumbnailData;
     }
 
 
@@ -170,7 +167,7 @@
      */
     public byte[] getThumbnail()
     {
-        return thumbnailData;
+        return _thumbnailData;
     }
 
 
@@ -184,7 +181,7 @@
      */
     public void setThumbnail(final byte[] thumbnail)
     {
-        this.thumbnailData = thumbnail;
+        this._thumbnailData = thumbnail;
     }
 
 
@@ -263,21 +260,18 @@
         if (!(getClipboardFormatTag() == CFTAG_WINDOWS))
             throw new HPSFException("Clipboard Format Tag of Thumbnail must " +
                                     "be CFTAG_WINDOWS.");
-        if (!(getClipboardFormat() == CF_METAFILEPICT))
+        if (!(getClipboardFormat() == CF_METAFILEPICT)) {
             throw new HPSFException("Clipboard Format of Thumbnail must " +
                                     "be CF_METAFILEPICT.");
-        else
-        {
-            byte[] thumbnail = getThumbnail();
-            int wmfImageLength = thumbnail.length - OFFSET_WMFDATA;
-            byte[] wmfImage = new byte[wmfImageLength];
-            System.arraycopy(thumbnail,
-                             OFFSET_WMFDATA,
-                             wmfImage,
-                             0,
-                             wmfImageLength);
-            return wmfImage;
         }
+        byte[] thumbnail = getThumbnail();
+        int wmfImageLength = thumbnail.length - OFFSET_WMFDATA;
+        byte[] wmfImage = new byte[wmfImageLength];
+        System.arraycopy(thumbnail,
+                         OFFSET_WMFDATA,
+                         wmfImage,
+                         0,
+                         wmfImageLength);
+        return wmfImage;
     }
-
 }
diff --git a/src/java/org/apache/poi/hpsf/TypeWriter.java b/src/java/org/apache/poi/hpsf/TypeWriter.java
index bd7f346..84269ab 100644
--- a/src/java/org/apache/poi/hpsf/TypeWriter.java
+++ b/src/java/org/apache/poi/hpsf/TypeWriter.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.IOException;
@@ -27,8 +27,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2003-02-20
  */
 public class TypeWriter
 {
diff --git a/src/java/org/apache/poi/hpsf/UnexpectedPropertySetTypeException.java b/src/java/org/apache/poi/hpsf/UnexpectedPropertySetTypeException.java
index 2a56fda..de635d6 100644
--- a/src/java/org/apache/poi/hpsf/UnexpectedPropertySetTypeException.java
+++ b/src/java/org/apache/poi/hpsf/UnexpectedPropertySetTypeException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -27,8 +27,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @version $Id$
- * @since 2002-02-09
  */
 public class UnexpectedPropertySetTypeException extends HPSFException
 {
diff --git a/src/java/org/apache/poi/hpsf/UnsupportedVariantTypeException.java b/src/java/org/apache/poi/hpsf/UnsupportedVariantTypeException.java
index 49ca914..125f704 100644
--- a/src/java/org/apache/poi/hpsf/UnsupportedVariantTypeException.java
+++ b/src/java/org/apache/poi/hpsf/UnsupportedVariantTypeException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import org.apache.poi.util.HexDump;
@@ -28,8 +28,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @since 2003-08-05
- * @version $Id$
  */
 public abstract class UnsupportedVariantTypeException
 extends VariantTypeException
diff --git a/src/java/org/apache/poi/hpsf/Util.java b/src/java/org/apache/poi/hpsf/Util.java
index 85ea0ea..62a384a 100644
--- a/src/java/org/apache/poi/hpsf/Util.java
+++ b/src/java/org/apache/poi/hpsf/Util.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.io.IOException;
@@ -27,8 +27,6 @@
  * <p>Provides various static utility methods.</p>
  *
  * @author Rainer Klute (klute@rainer-klute.de)
- * @version $Id$
- * @since 2002-02-09
  */
 public class Util
 {
@@ -179,7 +177,7 @@
      *
      * @param date The date to be converted
      * @return The filetime
-     * 
+     *
      * @see #filetimeToDate(long)
      * @see #filetimeToDate(int, int)
      */
@@ -213,10 +211,10 @@
      * @return <code>true</code> if the collections are equal, else
      * <code>false</code>.
      */
-    public static boolean equals(final Collection c1, final Collection c2)
+    public static boolean equals(Collection<?> c1, Collection<?> c2)
     {
-        final Object[] o1 = c1.toArray();
-        final Object[] o2 = c2.toArray();
+        Object[] o1 = c1.toArray();
+        Object[] o2 = c2.toArray();
         return internalEquals(o1, o2);
     }
 
@@ -231,14 +229,14 @@
      * @return <code>true</code> if the object arrays are equal,
      * <code>false</code> if they are not.
      */
-    public static boolean equals(final Object[] c1, final Object[] c2)
+    public static boolean equals(Object[] c1, Object[] c2)
     {
-        final Object[] o1 = (Object[]) c1.clone();
-        final Object[] o2 = (Object[]) c2.clone();
+        final Object[] o1 = c1.clone();
+        final Object[] o2 = c2.clone();
         return internalEquals(o1, o2);
     }
 
-    private static boolean internalEquals(final Object[] o1, final Object[] o2)
+    private static boolean internalEquals(Object[] o1, Object[] o2)
     {
         for (int i1 = 0; i1 < o1.length; i1++)
         {
@@ -328,9 +326,9 @@
     /**
      * <p>Returns a textual representation of a {@link Throwable}, including a
      * stacktrace.</p>
-     * 
+     *
      * @param t The {@link Throwable}
-     * 
+     *
      * @return a string containing the output of a call to
      * <code>t.printStacktrace()</code>.
      */
diff --git a/src/java/org/apache/poi/hpsf/Variant.java b/src/java/org/apache/poi/hpsf/Variant.java
index 4366004..a37cbf0 100644
--- a/src/java/org/apache/poi/hpsf/Variant.java
+++ b/src/java/org/apache/poi/hpsf/Variant.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 import java.util.Collections;
@@ -34,8 +34,6 @@
  * <strong>[S]</strong> - may appear in a Safe Array.</p>
  *
  * @author Rainer Klute (klute@rainer-klute.de)
- * @version $Id$
- * @since 2002-02-09
  */
 public class Variant
 {
@@ -353,32 +351,32 @@
     /**
      * <p>Denotes a variant type with a length that is unknown to HPSF yet.</p>
      */
-    public static final Integer LENGTH_UNKNOWN = new Integer(-2);
+    public static final Integer LENGTH_UNKNOWN = Integer.valueOf(-2);
 
     /**
      * <p>Denotes a variant type with a variable length.</p>
      */
-    public static final Integer LENGTH_VARIABLE = new Integer(-1);
+    public static final Integer LENGTH_VARIABLE = Integer.valueOf(-1);
 
     /**
      * <p>Denotes a variant type with a length of 0 bytes.</p>
      */
-    public static final Integer LENGTH_0 = new Integer(0);
+    public static final Integer LENGTH_0 = Integer.valueOf(0);
 
     /**
      * <p>Denotes a variant type with a length of 2 bytes.</p>
      */
-    public static final Integer LENGTH_2 = new Integer(2);
+    public static final Integer LENGTH_2 = Integer.valueOf(2);
 
     /**
      * <p>Denotes a variant type with a length of 4 bytes.</p>
      */
-    public static final Integer LENGTH_4 = new Integer(4);
+    public static final Integer LENGTH_4 = Integer.valueOf(4);
 
     /**
      * <p>Denotes a variant type with a length of 8 bytes.</p>
      */
-    public static final Integer LENGTH_8 = new Integer(8);
+    public static final Integer LENGTH_8 = Integer.valueOf(8);
 
 
 
@@ -386,92 +384,92 @@
     {
         /* Initialize the number-to-name map: */
         Map tm1 = new HashMap();
-        tm1.put(new Long(0), "VT_EMPTY");
-        tm1.put(new Long(1), "VT_NULL");
-        tm1.put(new Long(2), "VT_I2");
-        tm1.put(new Long(3), "VT_I4");
-        tm1.put(new Long(4), "VT_R4");
-        tm1.put(new Long(5), "VT_R8");
-        tm1.put(new Long(6), "VT_CY");
-        tm1.put(new Long(7), "VT_DATE");
-        tm1.put(new Long(8), "VT_BSTR");
-        tm1.put(new Long(9), "VT_DISPATCH");
-        tm1.put(new Long(10), "VT_ERROR");
-        tm1.put(new Long(11), "VT_BOOL");
-        tm1.put(new Long(12), "VT_VARIANT");
-        tm1.put(new Long(13), "VT_UNKNOWN");
-        tm1.put(new Long(14), "VT_DECIMAL");
-        tm1.put(new Long(16), "VT_I1");
-        tm1.put(new Long(17), "VT_UI1");
-        tm1.put(new Long(18), "VT_UI2");
-        tm1.put(new Long(19), "VT_UI4");
-        tm1.put(new Long(20), "VT_I8");
-        tm1.put(new Long(21), "VT_UI8");
-        tm1.put(new Long(22), "VT_INT");
-        tm1.put(new Long(23), "VT_UINT");
-        tm1.put(new Long(24), "VT_VOID");
-        tm1.put(new Long(25), "VT_HRESULT");
-        tm1.put(new Long(26), "VT_PTR");
-        tm1.put(new Long(27), "VT_SAFEARRAY");
-        tm1.put(new Long(28), "VT_CARRAY");
-        tm1.put(new Long(29), "VT_USERDEFINED");
-        tm1.put(new Long(30), "VT_LPSTR");
-        tm1.put(new Long(31), "VT_LPWSTR");
-        tm1.put(new Long(64), "VT_FILETIME");
-        tm1.put(new Long(65), "VT_BLOB");
-        tm1.put(new Long(66), "VT_STREAM");
-        tm1.put(new Long(67), "VT_STORAGE");
-        tm1.put(new Long(68), "VT_STREAMED_OBJECT");
-        tm1.put(new Long(69), "VT_STORED_OBJECT");
-        tm1.put(new Long(70), "VT_BLOB_OBJECT");
-        tm1.put(new Long(71), "VT_CF");
-        tm1.put(new Long(72), "VT_CLSID");
+        tm1.put(Long.valueOf(0), "VT_EMPTY");
+        tm1.put(Long.valueOf(1), "VT_NULL");
+        tm1.put(Long.valueOf(2), "VT_I2");
+        tm1.put(Long.valueOf(3), "VT_I4");
+        tm1.put(Long.valueOf(4), "VT_R4");
+        tm1.put(Long.valueOf(5), "VT_R8");
+        tm1.put(Long.valueOf(6), "VT_CY");
+        tm1.put(Long.valueOf(7), "VT_DATE");
+        tm1.put(Long.valueOf(8), "VT_BSTR");
+        tm1.put(Long.valueOf(9), "VT_DISPATCH");
+        tm1.put(Long.valueOf(10), "VT_ERROR");
+        tm1.put(Long.valueOf(11), "VT_BOOL");
+        tm1.put(Long.valueOf(12), "VT_VARIANT");
+        tm1.put(Long.valueOf(13), "VT_UNKNOWN");
+        tm1.put(Long.valueOf(14), "VT_DECIMAL");
+        tm1.put(Long.valueOf(16), "VT_I1");
+        tm1.put(Long.valueOf(17), "VT_UI1");
+        tm1.put(Long.valueOf(18), "VT_UI2");
+        tm1.put(Long.valueOf(19), "VT_UI4");
+        tm1.put(Long.valueOf(20), "VT_I8");
+        tm1.put(Long.valueOf(21), "VT_UI8");
+        tm1.put(Long.valueOf(22), "VT_INT");
+        tm1.put(Long.valueOf(23), "VT_UINT");
+        tm1.put(Long.valueOf(24), "VT_VOID");
+        tm1.put(Long.valueOf(25), "VT_HRESULT");
+        tm1.put(Long.valueOf(26), "VT_PTR");
+        tm1.put(Long.valueOf(27), "VT_SAFEARRAY");
+        tm1.put(Long.valueOf(28), "VT_CARRAY");
+        tm1.put(Long.valueOf(29), "VT_USERDEFINED");
+        tm1.put(Long.valueOf(30), "VT_LPSTR");
+        tm1.put(Long.valueOf(31), "VT_LPWSTR");
+        tm1.put(Long.valueOf(64), "VT_FILETIME");
+        tm1.put(Long.valueOf(65), "VT_BLOB");
+        tm1.put(Long.valueOf(66), "VT_STREAM");
+        tm1.put(Long.valueOf(67), "VT_STORAGE");
+        tm1.put(Long.valueOf(68), "VT_STREAMED_OBJECT");
+        tm1.put(Long.valueOf(69), "VT_STORED_OBJECT");
+        tm1.put(Long.valueOf(70), "VT_BLOB_OBJECT");
+        tm1.put(Long.valueOf(71), "VT_CF");
+        tm1.put(Long.valueOf(72), "VT_CLSID");
         Map tm2 = new HashMap(tm1.size(), 1.0F);
         tm2.putAll(tm1);
         numberToName = Collections.unmodifiableMap(tm2);
 
         /* Initialize the number-to-length map: */
         tm1.clear();
-        tm1.put(new Long(0), LENGTH_0);
-        tm1.put(new Long(1), LENGTH_UNKNOWN);
-        tm1.put(new Long(2), LENGTH_2);
-        tm1.put(new Long(3), LENGTH_4);
-        tm1.put(new Long(4), LENGTH_4);
-        tm1.put(new Long(5), LENGTH_8);
-        tm1.put(new Long(6), LENGTH_UNKNOWN);
-        tm1.put(new Long(7), LENGTH_UNKNOWN);
-        tm1.put(new Long(8), LENGTH_UNKNOWN);
-        tm1.put(new Long(9), LENGTH_UNKNOWN);
-        tm1.put(new Long(10), LENGTH_UNKNOWN);
-        tm1.put(new Long(11), LENGTH_UNKNOWN);
-        tm1.put(new Long(12), LENGTH_UNKNOWN);
-        tm1.put(new Long(13), LENGTH_UNKNOWN);
-        tm1.put(new Long(14), LENGTH_UNKNOWN);
-        tm1.put(new Long(16), LENGTH_UNKNOWN);
-        tm1.put(new Long(17), LENGTH_UNKNOWN);
-        tm1.put(new Long(18), LENGTH_UNKNOWN);
-        tm1.put(new Long(19), LENGTH_UNKNOWN);
-        tm1.put(new Long(20), LENGTH_UNKNOWN);
-        tm1.put(new Long(21), LENGTH_UNKNOWN);
-        tm1.put(new Long(22), LENGTH_UNKNOWN);
-        tm1.put(new Long(23), LENGTH_UNKNOWN);
-        tm1.put(new Long(24), LENGTH_UNKNOWN);
-        tm1.put(new Long(25), LENGTH_UNKNOWN);
-        tm1.put(new Long(26), LENGTH_UNKNOWN);
-        tm1.put(new Long(27), LENGTH_UNKNOWN);
-        tm1.put(new Long(28), LENGTH_UNKNOWN);
-        tm1.put(new Long(29), LENGTH_UNKNOWN);
-        tm1.put(new Long(30), LENGTH_VARIABLE);
-        tm1.put(new Long(31), LENGTH_UNKNOWN);
-        tm1.put(new Long(64), LENGTH_8);
-        tm1.put(new Long(65), LENGTH_UNKNOWN);
-        tm1.put(new Long(66), LENGTH_UNKNOWN);
-        tm1.put(new Long(67), LENGTH_UNKNOWN);
-        tm1.put(new Long(68), LENGTH_UNKNOWN);
-        tm1.put(new Long(69), LENGTH_UNKNOWN);
-        tm1.put(new Long(70), LENGTH_UNKNOWN);
-        tm1.put(new Long(71), LENGTH_UNKNOWN);
-        tm1.put(new Long(72), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(0), LENGTH_0);
+        tm1.put(Long.valueOf(1), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(2), LENGTH_2);
+        tm1.put(Long.valueOf(3), LENGTH_4);
+        tm1.put(Long.valueOf(4), LENGTH_4);
+        tm1.put(Long.valueOf(5), LENGTH_8);
+        tm1.put(Long.valueOf(6), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(7), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(8), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(9), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(10), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(11), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(12), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(13), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(14), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(16), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(17), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(18), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(19), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(20), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(21), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(22), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(23), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(24), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(25), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(26), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(27), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(28), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(29), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(30), LENGTH_VARIABLE);
+        tm1.put(Long.valueOf(31), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(64), LENGTH_8);
+        tm1.put(Long.valueOf(65), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(66), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(67), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(68), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(69), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(70), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(71), LENGTH_UNKNOWN);
+        tm1.put(Long.valueOf(72), LENGTH_UNKNOWN);
         tm2 = new HashMap(tm1.size(), 1.0F);
         tm2.putAll(tm1);
         numberToLength = Collections.unmodifiableMap(tm2);
@@ -488,7 +486,7 @@
      */
     public static String getVariantName(final long variantType)
     {
-        final String name = (String) numberToName.get(new Long(variantType));
+        final String name = (String) numberToName.get(Long.valueOf(variantType));
         return name != null ? name : "unknown variant type";
     }
 
@@ -503,7 +501,7 @@
      */
     public static int getVariantLength(final long variantType)
     {
-        final Long key = new Long((int) variantType);
+        final Long key = Long.valueOf((int) variantType);
         final Long length = (Long) numberToLength.get(key);
         if (length == null)
             return -2;
diff --git a/src/java/org/apache/poi/hpsf/VariantSupport.java b/src/java/org/apache/poi/hpsf/VariantSupport.java
index 703e8ab..c01b3c5 100644
--- a/src/java/org/apache/poi/hpsf/VariantSupport.java
+++ b/src/java/org/apache/poi/hpsf/VariantSupport.java
@@ -29,10 +29,10 @@
 
 /**
  * <p>Supports reading and writing of variant data.</p>
- * 
+ *
  * <p><strong>FIXME (3):</strong> Reading and writing should be made more
  * uniform than it is now. The following items should be resolved:
- * 
+ *
  * <ul>
  *
  * <li><p>Reading requires a length parameter that is 4 byte greater than the
@@ -45,8 +45,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @since 2003-08-08
- * @version $Id$
  */
 public class VariantSupport extends Variant
 {
@@ -70,7 +68,7 @@
      * on or off.</p>
      *
      * @return <code>true</code> if logging is turned on, else
-     * <code>false</code>. 
+     * <code>false</code>.
      */
     public static boolean isLogUnsupportedTypes()
     {
@@ -99,7 +97,7 @@
         {
             if (unsupportedMessage == null)
                 unsupportedMessage = new LinkedList();
-            Long vt = new Long(ex.getVariantType());
+            Long vt = Long.valueOf(ex.getVariantType());
             if (!unsupportedMessage.contains(vt))
             {
                 System.err.println(ex.getMessage());
@@ -123,7 +121,7 @@
      * <p>Checks whether HPSF supports the specified variant type. Unsupported
      * types should be implemented included in the {@link #SUPPORTED_TYPES}
      * array.</p>
-     * 
+     *
      * @see Variant
      * @param variantType the variant type to check
      * @return <code>true</code> if HPFS supports this type, else
@@ -141,7 +139,7 @@
 
     /**
      * <p>Reads a variant type from a byte array.</p>
-     * 
+     *
      * @param src The byte array
      * @param offset The offset in the byte array where the variant starts
      * @param length The length of the variant including the variant type field
@@ -184,7 +182,7 @@
                  * Read a short. In Java it is represented as an
                  * Integer object.
                  */
-                value = new Integer(LittleEndian.getShort(src, o1));
+                value = Integer.valueOf(LittleEndian.getShort(src, o1));
                 break;
             }
             case Variant.VT_I4:
@@ -193,7 +191,7 @@
                  * Read a word. In Java it is represented as an
                  * Integer object.
                  */
-                value = new Integer(LittleEndian.getInt(src, o1));
+                value = Integer.valueOf(LittleEndian.getInt(src, o1));
                 break;
             }
             case Variant.VT_I8:
@@ -202,7 +200,7 @@
                  * Read a double word. In Java it is represented as a
                  * Long object.
                  */
-                value = new Long(LittleEndian.getLong(src, o1));
+                value = Long.valueOf(LittleEndian.getLong(src, o1));
                 break;
             }
             case Variant.VT_R8:
@@ -274,9 +272,20 @@
             }
             case Variant.VT_CF:
             {
+                if(l1 < 0) {
+                    /**
+                     *  YK: reading the ClipboardData packet (VT_CF) is not quite correct.
+                     *  The size of the data is determined by the first four bytes of the packet
+                     *  while the current implementation calculates it in the Section constructor.
+                     *  Test files in Bugzilla 42726 and 45583 clearly show that this approach does not always work.
+                     *  The workaround below attempts to gracefully handle such cases instead of throwing exceptions.
+                     *
+                     *  August 20, 2009
+                     */
+                    l1 = LittleEndian.getInt(src, o1); o1 += LittleEndian.INT_SIZE;
+                }
                 final byte[] v = new byte[l1];
-                for (int i = 0; i < l1; i++)
-                    v[i] = src[(o1 + i)];
+                System.arraycopy(src, o1, v, 0, v.length);
                 value = v;
                 break;
             }
@@ -309,16 +318,16 @@
 
 
     /**
-     * <p>Turns a codepage number into the equivalent character encoding's 
+     * <p>Turns a codepage number into the equivalent character encoding's
      * name.</p>
      *
      * @param codepage The codepage number
-     * 
-     * @return The character encoding's name. If the codepage number is 65001, 
+     *
+     * @return The character encoding's name. If the codepage number is 65001,
      * the encoding name is "UTF-8". All other positive numbers are mapped to
-     * "cp" followed by the number, e.g. if the codepage number is 1252 the 
+     * "cp" followed by the number, e.g. if the codepage number is 1252 the
      * returned character encoding name will be "cp1252".
-     * 
+     *
      * @exception UnsupportedEncodingException if the specified codepage is
      * less than zero.
      */
@@ -491,7 +500,7 @@
             }
             case Variant.VT_LPWSTR:
             {
-                final int nrOfChars = ((String) value).length() + 1; 
+                final int nrOfChars = ((String) value).length() + 1;
                 length += TypeWriter.writeUIntToStream(out, nrOfChars);
                 char[] s = Util.pad4((String) value);
                 for (int i = 0; i < s.length; i++)
@@ -511,7 +520,7 @@
             }
             case Variant.VT_CF:
             {
-                final byte[] b = (byte[]) value; 
+                final byte[] b = (byte[]) value;
                 out.write(b);
                 length = b.length;
                 break;
@@ -537,7 +546,7 @@
                             + value.getClass().toString() + ", "
                             + value.toString());
                 }
-                length += TypeWriter.writeToStream(out, 
+                length += TypeWriter.writeToStream(out,
                           ((Integer) value).intValue());
                 break;
             }
@@ -549,7 +558,7 @@
             }
             case Variant.VT_R8:
             {
-                length += TypeWriter.writeToStream(out, 
+                length += TypeWriter.writeToStream(out,
                           ((Double) value).doubleValue());
                 break;
             }
@@ -570,7 +579,7 @@
                  * is a byte array we can write it nevertheless. */
                 if (value instanceof byte[])
                 {
-                    final byte[] b = (byte[]) value; 
+                    final byte[] b = (byte[]) value;
                     out.write(b);
                     length = b.length;
                     writeUnsupportedTypeMessage
@@ -584,5 +593,4 @@
 
         return length;
     }
-
 }
diff --git a/src/java/org/apache/poi/hpsf/VariantTypeException.java b/src/java/org/apache/poi/hpsf/VariantTypeException.java
index 0f35a88..58100bd 100644
--- a/src/java/org/apache/poi/hpsf/VariantTypeException.java
+++ b/src/java/org/apache/poi/hpsf/VariantTypeException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -23,8 +23,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @since 2004-06-21
- * @version $Id$
  */
 public abstract class VariantTypeException extends HPSFException
 {
diff --git a/src/java/org/apache/poi/hpsf/WritingNotSupportedException.java b/src/java/org/apache/poi/hpsf/WritingNotSupportedException.java
index 91fcbf1..e602478 100644
--- a/src/java/org/apache/poi/hpsf/WritingNotSupportedException.java
+++ b/src/java/org/apache/poi/hpsf/WritingNotSupportedException.java
@@ -14,7 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.hpsf;
 
 /**
@@ -26,8 +26,6 @@
  *
  * @author Rainer Klute <a
  * href="mailto:klute@rainer-klute.de">&lt;klute@rainer-klute.de&gt;</a>
- * @since 2003-08-08
- * @version $Id$
  */
 public class WritingNotSupportedException
     extends UnsupportedVariantTypeException
diff --git a/src/java/org/apache/poi/hpsf/extractor/HPSFPropertiesExtractor.java b/src/java/org/apache/poi/hpsf/extractor/HPSFPropertiesExtractor.java
index ecad5c0..32f9049 100644
--- a/src/java/org/apache/poi/hpsf/extractor/HPSFPropertiesExtractor.java
+++ b/src/java/org/apache/poi/hpsf/extractor/HPSFPropertiesExtractor.java
@@ -14,8 +14,11 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
+
 package org.apache.poi.hpsf.extractor;
 
+import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Iterator;
@@ -28,12 +31,13 @@
 import org.apache.poi.hpsf.SpecialPropertySet;
 import org.apache.poi.hpsf.SummaryInformation;
 import org.apache.poi.hpsf.wellknown.PropertyIDMap;
+import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;
 import org.apache.poi.poifs.filesystem.POIFSFileSystem;
 import org.apache.poi.util.LittleEndian;
 
 /**
  * Extracts all of the HPSF properties, both
- *  build in and custom, returning them in 
+ *  build in and custom, returning them in
  *  textual form.
  */
 public class HPSFPropertiesExtractor extends POITextExtractor {
@@ -46,54 +50,59 @@
 	public HPSFPropertiesExtractor(POIFSFileSystem fs) {
 		super(new PropertiesOnlyDocument(fs));
 	}
-	
+   public HPSFPropertiesExtractor(NPOIFSFileSystem fs) {
+      super(new PropertiesOnlyDocument(fs));
+   }
+
 	public String getDocumentSummaryInformationText() {
 		DocumentSummaryInformation dsi = document.getDocumentSummaryInformation();
 		StringBuffer text = new StringBuffer();
 
 		// Normal properties
 		text.append( getPropertiesText(dsi) );
-		
+
 		// Now custom ones
-		CustomProperties cps = dsi.getCustomProperties();
-		Iterator keys = cps.keySet().iterator();
-		while(keys.hasNext()) {
-			String key = (String)keys.next();
-			String val = getPropertyValueText( cps.get(key) );
-			text.append(key + " = " + val + "\n");
+		CustomProperties cps = dsi == null ? null : dsi.getCustomProperties();
+		if(cps != null) {
+			Iterator<String> keys = cps.nameSet().iterator();
+			while(keys.hasNext()) {
+				String key = keys.next();
+				String val = getPropertyValueText( cps.get(key) );
+				text.append(key + " = " + val + "\n");
+			}
 		}
-		
+
 		// All done
 		return text.toString();
 	}
 	public String getSummaryInformationText() {
 		SummaryInformation si = document.getSummaryInformation();
-		
+
 		// Just normal properties
 		return getPropertiesText(si);
 	}
-	
+
 	private static String getPropertiesText(SpecialPropertySet ps) {
 		if(ps == null) {
 			// Not defined, oh well
 			return "";
 		}
-		
+
 		StringBuffer text = new StringBuffer();
-		
+
 		PropertyIDMap idMap = ps.getPropertySetIDMap();
 		Property[] props = ps.getProperties();
 		for(int i=0; i<props.length; i++) {
-			String type = Long.toString( props[i].getID() ); 
+			String type = Long.toString( props[i].getID() );
 			Object typeObj = idMap.get(props[i].getID());
 			if(typeObj != null) {
 				type = typeObj.toString();
 			}
-			
+
 			String val = getPropertyValueText( props[i].getValue() );
 			text.append(type + " = " + val + "\n");
 		}
-		
+
 		return text.toString();
 	}
 	private static String getPropertyValueText(Object val) {
@@ -121,13 +130,13 @@
 	}
 
 	/**
-	 * Return the text of all the properties defined in
+	 * @return the text of all the properties defined in
 	 *  the document.
 	 */
 	public String getText() {
 		return getSummaryInformationText() + getDocumentSummaryInformationText();
 	}
-	
+
 	/**
 	 * Prevent recursion!
 	 */
@@ -136,16 +145,28 @@
 	}
 
 	/**
-	 * So we can get at the properties of any 
+	 * So we can get at the properties of any
 	 *  random OLE2 document.
 	 */
-	private static class PropertiesOnlyDocument extends POIDocument {
-		private PropertiesOnlyDocument(POIFSFileSystem fs) {
+	private static final class PropertiesOnlyDocument extends POIDocument {
+      public PropertiesOnlyDocument(NPOIFSFileSystem fs) {
+         super(fs.getRoot());
+      }
+		public PropertiesOnlyDocument(POIFSFileSystem fs) {
 			super(fs);
 		}
 
-		public void write(OutputStream out) throws IOException {
+		public void write(OutputStream out) {
 			throw new IllegalStateException("Unable to write, only for properties!");
 		}
 	}
+	
+	public static void main(String[] args) throws IOException {
+	   for(String file : args) {
+	      HPSFPropertiesExtractor ext = new HPSFPropertiesExtractor(
+	            new NPOIFSFileSystem(new File(file))
+	      );
+	      System.out.println(ext.getText());
+	   }
+	}
 }
diff --git a/src/java/org/apache/poi/hssf/record/StyleRecord.java b/src/java/org/apache/poi/hssf/record/StyleRecord.java
index 5b746e8..45c2bac 100644
--- a/src/java/org/apache/poi/hssf/record/StyleRecord.java
+++ b/src/java/org/apache/poi/hssf/record/StyleRecord.java
@@ -73,7 +73,7 @@
 	            
 	            byte[] string = in.readRemainder();
 	            if (fHighByte.isSet(field_3_string_options)) {
-	                field_4_name= StringUtil.getFromUnicodeBE(string, 0, field_2_name_length);
+	                field_4_name= StringUtil.getFromUnicodeLE(string, 0, field_2_name_length);
 	            } else {
 	                field_4_name=StringUtil.getFromCompressedUnicode(string, 0, field_2_name_length);
 	            }
diff --git a/src/java/org/apache/poi/hssf/usermodel/HSSFWorkbook.java b/src/java/org/apache/poi/hssf/usermodel/HSSFWorkbook.java
index e6cc861..3a7ca03 100644
--- a/src/java/org/apache/poi/hssf/usermodel/HSSFWorkbook.java
+++ b/src/java/org/apache/poi/hssf/usermodel/HSSFWorkbook.java
@@ -257,7 +257,6 @@
         // If we're not preserving nodes, don't track the
         //  POIFS any more
         if(! preserveNodes) {
-           this.filesystem = null;
            this.directory = null;
         }
 
@@ -1163,7 +1162,7 @@
             excepts.add("WORKBOOK");
 
             // Copy over all the other nodes to our new poifs
-            copyNodes(this.filesystem,fs,excepts);
+            copyNodes(this.directory.getFileSystem(),fs,excepts);
         }
         fs.writeFilesystem(stream);
         //poifs.writeFilesystem(stream);
@@ -1664,7 +1663,7 @@
                     Object sub = subRecordIter.next();
                     if (sub instanceof EmbeddedObjectRefSubRecord)
                     {
-                        objects.add(new HSSFObjectData((ObjRecord) obj, filesystem));
+                        objects.add(new HSSFObjectData((ObjRecord) obj, this.directory.getFileSystem()));
                     }
                 }
             }
diff --git a/src/java/org/apache/poi/poifs/common/POIFSBigBlockSize.java b/src/java/org/apache/poi/poifs/common/POIFSBigBlockSize.java
new file mode 100644
index 0000000..1e8b1b1
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/common/POIFSBigBlockSize.java
@@ -0,0 +1,64 @@
+
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+        
+
+package org.apache.poi.poifs.common;
+
+import org.apache.poi.util.LittleEndianConsts;
+
+/**
+ * <p>A class describing attributes of the Big Block Size</p>
+ */
+public final class POIFSBigBlockSize
+{
+   private int bigBlockSize;
+   private short headerValue;
+   
+   protected POIFSBigBlockSize(int bigBlockSize, short headerValue) {
+      this.bigBlockSize = bigBlockSize;
+      this.headerValue = headerValue;
+   }
+   
+   public int getBigBlockSize() {
+      return bigBlockSize;
+   }
+   
+   /**
+    * Returns the value that gets written into the 
+    *  header.
+    * Is the power of two that corresponds to the
+    *  size of the block, eg 512 => 9
+    */
+   public short getHeaderValue() {
+      return headerValue;
+   }
+   
+   public int getPropertiesPerBlock() {
+      return bigBlockSize / POIFSConstants.PROPERTY_SIZE;
+   }
+   
+   public int getBATEntriesPerBlock() {
+      return bigBlockSize / LittleEndianConsts.INT_SIZE;
+   }
+   public int getXBATEntriesPerBlock() {
+      return getBATEntriesPerBlock() - 1;
+   }
+   public int getNextXBATChainOffset() {
+      return getXBATEntriesPerBlock() * LittleEndianConsts.INT_SIZE;
+   }
+}
diff --git a/src/java/org/apache/poi/poifs/common/POIFSConstants.java b/src/java/org/apache/poi/poifs/common/POIFSConstants.java
index ff20502..d148f8b 100644
--- a/src/java/org/apache/poi/poifs/common/POIFSConstants.java
+++ b/src/java/org/apache/poi/poifs/common/POIFSConstants.java
@@ -21,21 +21,48 @@
 
 /**
  * <p>A repository for constants shared by POI classes.</p>
- *
- * @author Marc Johnson (mjohnson at apache dot org)
  */
-
 public interface POIFSConstants
 {
     /** Most files use 512 bytes as their big block size */
-    public static final int BIG_BLOCK_SIZE = 0x0200;
+    public static final int SMALLER_BIG_BLOCK_SIZE = 0x0200;
+    public static final POIFSBigBlockSize SMALLER_BIG_BLOCK_SIZE_DETAILS = 
+       new POIFSBigBlockSize(SMALLER_BIG_BLOCK_SIZE, (short)9);
     /** Some use 4096 bytes */
     public static final int LARGER_BIG_BLOCK_SIZE = 0x1000;
+    public static final POIFSBigBlockSize LARGER_BIG_BLOCK_SIZE_DETAILS = 
+       new POIFSBigBlockSize(LARGER_BIG_BLOCK_SIZE, (short)12);
     
-    public static final int END_OF_CHAIN   = -2;
+    /** How big a block in the small block stream is. Fixed size */
+    public static final int SMALL_BLOCK_SIZE = 0x0040; 
+    
+    /** How big a single property is */
     public static final int PROPERTY_SIZE  = 0x0080;
+    
+    /** 
+     * The minimum size of a document before it's stored using 
+     *  Big Blocks (normal streams). Smaller documents go in the 
+     *  Mini Stream (SBAT / Small Blocks)
+     */
+    public static final int BIG_BLOCK_MINIMUM_DOCUMENT_SIZE = 0x1000;
+    
+    /** The highest sector number you're allowed, 0xFFFFFFFA */
+    public static final int LARGEST_REGULAR_SECTOR_NUMBER = -5;
+    
+    /** Indicates the sector holds a DIFAT block (0xFFFFFFFC) */
+    public static final int DIFAT_SECTOR_BLOCK   = -4;
+    /** Indicates the sector holds a FAT block (0xFFFFFFFD) */
+    public static final int FAT_SECTOR_BLOCK   = -3;
+    /** Indicates the sector is the end of a chain (0xFFFFFFFE) */
+    public static final int END_OF_CHAIN   = -2;
+    /** Indicates the sector is not used (0xFFFFFFFF) */
     public static final int UNUSED_BLOCK   = -1;
     
+    /** The first 4 bytes of an OOXML file, used in detection */
     public static final byte[] OOXML_FILE_HEADER = 
     	new byte[] { 0x50, 0x4b, 0x03, 0x04 };
+
+    /** HACKY: For backwards compatibility on 3.2 */
+    public static final int BIG_BLOCK_SIZE = SMALLER_BIG_BLOCK_SIZE;
+
 }   // end public interface POIFSConstants;
diff --git a/src/java/org/apache/poi/poifs/dev/POIFSDump.java b/src/java/org/apache/poi/poifs/dev/POIFSDump.java
index 5028bab..ace19d8 100755
--- a/src/java/org/apache/poi/poifs/dev/POIFSDump.java
+++ b/src/java/org/apache/poi/poifs/dev/POIFSDump.java
@@ -1,74 +1,74 @@
-/* ====================================================================
-   Licensed to the Apache Software Foundation (ASF) under one or more
-   contributor license agreements.  See the NOTICE file distributed with
-   this work for additional information regarding copyright ownership.
-   The ASF licenses this file to You 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.
-==================================================================== */
-package org.apache.poi.poifs.dev;
-
-import org.apache.poi.poifs.filesystem.*;
-
-import java.io.FileInputStream;
-import java.io.File;
-import java.io.IOException;
-import java.io.FileOutputStream;
-import java.util.Iterator;
-
-/**
- *
- * Dump internal structure of a OLE2 file into file system
- *
- * @author Yegor Kozlov
- */
-public class POIFSDump {
-
-    public static void main(String[] args) throws Exception {
-        for (int i = 0; i < args.length; i++) {
-            System.out.println("Dumping " + args[i]);
-            FileInputStream is = new FileInputStream(args[i]);
-            POIFSFileSystem fs = new POIFSFileSystem(is);
-            is.close();
-
-            DirectoryEntry root = fs.getRoot();
-            File file = new File(root.getName());
-            file.mkdir();
-
-            dump(root, file);
-        }
-   }
-
-
-    public static void dump(DirectoryEntry root, File parent) throws IOException {
-        for(Iterator it = root.getEntries(); it.hasNext();){
-            Entry entry = (Entry)it.next();
-            if(entry instanceof DocumentNode){
-                DocumentNode node = (DocumentNode)entry;
-                DocumentInputStream is = new DocumentInputStream(node);
-                byte[] bytes = new byte[node.getSize()];
-                is.read(bytes);
-                is.close();
-
-                FileOutputStream out = new FileOutputStream(new File(parent, node.getName().trim()));
-                out.write(bytes);
-                out.close();
-            } else if (entry instanceof DirectoryEntry){
-                DirectoryEntry dir = (DirectoryEntry)entry;
-                File file = new File(parent, entry.getName());
-                file.mkdir();
-                dump(dir, file);
-            } else {
-                System.err.println("Skipping unsupported POIFS entry: " + entry);
-            }
-        }
-    }
-}
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+package org.apache.poi.poifs.dev;
+
+import org.apache.poi.poifs.filesystem.*;
+
+import java.io.FileInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.FileOutputStream;
+import java.util.Iterator;
+
+/**
+ *
+ * Dump internal structure of a OLE2 file into file system
+ *
+ * @author Yegor Kozlov
+ */
+public class POIFSDump {
+
+    public static void main(String[] args) throws Exception {
+        for (int i = 0; i < args.length; i++) {
+            System.out.println("Dumping " + args[i]);
+            FileInputStream is = new FileInputStream(args[i]);
+            POIFSFileSystem fs = new POIFSFileSystem(is);
+            is.close();
+
+            DirectoryEntry root = fs.getRoot();
+            File file = new File(root.getName());
+            file.mkdir();
+
+            dump(root, file);
+        }
+   }
+
+
+    public static void dump(DirectoryEntry root, File parent) throws IOException {
+        for(Iterator it = root.getEntries(); it.hasNext();){
+            Entry entry = (Entry)it.next();
+            if(entry instanceof DocumentNode){
+                DocumentNode node = (DocumentNode)entry;
+                DocumentInputStream is = new DocumentInputStream(node);
+                byte[] bytes = new byte[node.getSize()];
+                is.read(bytes);
+                is.close();
+
+                FileOutputStream out = new FileOutputStream(new File(parent, node.getName().trim()));
+                out.write(bytes);
+                out.close();
+            } else if (entry instanceof DirectoryEntry){
+                DirectoryEntry dir = (DirectoryEntry)entry;
+                File file = new File(parent, entry.getName());
+                file.mkdir();
+                dump(dir, file);
+            } else {
+                System.err.println("Skipping unsupported POIFS entry: " + entry);
+            }
+        }
+    }
+}
diff --git a/src/java/org/apache/poi/poifs/dev/POIFSHeaderDumper.java b/src/java/org/apache/poi/poifs/dev/POIFSHeaderDumper.java
new file mode 100644
index 0000000..78ed986
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/dev/POIFSHeaderDumper.java
@@ -0,0 +1,152 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.dev;
+
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
+import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.property.PropertyTable;
+import org.apache.poi.poifs.storage.BlockAllocationTableReader;
+import org.apache.poi.poifs.storage.BlockList;
+import org.apache.poi.poifs.storage.HeaderBlock;
+import org.apache.poi.poifs.storage.ListManagedBlock;
+import org.apache.poi.poifs.storage.RawDataBlockList;
+import org.apache.poi.poifs.storage.SmallBlockTableReader;
+import org.apache.poi.util.HexDump;
+import org.apache.poi.util.IntList;
+
+/**
+ * A very low level debugging tool, for printing out core 
+ *  information on the headers and FAT blocks.
+ * You probably only want to use this if you're trying
+ *  to understand POIFS, or if you're trying to track
+ *  down the source of corruption in a file.
+ */
+public class POIFSHeaderDumper {
+	/**
+	 * Display the entries of multiple POIFS files
+	 *
+	 * @param args the names of the files to be displayed
+	 */
+	public static void main(final String args[]) throws Exception {
+		if (args.length == 0) {
+			System.err.println("Must specify at least one file to view");
+			System.exit(1);
+		}
+
+		for (int j = 0; j < args.length; j++) {
+		   viewFile(args[j]);
+		}
+	}
+
+	public static void viewFile(final String filename) throws Exception {
+		InputStream inp = new FileInputStream(filename);
+		
+		// Header
+		HeaderBlock header_block = new HeaderBlock(inp);
+		displayHeader(header_block);
+		
+		// Raw blocks
+      POIFSBigBlockSize bigBlockSize = header_block.getBigBlockSize();
+      RawDataBlockList data_blocks = new RawDataBlockList(inp, bigBlockSize);
+      displayRawBlocksSummary(data_blocks);
+      
+      // Main FAT Table
+      BlockAllocationTableReader batReader =
+         new BlockAllocationTableReader(
+            header_block.getBigBlockSize(),
+            header_block.getBATCount(),
+            header_block.getBATArray(),
+            header_block.getXBATCount(),
+            header_block.getXBATIndex(),
+            data_blocks);
+      displayBATReader(batReader);
+
+      // Properties Table
+      PropertyTable properties =
+         new PropertyTable(header_block, data_blocks);
+      
+      // Mini Fat
+      BlockList sbat = 
+         SmallBlockTableReader.getSmallDocumentBlocks(
+               bigBlockSize, data_blocks, properties.getRoot(),
+               header_block.getSBATStart()
+         );
+   }
+
+	public static void displayHeader(HeaderBlock header_block) throws Exception {
+	   System.out.println("Header Details:");
+	   System.out.println(" Block size: " + header_block.getBigBlockSize().getBigBlockSize());
+      System.out.println(" BAT (FAT) header blocks: " + header_block.getBATArray().length);
+      System.out.println(" BAT (FAT) block count: " + header_block.getBATCount());
+      System.out.println(" XBAT (FAT) block count: " + header_block.getXBATCount());
+      System.out.println(" XBAT (FAT) block 1 at: " + header_block.getXBATIndex());
+      System.out.println(" SBAT (MiniFAT) block count: " + header_block.getSBATCount());
+      System.out.println(" SBAT (MiniFAT) block 1 at: " + header_block.getSBATStart());
+      System.out.println(" Property table at: " + header_block.getPropertyStart());
+      System.out.println("");
+	}
+
+   public static void displayRawBlocksSummary(RawDataBlockList data_blocks) throws Exception {
+      System.out.println("Raw Blocks Details:");
+      System.out.println(" Number of blocks: " + data_blocks.blockCount());
+      
+      Method gbm = data_blocks.getClass().getSuperclass().getDeclaredMethod("get", int.class);
+      gbm.setAccessible(true);
+      
+      for(int i=0; i<Math.min(16, data_blocks.blockCount()); i++) {
+         ListManagedBlock block = (ListManagedBlock)gbm.invoke(data_blocks, Integer.valueOf(i));
+         byte[] data = new byte[Math.min(48, block.getData().length)];
+         System.arraycopy(block.getData(), 0, data, 0, data.length);
+         
+         System.out.println(" Block #" + i + ":");
+         System.out.println(HexDump.dump(data, 0, 0));
+      }
+      
+      System.out.println("");
+   }
+   
+   public static void displayBATReader(BlockAllocationTableReader batReader) throws Exception {
+      System.out.println("Sectors, as referenced from the FAT:");
+      Field entriesF = batReader.getClass().getDeclaredField("_entries");
+      entriesF.setAccessible(true);
+      IntList entries = (IntList)entriesF.get(batReader);
+      
+      for(int i=0; i<entries.size(); i++) {
+         int bn = entries.get(i);
+         String bnS = Integer.toString(bn);
+         if(bn == POIFSConstants.END_OF_CHAIN) {
+            bnS = "End Of Chain";
+         } else if(bn == POIFSConstants.DIFAT_SECTOR_BLOCK) {
+            bnS = "DI Fat Block";
+         } else if(bn == POIFSConstants.FAT_SECTOR_BLOCK) {
+            bnS = "Normal Fat Block";
+         } else if(bn == POIFSConstants.UNUSED_BLOCK) {
+            bnS = "Block Not Used (Free)";
+         }
+         
+         System.out.println("  Block  # " + i + " -> " + bnS);
+      }
+      
+      System.out.println("");
+   }
+}
diff --git a/src/java/org/apache/poi/poifs/dev/POIFSLister.java b/src/java/org/apache/poi/poifs/dev/POIFSLister.java
index cdd9902..357773a 100644
--- a/src/java/org/apache/poi/poifs/dev/POIFSLister.java
+++ b/src/java/org/apache/poi/poifs/dev/POIFSLister.java
@@ -17,82 +17,88 @@
 
 package org.apache.poi.poifs.dev;
 
+import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.util.Iterator;
 
-import org.apache.poi.poifs.filesystem.DirectoryEntry;
 import org.apache.poi.poifs.filesystem.DirectoryNode;
-import org.apache.poi.poifs.filesystem.DocumentEntry;
 import org.apache.poi.poifs.filesystem.DocumentNode;
+import org.apache.poi.poifs.filesystem.Entry;
+import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;
 import org.apache.poi.poifs.filesystem.POIFSFileSystem;
 
 /**
  * A lister of the entries in POIFS files.
- * 
+ *
  * Much simpler than {@link POIFSViewer}
  */
 public class POIFSLister {
-    /**
-     * Display the entries of multiple POIFS files
-     *
-     * @param args the names of the files to be displayed
-     */
-    public static void main(final String args[]) throws IOException {
-        if (args.length == 0)
-        {
-            System.err.println("Must specify at least one file to view");
-            System.exit(1);
-        }
+   /**
+    * Display the entries of multiple POIFS files
+    *
+    * @param args the names of the files to be displayed
+    */
+   public static void main(final String args[]) throws IOException {
+      if (args.length == 0) {
+         System.err.println("Must specify at least one file to view");
+         System.exit(1);
+      }
 
-        boolean withSizes = false;
-        for (int j = 0; j < args.length; j++) {
-        	if(args[j].equalsIgnoreCase("-size") || 
-        			args[j].equalsIgnoreCase("-sizes")) {
-        		withSizes = true;
-        	} else {
-        		viewFile(args[j], withSizes);
-        	}
-        }
-    }
+      boolean withSizes = false;
+      boolean newPOIFS = true;
+      for (int j = 0; j < args.length; j++) {
+         if (args[j].equalsIgnoreCase("-size") || args[j].equalsIgnoreCase("-sizes")) {
+            withSizes = true;
+         } else if (args[j].equalsIgnoreCase("-old") || args[j].equalsIgnoreCase("-old-poifs")) {
+            newPOIFS = false;
+         } else {
+            if(newPOIFS) {
+               viewFile(args[j], withSizes);
+            } else {
+               viewFileOld(args[j], withSizes);
+            }
+         }
+      }
+   }
 
-    public static void viewFile(final String filename, boolean withSizes) throws IOException
-    {
-    	POIFSFileSystem fs = new POIFSFileSystem(
-    			new FileInputStream(filename)
-    	);
-    	displayDirectory(fs.getRoot(), "", withSizes);
-    }
-    
-    public static void displayDirectory(DirectoryNode dir, String indent, boolean withSizes) {
-    	System.out.println(indent + dir.getName() + " -");
-    	String newIndent = indent + "  ";
-    	
-    	boolean hadChildren = false;
-    	for(Iterator it = dir.getEntries(); it.hasNext(); ) {
-    		hadChildren = true;
-    		Object entry = it.next();
-    		if(entry instanceof DirectoryNode) {
-    			displayDirectory((DirectoryNode)entry, newIndent, withSizes);
-    		} else {
-    			DocumentNode doc = (DocumentNode)entry;
-    			String name = doc.getName();
-    			String size = "";
-    			if(name.charAt(0) < 10) {
-    				String altname = "(0x0" + (int)name.charAt(0) + ")" + name.substring(1);
-    				name = name.substring(1) + " <" + altname + ">";
-    			}
-    			if(withSizes) {
-    				size = " [" +
-    					doc.getSize() + " / 0x" +
-    					Integer.toHexString(doc.getSize()) +
-    					"]";
-    			}
-    			System.out.println(newIndent + name + size);
-    		}
-    	}
-    	if(!hadChildren) {
-    		System.out.println(newIndent + "(no children)");
-    	}
-    }
-}
\ No newline at end of file
+   public static void viewFile(final String filename, boolean withSizes) throws IOException {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(new File(filename));
+      displayDirectory(fs.getRoot(), "", withSizes);
+   }
+
+   public static void viewFileOld(final String filename, boolean withSizes) throws IOException {
+      POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(filename));
+      displayDirectory(fs.getRoot(), "", withSizes);
+   }
+
+   public static void displayDirectory(DirectoryNode dir, String indent, boolean withSizes) {
+      System.out.println(indent + dir.getName() + " -");
+      String newIndent = indent + "  ";
+
+      boolean hadChildren = false;
+      for(Iterator<Entry> it = dir.getEntries(); it.hasNext();) {
+         hadChildren = true;
+         Entry entry = it.next();
+         if (entry instanceof DirectoryNode) {
+            displayDirectory((DirectoryNode) entry, newIndent, withSizes);
+         } else {
+            DocumentNode doc = (DocumentNode) entry;
+            String name = doc.getName();
+            String size = "";
+            if (name.charAt(0) < 10) {
+               String altname = "(0x0" + (int) name.charAt(0) + ")" + name.substring(1);
+               name = name.substring(1) + " <" + altname + ">";
+            }
+            if (withSizes) {
+               size = " [" + doc.getSize() + " / 0x" + 
+                      Integer.toHexString(doc.getSize()) + "]";
+            }
+            System.out.println(newIndent + name + size);
+         }
+      }
+      if (!hadChildren) {
+         System.out.println(newIndent + "(no children)");
+      }
+   }
+}
diff --git a/src/java/org/apache/poi/poifs/dev/POIFSViewable.java b/src/java/org/apache/poi/poifs/dev/POIFSViewable.java
index 4580728..c5d7748 100644
--- a/src/java/org/apache/poi/poifs/dev/POIFSViewable.java
+++ b/src/java/org/apache/poi/poifs/dev/POIFSViewable.java
@@ -46,7 +46,7 @@
      */
 
     public Object [] getViewableArray();
-
+    
     /**
      * Get an Iterator of objects, some of which may implement
      * POIFSViewable
@@ -54,7 +54,7 @@
      * @return an Iterator; may not be null, but may have an empty
      * back end store
      */
-
+    @SuppressWarnings("unchecked")
     public Iterator getViewableIterator();
 
     /**
diff --git a/src/java/org/apache/poi/poifs/eventfilesystem/POIFSReader.java b/src/java/org/apache/poi/poifs/eventfilesystem/POIFSReader.java
index 73911e6..5675275 100644
--- a/src/java/org/apache/poi/poifs/eventfilesystem/POIFSReader.java
+++ b/src/java/org/apache/poi/poifs/eventfilesystem/POIFSReader.java
@@ -31,7 +31,7 @@
 import org.apache.poi.poifs.property.PropertyTable;
 import org.apache.poi.poifs.storage.BlockAllocationTableReader;
 import org.apache.poi.poifs.storage.BlockList;
-import org.apache.poi.poifs.storage.HeaderBlockReader;
+import org.apache.poi.poifs.storage.HeaderBlock;
 import org.apache.poi.poifs.storage.RawDataBlockList;
 import org.apache.poi.poifs.storage.SmallBlockTableReader;
 
@@ -75,29 +75,31 @@
         registryClosed = true;
 
         // read the header block from the stream
-        HeaderBlockReader header_block_reader = new HeaderBlockReader(stream);
+        HeaderBlock header_block = new HeaderBlock(stream);
 
         // read the rest of the stream into blocks
-        RawDataBlockList  data_blocks         = new RawDataBlockList(stream, header_block_reader.getBigBlockSize());
+        RawDataBlockList data_blocks = new RawDataBlockList(stream, header_block.getBigBlockSize());
 
         // set up the block allocation table (necessary for the
         // data_blocks to be manageable
-        new BlockAllocationTableReader(header_block_reader.getBATCount(),
-                                       header_block_reader.getBATArray(),
-                                       header_block_reader.getXBATCount(),
-                                       header_block_reader.getXBATIndex(),
+        new BlockAllocationTableReader(header_block.getBigBlockSize(),
+                                       header_block.getBATCount(),
+                                       header_block.getBATArray(),
+                                       header_block.getXBATCount(),
+                                       header_block.getXBATIndex(),
                                        data_blocks);
 
         // get property table from the document
         PropertyTable properties =
-            new PropertyTable(header_block_reader.getPropertyStart(),
-                              data_blocks);
+            new PropertyTable(header_block, data_blocks);
 
         // process documents
         processProperties(SmallBlockTableReader
-            .getSmallDocumentBlocks(data_blocks, properties
-                .getRoot(), header_block_reader
-                    .getSBATStart()), data_blocks, properties.getRoot()
+            .getSmallDocumentBlocks(
+                  header_block.getBigBlockSize(),
+                  data_blocks, properties.getRoot(), 
+                  header_block.getSBATStart()), 
+                  data_blocks, properties.getRoot()
                         .getChildren(), new POIFSDocumentPath());
     }
 
@@ -245,13 +247,13 @@
                     {
                         document =
                             new POIFSDocument(name, small_blocks
-                                .fetchBlocks(startBlock), size);
+                                .fetchBlocks(startBlock, -1), size);
                     }
                     else
                     {
                         document =
                             new POIFSDocument(name, big_blocks
-                                .fetchBlocks(startBlock), size);
+                                .fetchBlocks(startBlock, -1), size);
                     }
                     while (listeners.hasNext())
                     {
@@ -270,11 +272,11 @@
                     // consume the document's data and discard it
                     if (property.shouldUseSmallBlocks())
                     {
-                        small_blocks.fetchBlocks(startBlock);
+                        small_blocks.fetchBlocks(startBlock, -1);
                     }
                     else
                     {
-                        big_blocks.fetchBlocks(startBlock);
+                        big_blocks.fetchBlocks(startBlock, -1);
                     }
                 }
             }
diff --git a/src/java/org/apache/poi/poifs/filesystem/BlockStore.java b/src/java/org/apache/poi/poifs/filesystem/BlockStore.java
new file mode 100644
index 0000000..1da9b6a
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/filesystem/BlockStore.java
@@ -0,0 +1,105 @@
+
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.filesystem;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import org.apache.poi.poifs.storage.BATBlock.BATBlockAndIndex;
+
+/**
+ * This abstract class describes a way to read, store, chain
+ *  and free a series of blocks (be they Big or Small ones)
+ */
+public abstract class BlockStore {
+   /**
+    * Returns the size of the blocks managed through the block store.
+    */
+   protected abstract int getBlockStoreBlockSize();
+   
+    /**
+     * Load the block at the given offset.
+     */
+    protected abstract ByteBuffer getBlockAt(final int offset) throws IOException;
+    
+    /**
+     * Extends the file if required to hold blocks up to
+     *  the specified offset, and return the block from there. 
+     */
+    protected abstract ByteBuffer createBlockIfNeeded(final int offset) throws IOException;
+    
+    /**
+     * Returns the BATBlock that handles the specified offset,
+     *  and the relative index within it
+     */
+    protected abstract BATBlockAndIndex getBATBlockAndIndex(final int offset);
+    
+    /**
+     * Works out what block follows the specified one.
+     */
+    protected abstract int getNextBlock(final int offset);
+    
+    /**
+     * Changes the record of what block follows the specified one.
+     */
+    protected abstract void setNextBlock(final int offset, final int nextBlock);
+    
+    /**
+     * Finds a free block, and returns its offset.
+     * This method will extend the file/stream if needed, and if doing
+     *  so, allocate new FAT blocks to address the extra space.
+     */
+    protected abstract int getFreeBlock() throws IOException;
+    
+    /**
+     * Creates a Detector for loops in the chain 
+     */
+    protected abstract ChainLoopDetector getChainLoopDetector() throws IOException;
+    
+    /**
+     * Used to detect if a chain has a loop in it, so
+     *  we can bail out with an error rather than
+     *  spinning away for ever... 
+     */
+    protected class ChainLoopDetector {
+       private boolean[] used_blocks;
+       protected ChainLoopDetector(long rawSize) {
+          int numBlocks = (int)Math.ceil( rawSize / getBlockStoreBlockSize() );
+          used_blocks = new boolean[numBlocks];
+       }
+       protected void claim(int offset) {
+          if(offset >= used_blocks.length) {
+             // They're writing, and have had new blocks requested
+             //  for the write to proceed. That means they're into
+             //  blocks we've allocated for them, so are safe
+             return;
+          }
+          
+          // Claiming an existing block, ensure there's no loop
+          if(used_blocks[offset]) {
+             throw new IllegalStateException(
+                   "Potential loop detected - Block " + offset + 
+                   " was already claimed but was just requested again"
+             );
+          }
+          used_blocks[offset] = true;
+       }
+    }
+}
+
diff --git a/src/java/org/apache/poi/poifs/filesystem/DirectoryEntry.java b/src/java/org/apache/poi/poifs/filesystem/DirectoryEntry.java
index de8bb1f..844070f 100644
--- a/src/java/org/apache/poi/poifs/filesystem/DirectoryEntry.java
+++ b/src/java/org/apache/poi/poifs/filesystem/DirectoryEntry.java
@@ -33,7 +33,7 @@
  */
 
 public interface DirectoryEntry
-    extends Entry
+    extends Entry, Iterable<Entry>
 {
 
     /**
@@ -47,7 +47,7 @@
      *         implementations of Entry.
      */
 
-    public Iterator getEntries();
+    public Iterator<Entry> getEntries();
 
     /**
      * is this DirectoryEntry empty?
diff --git a/src/java/org/apache/poi/poifs/filesystem/DirectoryNode.java b/src/java/org/apache/poi/poifs/filesystem/DirectoryNode.java
index 6805e51..ea733ea 100644
--- a/src/java/org/apache/poi/poifs/filesystem/DirectoryNode.java
+++ b/src/java/org/apache/poi/poifs/filesystem/DirectoryNode.java
@@ -19,9 +19,14 @@
 
 package org.apache.poi.poifs.filesystem;
 
-import java.io.*;
-
-import java.util.*;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
 
 import org.apache.poi.hpsf.ClassID;
 import org.apache.poi.poifs.dev.POIFSViewable;
@@ -34,17 +39,21 @@
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-
 public class DirectoryNode
     extends EntryNode
-    implements DirectoryEntry, POIFSViewable
+    implements DirectoryEntry, POIFSViewable, Iterable<Entry>
 {
 
     // Map of Entry instances, keyed by their names
-    private Map               _entries;
+    private Map<String,Entry> _byname;
+    // Our list of entries, kept sorted to preserve order
+    private ArrayList<Entry> _entries;
 
+   // Only one of these two will exist
     // the POIFSFileSystem we belong to
-    private POIFSFileSystem   _filesystem;
+    private POIFSFileSystem   _ofilesystem;
+    // the NPOIFSFileSytem we belong to
+    private NPOIFSFileSystem  _nfilesystem; 
 
     // the path described by this document
     private POIFSDocumentPath _path;
@@ -57,11 +66,33 @@
      * @param filesystem the POIFSFileSystem we belong to
      * @param parent the parent of this entry
      */
-
     DirectoryNode(final DirectoryProperty property,
                   final POIFSFileSystem filesystem,
                   final DirectoryNode parent)
     {
+       this(property, parent);
+       _ofilesystem = filesystem;
+    }
+    
+    /**
+     * create a DirectoryNode. This method is not public by design; it
+     * is intended strictly for the internal use of this package
+     *
+     * @param property the DirectoryProperty for this DirectoryEntry
+     * @param nfilesystem the NPOIFSFileSystem we belong to
+     * @param parent the parent of this entry
+     */
+    DirectoryNode(final DirectoryProperty property,
+                  final NPOIFSFileSystem nfilesystem,
+                  final DirectoryNode parent)
+    {
+       this(property, parent);
+       _nfilesystem = nfilesystem;
+    }
+    
+    private DirectoryNode(final DirectoryProperty property,
+                          final DirectoryNode parent)
+    {
         super(property, parent);
         if (parent == null)
         {
@@ -74,26 +105,30 @@
                 property.getName()
             });
         }
-        _filesystem = filesystem;
-        _entries    = new HashMap();
-        Iterator iter = property.getChildren();
+        _byname     = new HashMap<String, Entry>();
+        _entries    = new ArrayList<Entry>();
+        Iterator<Property> iter = property.getChildren();
 
         while (iter.hasNext())
         {
-            Property child     = ( Property ) iter.next();
+            Property child     = iter.next();
             Entry    childNode = null;
 
             if (child.isDirectory())
             {
-                childNode = new DirectoryNode(( DirectoryProperty ) child,
-                                              _filesystem, this);
+                DirectoryProperty childDir = (DirectoryProperty) child;
+                if(_ofilesystem != null) {
+                   childNode = new DirectoryNode(childDir, _ofilesystem, this);
+                } else {
+                   childNode = new DirectoryNode(childDir, _nfilesystem, this);
+                }
             }
             else
             {
-                childNode = new DocumentNode(( DocumentProperty ) child,
-                                             this);
+                childNode = new DocumentNode((DocumentProperty) child, this);
             }
-            _entries.put(childNode.getName(), childNode);
+            _entries.add(childNode);
+            _byname.put(childNode.getName(), childNode);
         }
     }
 
@@ -107,6 +142,22 @@
     }
     
     /**
+     * @return the filesystem that this belongs to
+     */
+    public POIFSFileSystem getFileSystem()
+    {
+        return _ofilesystem; 
+    }
+    
+    /**
+     * @return the filesystem that this belongs to
+     */
+    public NPOIFSFileSystem getNFileSystem()
+    {
+        return _nfilesystem; 
+    }
+    
+    /**
      * open a document in the directory's entry's list of entries
      *
      * @param documentName the name of the document to be opened
@@ -116,19 +167,34 @@
      * @exception IOException if the document does not exist or the
      *            name is that of a DirectoryEntry
      */
-
     public DocumentInputStream createDocumentInputStream(
             final String documentName)
         throws IOException
     {
-        Entry document = getEntry(documentName);
+        return createDocumentInputStream(getEntry(documentName));
+    }
 
-        if (!document.isDocumentEntry())
-        {
-            throw new IOException("Entry '" + documentName
+    /**
+     * open a document in the directory's entry's list of entries
+     *
+     * @param documentEntry the document to be opened
+     *
+     * @return a newly opened DocumentInputStream or NDocumentInputStream
+     *
+     * @exception IOException if the document does not exist or the
+     *            name is that of a DirectoryEntry
+     */
+    public DocumentInputStream createDocumentInputStream(
+            final Entry document)
+        throws IOException
+    {
+        if (!document.isDocumentEntry()) {
+            throw new IOException("Entry '" + document.getName()
                                   + "' is not a DocumentEntry");
         }
-        return new DocumentInputStream(( DocumentEntry ) document);
+        
+        DocumentEntry entry = (DocumentEntry)document;
+        return new DocumentInputStream(entry);
     }
 
     /**
@@ -140,7 +206,6 @@
      *
      * @exception IOException
      */
-
     DocumentEntry createDocument(final POIFSDocument document)
         throws IOException
     {
@@ -148,8 +213,33 @@
         DocumentNode     rval     = new DocumentNode(property, this);
 
         (( DirectoryProperty ) getProperty()).addChild(property);
-        _filesystem.addDocument(document);
-        _entries.put(property.getName(), rval);
+        _ofilesystem.addDocument(document);
+        
+        _entries.add(rval);
+        _byname.put(property.getName(), rval);
+        return rval;
+    }
+
+    /**
+     * create a new DocumentEntry
+     *
+     * @param document the new document
+     *
+     * @return the new DocumentEntry
+     *
+     * @exception IOException
+     */
+    DocumentEntry createDocument(final NPOIFSDocument document)
+        throws IOException
+    {
+        DocumentProperty property = document.getDocumentProperty();
+        DocumentNode     rval     = new DocumentNode(property, this);
+
+        (( DirectoryProperty ) getProperty()).addChild(property);
+        _nfilesystem.addDocument(document);
+        
+        _entries.add(rval);
+        _byname.put(property.getName(), rval);
         return rval;
     }
 
@@ -161,11 +251,10 @@
      *
      * @return true if the operation succeeded, else false
      */
-
     boolean changeName(final String oldName, final String newName)
     {
         boolean   rval  = false;
-        EntryNode child = ( EntryNode ) _entries.get(oldName);
+        EntryNode child = ( EntryNode ) _byname.get(oldName);
 
         if (child != null)
         {
@@ -173,8 +262,8 @@
                 .changeName(child.getProperty(), newName);
             if (rval)
             {
-                _entries.remove(oldName);
-                _entries.put(child.getProperty().getName(), child);
+                _byname.remove(oldName);
+                _byname.put(child.getProperty().getName(), child);
             }
         }
         return rval;
@@ -196,8 +285,14 @@
 
         if (rval)
         {
-            _entries.remove(entry.getName());
-            _filesystem.remove(entry);
+            _entries.remove(entry);
+        	   _byname.remove(entry.getName());
+        	   
+        	   if(_ofilesystem != null) {
+               _ofilesystem.remove(entry);
+        	   } else {
+        	      _nfilesystem.remove(entry);
+        	   }
         }
         return rval;
     }
@@ -215,9 +310,9 @@
      *         implementations of Entry.
      */
 
-    public Iterator getEntries()
+    public Iterator<Entry> getEntries()
     {
-        return _entries.values().iterator();
+        return _entries.iterator();
     }
 
     /**
@@ -263,7 +358,7 @@
 
         if (name != null)
         {
-            rval = ( Entry ) _entries.get(name);
+            rval = _byname.get(name);
         }
         if (rval == null)
         {
@@ -326,13 +421,20 @@
     public DirectoryEntry createDirectory(final String name)
         throws IOException
     {
+        DirectoryNode rval;
         DirectoryProperty property = new DirectoryProperty(name);
-        DirectoryNode     rval     = new DirectoryNode(property, _filesystem,
-                                         this);
+        
+        if(_ofilesystem != null) {
+           rval = new DirectoryNode(property, _ofilesystem, this);
+           _ofilesystem.addDirectory(property);
+        } else {
+           rval = new DirectoryNode(property, _nfilesystem, this);
+           _nfilesystem.addDirectory(property);
+        }
 
         (( DirectoryProperty ) getProperty()).addChild(property);
-        _filesystem.addDirectory(property);
-        _entries.put(name, rval);
+        _entries.add(rval);
+        _byname.put(name, rval);
         return rval;
     }
 
@@ -410,15 +512,13 @@
      * @return an Iterator; may not be null, but may have an empty
      * back end store
      */
-
+    @SuppressWarnings("unchecked")
     public Iterator getViewableIterator()
     {
         List components = new ArrayList();
 
         components.add(getProperty());
-        SortedMap sortedEntries = new TreeMap(_entries);
-        Iterator  iter          = sortedEntries.values().iterator();
-
+        Iterator<Entry> iter = _entries.iterator();
         while (iter.hasNext())
         {
             components.add(iter.next());
@@ -451,6 +551,13 @@
         return getName();
     }
 
+    /**
+     * Returns an Iterator over all the entries
+     */
+    public Iterator<Entry> iterator() {
+        return getEntries(); 
+    }
+
     /* **********  END  begin implementation of POIFSViewable ********** */
 }   // end public class DirectoryNode
 
diff --git a/src/java/org/apache/poi/poifs/filesystem/DocumentInputStream.java b/src/java/org/apache/poi/poifs/filesystem/DocumentInputStream.java
index 786a8d2..d39582f 100644
--- a/src/java/org/apache/poi/poifs/filesystem/DocumentInputStream.java
+++ b/src/java/org/apache/poi/poifs/filesystem/DocumentInputStream.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,437 +14,156 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.filesystem;
 
-import java.io.*;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.apache.poi.util.LittleEndianInput;
 
 /**
  * This class provides methods to read a DocumentEntry managed by a
- * Filesystem instance.
- *
- * @author Marc Johnson (mjohnson at apache dot org)
+ *  {@link POIFSFileSystem} or {@link NPOIFSFileSystem} instance.
+ * It creates the appropriate one, and delegates, allowing us to
+ *  work transparently with the two.
  */
+public class DocumentInputStream extends InputStream implements LittleEndianInput {
+	/** returned by read operations if we're at end of document */
+	protected static final int EOF = -1;
 
-public class DocumentInputStream
-    extends InputStream
-{
+	protected static final int SIZE_SHORT = 2;
+	protected static final int SIZE_INT = 4;
+	protected static final int SIZE_LONG = 8;
+	
+	private DocumentInputStream delegate;
+	
+	/** For use by downstream implementations */
+	protected DocumentInputStream() {}
 
-    // current offset into the Document
-    private int              _current_offset;
+	/**
+	 * Create an InputStream from the specified DocumentEntry
+	 * 
+	 * @param document the DocumentEntry to be read
+	 * 
+	 * @exception IOException if the DocumentEntry cannot be opened (like, maybe it has
+	 *                been deleted?)
+	 */
+	public DocumentInputStream(DocumentEntry document) throws IOException {
+	   if (!(document instanceof DocumentNode)) {
+	      throw new IOException("Cannot open internal document storage");
+	   }
+	   DocumentNode documentNode = (DocumentNode)document;
+	   DirectoryNode parentNode = (DirectoryNode)document.getParent();
 
-    // current marked offset into the Document (used by mark and
-    // reset)
-    private int              _marked_offset;
+	   if(documentNode.getDocument() != null) {
+	      delegate = new ODocumentInputStream(document);
+	   } else if(parentNode.getFileSystem() != null) {
+	      delegate = new ODocumentInputStream(document);
+	   } else if(parentNode.getNFileSystem() != null) {
+	      delegate = new NDocumentInputStream(document);
+	   } else {
+	      throw new IOException("No FileSystem bound on the parent, can't read contents");
+	   }
+	}
 
-    // the Document's size
-    private int              _document_size;
+	/**
+	 * Create an InputStream from the specified Document
+	 * 
+	 * @param document the Document to be read
+	 */
+	public DocumentInputStream(POIFSDocument document) {
+	   delegate = new ODocumentInputStream(document);
+	}
 
-    // have we been closed?
-    private boolean          _closed;
+   /**
+    * Create an InputStream from the specified Document
+    * 
+    * @param document the Document to be read
+    */
+   public DocumentInputStream(NPOIFSDocument document) {
+      delegate = new NDocumentInputStream(document);
+   }
 
-    // the actual Document
-    private POIFSDocument    _document;
+	public int available() {
+	   return delegate.available();
+	}
 
-    // buffer used to read one byte at a time
-    private byte[]           _tiny_buffer;
+	public void close() {
+	   delegate.close();
+	}
 
-    // returned by read operations if we're at end of document
-    static private final int EOD = -1;
+	public void mark(int ignoredReadlimit) {
+		delegate.mark(ignoredReadlimit);
+	}
 
-    /**
-     * Create an InputStream from the specified DocumentEntry
-     *
-     * @param document the DocumentEntry to be read
-     *
-     * @exception IOException if the DocumentEntry cannot be opened
-     *            (like, maybe it has been deleted?)
-     */
+	/**
+	 * Tests if this input stream supports the mark and reset methods.
+	 * 
+	 * @return <code>true</code> always
+	 */
+	public boolean markSupported() {
+		return true;
+	}
 
-    public DocumentInputStream(final DocumentEntry document)
-        throws IOException
-    {
-        _current_offset = 0;
-        _marked_offset  = 0;
-        _document_size  = document.getSize();
-        _closed         = false;
-        _tiny_buffer    = null;
-        if (document instanceof DocumentNode)
-        {
-            _document = (( DocumentNode ) document).getDocument();
-        }
-        else
-        {
-            throw new IOException("Cannot open internal document storage");
-        }
-    }
+	public int read() throws IOException {
+	   return delegate.read();
+	}
 
-    /**
-     * Create an InputStream from the specified Document
-     *
-     * @param document the Document to be read
-     *
-     * @exception IOException if the DocumentEntry cannot be opened
-     *            (like, maybe it has been deleted?)
-     */
+	public int read(byte[] b) throws IOException {
+		return read(b, 0, b.length);
+	}
 
-    public DocumentInputStream(final POIFSDocument document)
-        throws IOException
-    {
-        _current_offset = 0;
-        _marked_offset  = 0;
-        _document_size  = document.getSize();
-        _closed         = false;
-        _tiny_buffer    = null;
-        _document       = document;
-    }
+	public int read(byte[] b, int off, int len) throws IOException {
+	   return delegate.read(b, off, len);
+	}
 
-    /**
-     * Returns the number of bytes that can be read (or skipped over)
-     * from this input stream without blocking by the next caller of a
-     * method for this input stream. The next caller might be the same
-     * thread or or another thread.
-     *
-     * @return the number of bytes that can be read from this input
-     *         stream without blocking.
-     *
-     * @exception IOException on error (such as the stream has been
-     *            closed)
-     */
+	/**
+	 * Repositions this stream to the position at the time the mark() method was
+	 * last called on this input stream. If mark() has not been called this
+	 * method repositions the stream to its beginning.
+	 */
+	public void reset() {
+	   delegate.reset();
+	}
 
-    public int available()
-        throws IOException
-    {
-        dieIfClosed();
-        return _document_size - _current_offset;
-    }
+	public long skip(long n) throws IOException {
+	   return delegate.skip(n);
+	}
 
-    /**
-     * Closes this input stream and releases any system resources
-     * associated with the stream.
-     *
-     * @exception IOException
-     */
+	public byte readByte() {
+	   return delegate.readByte();
+	}
 
-    public void close()
-        throws IOException
-    {
-        _closed = true;
-    }
+	public double readDouble() {
+	   return delegate.readDouble();
+	}
 
-    /**
-     * Marks the current position in this input stream. A subsequent
-     * call to the reset method repositions this stream at the last
-     * marked position so that subsequent reads re-read the same
-     * bytes.
-     * <p>
-     * The readlimit arguments tells this input stream to allow that
-     * many bytes to be read before the mark position gets
-     * invalidated. This implementation, however, does not care.
-     * <p>
-     * The general contract of mark is that, if the method
-     * markSupported returns true, the stream somehow remembers all
-     * the bytes read after the call to mark and stands ready to
-     * supply those same bytes again if and whenever the method reset
-     * is called. However, the stream is not required to remember any
-     * data at all if more than readlimit bytes are read from the
-     * stream before reset is called. But this stream will.
-     *
-     * @param ignoredReadlimit the maximum limit of bytes that can be
-     *                         read before the mark position becomes
-     *                         invalid. Ignored by this
-     *                         implementation.
-     */
+	public short readShort() {
+		return (short) readUShort();
+	}
 
-    public void mark(int ignoredReadlimit)
-    {
-        _marked_offset = _current_offset;
-    }
+   public void readFully(byte[] buf) {
+      readFully(buf, 0, buf.length);
+   }
 
-    /**
-     * Tests if this input stream supports the mark and reset methods.
-     *
-     * @return true
-     */
+	public void readFully(byte[] buf, int off, int len) {
+	   delegate.readFully(buf, off, len);
+	}
 
-    public boolean markSupported()
-    {
-        return true;
-    }
+	public long readLong() {
+	   return delegate.readLong();
+	}
 
-    /**
-     * Reads the next byte of data from the input stream. The value
-     * byte is returned as an int in the range 0 to 255. If no byte is
-     * available because the end of the stream has been reached, the
-     * value -1 is returned. The definition of this method in
-     * java.io.InputStream allows this method to block, but it won't.
-     *
-     * @return the next byte of data, or -1 if the end of the stream
-     *         is reached.
-     *
-     * @exception IOException
-     */
+	public int readInt() {
+	   return delegate.readInt();
+	}
 
-    public int read()
-        throws IOException
-    {
-        dieIfClosed();
-        if (atEOD())
-        {
-            return EOD;
-        }
-        if (_tiny_buffer == null)
-        {
-            _tiny_buffer = new byte[ 1 ];
-        }
-        _document.read(_tiny_buffer, _current_offset++);
-        return ((int)_tiny_buffer[ 0 ]) & 0x000000FF;
-    }
+	public int readUShort() {
+	   return delegate.readUShort();
+	}
 
-    /**
-     * Reads some number of bytes from the input stream and stores
-     * them into the buffer array b. The number of bytes actually read
-     * is returned as an integer. The definition of this method in
-     * java.io.InputStream allows this method to block, but it won't.
-     * <p>
-     * If b is null, a NullPointerException is thrown. If the length
-     * of b is zero, then no bytes are read and 0 is returned;
-     * otherwise, there is an attempt to read at least one byte. If no
-     * byte is available because the stream is at end of file, the
-     * value -1 is returned; otherwise, at least one byte is read and
-     * stored into b.
-     * <p>
-     * The first byte read is stored into element b[0], the next one
-     * into b[1], and so on. The number of bytes read is, at most,
-     * equal to the length of b. Let k be the number of bytes actually
-     * read; these bytes will be stored in elements b[0] through
-     * b[k-1], leaving elements b[k] through b[b.length-1] unaffected.
-     * <p>
-     * If the first byte cannot be read for any reason other than end
-     * of file, then an IOException is thrown. In particular, an
-     * IOException is thrown if the input stream has been closed.
-     * <p>
-     * The read(b) method for class InputStream has the same effect as:
-     * <p>
-     * <code>read(b, 0, b.length)</code>
-     *
-     * @param b the buffer into which the data is read.
-     *
-     * @return the total number of bytes read into the buffer, or -1
-     *         if there is no more data because the end of the stream
-     *         has been reached.
-     *
-     * @exception IOException
-     * @exception NullPointerException
-     */
-
-    public int read(final byte [] b)
-        throws IOException, NullPointerException
-    {
-        return read(b, 0, b.length);
-    }
-
-    /**
-     * Reads up to len bytes of data from the input stream into an
-     * array of bytes. An attempt is made to read as many as len
-     * bytes, but a smaller number may be read, possibly zero. The
-     * number of bytes actually read is returned as an integer.
-     * <p>
-     * The definition of this method in java.io.InputStream allows it
-     * to block, but it won't.
-     * <p>
-     * If b is null, a NullPointerException is thrown.
-     * <p>
-     * If off is negative, or len is negative, or off+len is greater
-     * than the length of the array b, then an
-     * IndexOutOfBoundsException is thrown.
-     * <p>
-     * If len is zero, then no bytes are read and 0 is returned;
-     * otherwise, there is an attempt to read at least one byte. If no
-     * byte is available because the stream is at end of file, the
-     * value -1 is returned; otherwise, at least one byte is read and
-     * stored into b.
-     * <p>
-     * The first byte read is stored into element b[off], the next one
-     * into b[off+1], and so on. The number of bytes read is, at most,
-     * equal to len. Let k be the number of bytes actually read; these
-     * bytes will be stored in elements b[off] through b[off+k-1],
-     * leaving elements b[off+k] through b[off+len-1] unaffected.
-     * <p>
-     * In every case, elements b[0] through b[off] and elements
-     * b[off+len] through b[b.length-1] are unaffected.
-     * <p>
-     * If the first byte cannot be read for any reason other than end
-     * of file, then an IOException is thrown. In particular, an
-     * IOException is thrown if the input stream has been closed.
-     *
-     * @param b the buffer into which the data is read.
-     * @param off the start offset in array b at which the data is
-     *            written.
-     * @param len the maximum number of bytes to read.
-     *
-     * @return the total number of bytes read into the buffer, or -1
-     *         if there is no more data because the end of the stream
-     *         has been reached.
-     *
-     * @exception IOException
-     * @exception NullPointerException
-     * @exception IndexOutOfBoundsException
-     */
-
-    public int read(final byte [] b, final int off, final int len)
-        throws IOException, NullPointerException, IndexOutOfBoundsException
-    {
-        dieIfClosed();
-        if (b == null)
-        {
-            throw new NullPointerException("buffer is null");
-        }
-        if ((off < 0) || (len < 0) || (b.length < (off + len)))
-        {
-            throw new IndexOutOfBoundsException(
-                "can't read past buffer boundaries");
-        }
-        if (len == 0)
-        {
-            return 0;
-        }
-        if (atEOD())
-        {
-            return EOD;
-        }
-        int limit = Math.min(available(), len);
-
-        if ((off == 0) && (limit == b.length))
-        {
-            _document.read(b, _current_offset);
-        }
-        else
-        {
-            byte[] buffer = new byte[ limit ];
-
-            _document.read(buffer, _current_offset);
-            System.arraycopy(buffer, 0, b, off, limit);
-        }
-        _current_offset += limit;
-        return limit;
-    }
-
-    /**
-     * Repositions this stream to the position at the time the mark
-     * method was last called on this input stream.
-     * <p>
-     * The general contract of reset is:
-     * <p>
-     * <ul>
-     *    <li>
-     *        If the method markSupported returns true, then:
-     *        <ul>
-     *            <li>
-     *                If the method mark has not been called since the
-     *                stream was created, or the number of bytes read
-     *                from the stream since mark was last called is
-     *                larger than the argument to mark at that last
-     *                call, then an IOException might be thrown.
-     *            </li>
-     *            <li>
-     *                If such an IOException is not thrown, then the
-     *                stream is reset to a state such that all the
-     *                bytes read since the most recent call to mark
-     *                (or since the start of the file, if mark has not
-     *                been called) will be resupplied to subsequent
-     *                callers of the read method, followed by any
-     *                bytes that otherwise would have been the next
-     *                input data as of the time of the call to reset.
-     *             </li>
-     *         </ul>
-     *     </li>
-     *     <li>
-     *         If the method markSupported returns false, then:
-     *         <ul>
-     *             <li>
-     *                 The call to reset may throw an IOException.
-     *             </li>
-     *             <li>
-     *                 If an IOException is not thrown, then the
-     *                 stream is reset to a fixed state that depends
-     *                 on the particular type of the input and how it
-     *                 was created. The bytes that will be supplied to
-     *                 subsequent callers of the read method depend on
-     *                 the particular type of the input stream.
-     *             </li>
-     *         </ul>
-     *     </li>
-     * </ul>
-     * <p>
-     * All well and good ... this class's markSupported method returns
-     * true and this method does not care whether you've called mark
-     * at all, or whether you've exceeded the number of bytes
-     * specified in the last call to mark. We're basically walking a
-     * byte array ... mark and reset to your heart's content.
-     */
-
-    public void reset()
-    {
-        _current_offset = _marked_offset;
-    }
-
-    /**
-     * Skips over and discards n bytes of data from this input
-     * stream. The skip method may, for a variety of reasons, end up
-     * skipping over some smaller number of bytes, possibly 0. This
-     * may result from any of a number of conditions; reaching end of
-     * file before n bytes have been skipped is only one
-     * possibility. The actual number of bytes skipped is returned. If
-     * n is negative, no bytes are skipped.
-     *
-     * @param n the number of bytes to be skipped.
-     *
-     * @return the actual number of bytes skipped.
-     *
-     * @exception IOException
-     */
-
-    public long skip(final long n)
-        throws IOException
-    {
-        dieIfClosed();
-        if (n < 0)
-        {
-            return 0;
-        }
-        int new_offset = _current_offset + ( int ) n;
-
-        if (new_offset < _current_offset)
-        {
-
-            // wrap around in converting a VERY large long to an int
-            new_offset = _document_size;
-        }
-        else if (new_offset > _document_size)
-        {
-            new_offset = _document_size;
-        }
-        long rval = new_offset - _current_offset;
-
-        _current_offset = new_offset;
-        return rval;
-    }
-
-    private void dieIfClosed()
-        throws IOException
-    {
-        if (_closed)
-        {
-            throw new IOException(
-                "cannot perform requested operation on a closed stream");
-        }
-    }
-
-    private boolean atEOD()
-    {
-        return _current_offset == _document_size;
-    }
-}   // end public class DocumentInputStream
-
+	public int readUByte() {
+	   return delegate.readUByte();
+	}
+}
diff --git a/src/java/org/apache/poi/poifs/filesystem/DocumentOutputStream.java b/src/java/org/apache/poi/poifs/filesystem/DocumentOutputStream.java
index 4e669a8..fd1ffa9 100644
--- a/src/java/org/apache/poi/poifs/filesystem/DocumentOutputStream.java
+++ b/src/java/org/apache/poi/poifs/filesystem/DocumentOutputStream.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +14,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.filesystem;
 
@@ -30,12 +28,10 @@
  * @author Marc Johnson (mjohnson at apache dot org)
  */
 
-public class DocumentOutputStream
-    extends OutputStream
-{
-    private OutputStream stream;
-    private int          limit;
-    private int          written;
+public final class DocumentOutputStream extends OutputStream {
+    private final OutputStream _stream;
+    private final int          _limit;
+    private int          _written;
 
     /**
      * Create a DocumentOutputStream
@@ -44,12 +40,10 @@
      *               read
      * @param limit the maximum number of bytes that can be written
      */
-
-    DocumentOutputStream(final OutputStream stream, final int limit)
-    {
-        this.stream  = stream;
-        this.limit   = limit;
-        this.written = 0;
+    DocumentOutputStream(OutputStream stream, int limit) {
+        _stream  = stream;
+        _limit   = limit;
+        _written = 0;
     }
 
     /**
@@ -64,12 +58,11 @@
      *                        output stream has been closed, or if the
      *                        writer tries to write too much data.
      */
-
-    public void write(final int b)
+    public void write(int b)
         throws IOException
     {
         limitCheck(1);
-        stream.write(b);
+        _stream.write(b);
     }
 
     /**
@@ -79,8 +72,7 @@
      * @param b the data.
      * @exception IOException if an I/O error occurs.
      */
-
-    public void write(final byte b[])
+    public void write(byte b[])
         throws IOException
     {
         write(b, 0, b.length);
@@ -106,12 +98,11 @@
      *                        output stream is closed or if the writer
      *                        tries to write too many bytes.
      */
-
-    public void write(final byte b[], final int off, final int len)
+    public void write(byte b[], int off, int len)
         throws IOException
     {
         limitCheck(len);
-        stream.write(b, off, len);
+        _stream.write(b, off, len);
     }
 
     /**
@@ -120,11 +111,10 @@
      *
      * @exception IOException if an I/O error occurs.
      */
-
     public void flush()
         throws IOException
     {
-        stream.flush();
+        _stream.flush();
     }
 
     /**
@@ -135,10 +125,7 @@
      *
      * @exception IOException if an I/O error occurs.
      */
-
-    public void close()
-        throws IOException
-    {
+    public void close() {
 
         // ignore this call
     }
@@ -152,27 +139,25 @@
      *
      * @exception IOException on I/O error
      */
-
-    void writeFiller(final int totalLimit, final byte fill)
+    void writeFiller(int totalLimit, byte fill)
         throws IOException
     {
-        if (totalLimit > written)
+        if (totalLimit > _written)
         {
-            byte[] filler = new byte[ totalLimit - written ];
+            byte[] filler = new byte[ totalLimit - _written ];
 
             Arrays.fill(filler, fill);
-            stream.write(filler);
+            _stream.write(filler);
         }
     }
 
-    private void limitCheck(final int toBeWritten)
+    private void limitCheck(int toBeWritten)
         throws IOException
     {
-        if ((written + toBeWritten) > limit)
+        if ((_written + toBeWritten) > _limit)
         {
             throw new IOException("tried to write too much data");
         }
-        written += toBeWritten;
+        _written += toBeWritten;
     }
-}   // end public class DocumentOutputStream
-
+}
diff --git a/src/java/org/apache/poi/poifs/filesystem/NDocumentInputStream.java b/src/java/org/apache/poi/poifs/filesystem/NDocumentInputStream.java
new file mode 100644
index 0000000..602cb5f
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/filesystem/NDocumentInputStream.java
@@ -0,0 +1,303 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.filesystem;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+import org.apache.poi.poifs.property.DocumentProperty;
+import org.apache.poi.util.LittleEndian;
+
+/**
+ * This class provides methods to read a DocumentEntry managed by a
+ * {@link NPOIFSFileSystem} instance.
+ */
+public final class NDocumentInputStream extends DocumentInputStream {
+	/** current offset into the Document */
+	private int _current_offset;
+	/** current block count */
+	private int _current_block_count;
+
+	/** current marked offset into the Document (used by mark and reset) */
+	private int _marked_offset;
+	/** and the block count for it */
+   private int _marked_offset_count;
+
+	/** the Document's size */
+	private int _document_size;
+
+	/** have we been closed? */
+	private boolean _closed;
+
+	/** the actual Document */
+	private NPOIFSDocument _document;
+	
+	private Iterator<ByteBuffer> _data;
+	private ByteBuffer _buffer;
+
+	/**
+	 * Create an InputStream from the specified DocumentEntry
+	 * 
+	 * @param document the DocumentEntry to be read
+	 * 
+	 * @exception IOException if the DocumentEntry cannot be opened (like, maybe it has
+	 *                been deleted?)
+	 */
+	public NDocumentInputStream(DocumentEntry document) throws IOException {
+		if (!(document instanceof DocumentNode)) {
+			throw new IOException("Cannot open internal document storage");
+		}
+		_current_offset = 0;
+		_current_block_count = 0;
+		_marked_offset = 0;
+		_marked_offset_count = 0;
+		_document_size = document.getSize();
+		_closed = false;
+		
+      DocumentNode doc = (DocumentNode)document;
+		DocumentProperty property = (DocumentProperty)doc.getProperty();
+		_document = new NPOIFSDocument(
+		      property, 
+		      ((DirectoryNode)doc.getParent()).getNFileSystem()
+		);
+		_data = _document.getBlockIterator();
+	}
+
+	/**
+	 * Create an InputStream from the specified Document
+	 * 
+	 * @param document the Document to be read
+	 */
+	public NDocumentInputStream(NPOIFSDocument document) {
+      _current_offset = 0;
+      _current_block_count = 0;
+      _marked_offset = 0;
+      _marked_offset_count = 0;
+		_document_size = document.getSize();
+		_closed = false;
+		_document = document;
+      _data = _document.getBlockIterator();
+	}
+
+	@Override
+	public int available() {
+		if (_closed) {
+			throw new IllegalStateException("cannot perform requested operation on a closed stream");
+		}
+		return _document_size - _current_offset;
+	}
+
+   @Override
+	public void close() {
+		_closed = true;
+	}
+
+   @Override
+	public void mark(int ignoredReadlimit) {
+		_marked_offset = _current_offset;
+		_marked_offset_count = _current_block_count;
+	}
+
+   @Override
+	public int read() throws IOException {
+		dieIfClosed();
+		if (atEOD()) {
+			return EOF;
+		}
+		byte[] b = new byte[1];
+		int result = read(b, 0, 1);
+		if(result >= 0) {
+		   if(b[0] < 0) {
+		      return b[0]+256;
+		   }
+		   return b[0];
+		}
+		return result;
+	}
+
+   @Override
+	public int read(byte[] b, int off, int len) throws IOException {
+		dieIfClosed();
+		if (b == null) {
+			throw new IllegalArgumentException("buffer must not be null");
+		}
+		if (off < 0 || len < 0 || b.length < off + len) {
+			throw new IndexOutOfBoundsException("can't read past buffer boundaries");
+		}
+		if (len == 0) {
+			return 0;
+		}
+		if (atEOD()) {
+			return EOF;
+		}
+		int limit = Math.min(available(), len);
+		readFully(b, off, limit);
+		return limit;
+	}
+
+	/**
+	 * Repositions this stream to the position at the time the mark() method was
+	 * last called on this input stream. If mark() has not been called this
+	 * method repositions the stream to its beginning.
+	 */
+   @Override
+	public void reset() {
+	   // Special case for reset to the start
+	   if(_marked_offset == 0 && _marked_offset_count == 0) {
+	      _current_block_count = _marked_offset_count;
+	      _current_offset = _marked_offset;
+	      _data = _document.getBlockIterator();
+	      _buffer = null;
+	      return;
+	   }
+	   
+		// Start again, then wind on to the required block
+		_data = _document.getBlockIterator();
+		_current_offset = 0;
+		for(int i=0; i<_marked_offset_count; i++) {
+		   _buffer = _data.next();
+		   _current_offset += _buffer.remaining();
+		}
+		
+      _current_block_count = _marked_offset_count;
+      
+      // Do we need to position within it?
+      if(_current_offset != _marked_offset) {
+   		// Grab the right block
+         _buffer = _data.next();
+         _current_block_count++;
+         
+   		// Skip to the right place in it
+   		_buffer.position(_marked_offset - _current_offset);
+      }
+
+      // All done
+      _current_offset = _marked_offset;
+	}
+
+   @Override
+	public long skip(long n) throws IOException {
+		dieIfClosed();
+		if (n < 0) {
+			return 0;
+		}
+		int new_offset = _current_offset + (int) n;
+
+		if (new_offset < _current_offset) {
+			// wrap around in converting a VERY large long to an int
+			new_offset = _document_size;
+		} else if (new_offset > _document_size) {
+			new_offset = _document_size;
+		}
+		
+		long rval = new_offset - _current_offset;
+		
+		// TODO Do this better
+		byte[] skip = new byte[(int)rval];
+		readFully(skip);
+		return rval;
+	}
+
+	private void dieIfClosed() throws IOException {
+		if (_closed) {
+			throw new IOException("cannot perform requested operation on a closed stream");
+		}
+	}
+
+	private boolean atEOD() {
+		return _current_offset == _document_size;
+	}
+
+	private void checkAvaliable(int requestedSize) {
+		if (_closed) {
+			throw new IllegalStateException("cannot perform requested operation on a closed stream");
+		}
+		if (requestedSize > _document_size - _current_offset) {
+			throw new RuntimeException("Buffer underrun - requested " + requestedSize
+					+ " bytes but " + (_document_size - _current_offset) + " was available");
+		}
+	}
+
+   @Override
+	public void readFully(byte[] buf, int off, int len) {
+		checkAvaliable(len);
+
+		int read = 0;
+		while(read < len) {
+		   if(_buffer == null || _buffer.remaining() == 0) {
+		      _current_block_count++;
+		      _buffer = _data.next();
+		   }
+		   
+		   int limit = Math.min(len-read, _buffer.remaining());
+		   _buffer.get(buf, off+read, limit);
+         _current_offset += limit;
+		   read += limit;
+		}
+	}
+
+   @Override
+   public byte readByte() {
+      return (byte) readUByte();
+   }
+
+   @Override
+   public double readDouble() {
+      return Double.longBitsToDouble(readLong());
+   }
+
+   @Override
+	public long readLong() {
+		checkAvaliable(SIZE_LONG);
+		byte[] data = new byte[SIZE_LONG];
+		readFully(data, 0, SIZE_LONG);
+		return LittleEndian.getLong(data, 0);
+	}
+
+   @Override
+   public short readShort() {
+      return (short) readUShort();
+   }
+
+   @Override
+	public int readInt() {
+		checkAvaliable(SIZE_INT);
+      byte[] data = new byte[SIZE_INT];
+      readFully(data, 0, SIZE_INT);
+      return LittleEndian.getInt(data);
+	}
+
+   @Override
+	public int readUShort() {
+		checkAvaliable(SIZE_SHORT);
+      byte[] data = new byte[SIZE_SHORT];
+      readFully(data, 0, SIZE_SHORT);
+      return LittleEndian.getShort(data);
+	}
+
+   @Override
+	public int readUByte() {
+		checkAvaliable(1);
+      byte[] data = new byte[1];
+      readFully(data, 0, 1);
+      if(data[0] >= 0)
+         return data[0];
+      return data[0] + 256;
+	}
+}
diff --git a/src/java/org/apache/poi/poifs/filesystem/NPOIFSDocument.java b/src/java/org/apache/poi/poifs/filesystem/NPOIFSDocument.java
new file mode 100644
index 0000000..09536d4
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/filesystem/NPOIFSDocument.java
@@ -0,0 +1,193 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.filesystem;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.Collections;
+import java.util.Iterator;
+
+import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.dev.POIFSViewable;
+import org.apache.poi.poifs.property.DocumentProperty;
+import org.apache.poi.util.HexDump;
+import org.apache.poi.util.IOUtils;
+
+/**
+ * This class manages a document in the NIO POIFS filesystem.
+ * This is the {@link NPOIFSFileSystem} version.
+ */
+public final class NPOIFSDocument implements POIFSViewable {
+   private DocumentProperty _property;
+
+   private NPOIFSFileSystem _filesystem;
+   private NPOIFSStream _stream;
+   private int _block_size;
+	
+   /**
+    * Constructor for an existing Document 
+    */
+   public NPOIFSDocument(DocumentProperty property, NPOIFSFileSystem filesystem) 
+      throws IOException
+   {
+      this._property = property;
+      this._filesystem = filesystem;
+
+      if(property.getSize() <= POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE) {
+         _stream = new NPOIFSStream(_filesystem.getMiniStore(), property.getStartBlock());
+         _block_size = _filesystem.getMiniStore().getBlockStoreBlockSize();
+      } else {
+         _stream = new NPOIFSStream(_filesystem, property.getStartBlock());
+         _block_size = _filesystem.getBlockStoreBlockSize();
+      }
+   }
+
+   /**
+    * Constructor for a new Document
+    *
+    * @param name the name of the POIFSDocument
+    * @param stream the InputStream we read data from
+    */
+   public NPOIFSDocument(String name, NPOIFSFileSystem filesystem, InputStream stream) 
+      throws IOException 
+   {
+      this._filesystem = filesystem;
+
+      // Buffer the contents into memory. This is a bit icky...
+      // TODO Replace with a buffer up to the mini stream size, then streaming write
+      byte[] contents;
+      if(stream instanceof ByteArrayInputStream) {
+         ByteArrayInputStream bais = (ByteArrayInputStream)stream;
+         contents = new byte[bais.available()];
+         bais.read(contents);
+      } else {
+         ByteArrayOutputStream baos = new ByteArrayOutputStream();
+         IOUtils.copy(stream, baos);
+         contents = baos.toByteArray();
+      }
+
+      // Do we need to store as a mini stream or a full one?
+      if(contents.length <= POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE) {
+         _stream = new NPOIFSStream(filesystem.getMiniStore());
+         _block_size = _filesystem.getMiniStore().getBlockStoreBlockSize();
+      } else {
+         _stream = new NPOIFSStream(filesystem);
+         _block_size = _filesystem.getBlockStoreBlockSize();
+      }
+
+      // Store it
+      _stream.updateContents(contents);
+
+      // And build the property for it
+      this._property = new DocumentProperty(name, contents.length);
+      _property.setStartBlock(_stream.getStartBlock());     
+   }
+   
+   int getDocumentBlockSize() {
+      return _block_size;
+   }
+   
+   Iterator<ByteBuffer> getBlockIterator() {
+      return _stream.getBlockIterator();
+   }
+
+   /**
+    * @return size of the document
+    */
+   public int getSize() {
+      return _property.getSize();
+   }
+
+   /**
+    * @return the instance's DocumentProperty
+    */
+   DocumentProperty getDocumentProperty() {
+      return _property;
+   }
+
+   /**
+    * Get an array of objects, some of which may implement POIFSViewable
+    *
+    * @return an array of Object; may not be null, but may be empty
+    */
+   public Object[] getViewableArray() {
+      Object[] results = new Object[1];
+      String result;
+
+      try {
+         if(getSize() > 0) {
+            // Get all the data into a single array
+            byte[] data = new byte[getSize()];
+            int offset = 0;
+            for(ByteBuffer buffer : _stream) {
+               int length = Math.min(_block_size, data.length-offset); 
+               buffer.get(data, offset, length);
+               offset += length;
+            }
+
+            ByteArrayOutputStream output = new ByteArrayOutputStream();
+            HexDump.dump(data, 0, output, 0);
+            result = output.toString();
+         } else {
+            result = "<NO DATA>";
+         }
+      } catch (IOException e) {
+         result = e.getMessage();
+      }
+      results[0] = result;
+      return results;
+   }
+
+   /**
+    * Get an Iterator of objects, some of which may implement POIFSViewable
+    *
+    * @return an Iterator; may not be null, but may have an empty back end
+    *		 store
+    */
+   public Iterator getViewableIterator() {
+      return Collections.EMPTY_LIST.iterator();
+   }
+
+   /**
+    * Give viewers a hint as to whether to call getViewableArray or
+    * getViewableIterator
+    *
+    * @return <code>true</code> if a viewer should call getViewableArray,
+    *		 <code>false</code> if a viewer should call getViewableIterator
+    */
+   public boolean preferArray() {
+      return true;
+   }
+
+   /**
+    * Provides a short description of the object, to be used when a
+    * POIFSViewable object has not provided its contents.
+    *
+    * @return short description
+    */
+   public String getShortDescription() {
+      StringBuffer buffer = new StringBuffer();
+
+      buffer.append("Document: \"").append(_property.getName()).append("\"");
+      buffer.append(" size = ").append(getSize());
+      return buffer.toString();
+   }
+}
diff --git a/src/java/org/apache/poi/poifs/filesystem/NPOIFSFileSystem.java b/src/java/org/apache/poi/poifs/filesystem/NPOIFSFileSystem.java
new file mode 100644
index 0000000..e671d87
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/filesystem/NPOIFSFileSystem.java
@@ -0,0 +1,788 @@
+
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+
+package org.apache.poi.poifs.filesystem;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PushbackInputStream;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.FileChannel;
+import java.nio.channels.ReadableByteChannel;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
+import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.dev.POIFSViewable;
+import org.apache.poi.poifs.nio.ByteArrayBackedDataSource;
+import org.apache.poi.poifs.nio.DataSource;
+import org.apache.poi.poifs.nio.FileBackedDataSource;
+import org.apache.poi.poifs.property.DirectoryProperty;
+import org.apache.poi.poifs.property.NPropertyTable;
+import org.apache.poi.poifs.storage.BATBlock;
+import org.apache.poi.poifs.storage.BlockAllocationTableReader;
+import org.apache.poi.poifs.storage.BlockAllocationTableWriter;
+import org.apache.poi.poifs.storage.HeaderBlock;
+import org.apache.poi.poifs.storage.HeaderBlockConstants;
+import org.apache.poi.poifs.storage.HeaderBlockWriter;
+import org.apache.poi.poifs.storage.BATBlock.BATBlockAndIndex;
+import org.apache.poi.util.CloseIgnoringInputStream;
+import org.apache.poi.util.IOUtils;
+import org.apache.poi.util.LongField;
+import org.apache.poi.util.POILogFactory;
+import org.apache.poi.util.POILogger;
+
+/**
+ * This is the main class of the POIFS system; it manages the entire
+ * life cycle of the filesystem.
+ * This is the new NIO version
+ */
+
+public class NPOIFSFileSystem extends BlockStore
+    implements POIFSViewable
+{
+	private static final POILogger _logger =
+		POILogFactory.getLogger(NPOIFSFileSystem.class);
+
+    /**
+     * Convenience method for clients that want to avoid the auto-close behaviour of the constructor.
+     */
+    public static InputStream createNonClosingInputStream(InputStream is) {
+       return new CloseIgnoringInputStream(is);
+    }
+   
+    private NPOIFSMiniStore _mini_store;
+    private NPropertyTable  _property_table;
+    private List<BATBlock>  _xbat_blocks;
+    private List<BATBlock>  _bat_blocks;
+    private HeaderBlock     _header;
+    private DirectoryNode   _root;
+    
+    private DataSource _data;
+    
+    /**
+     * What big block size the file uses. Most files
+     *  use 512 bytes, but a few use 4096
+     */
+    private POIFSBigBlockSize bigBlockSize = 
+       POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS;
+
+    /**
+     * Constructor, intended for writing
+     */
+    public NPOIFSFileSystem()
+    {
+        _header         = new HeaderBlock(bigBlockSize);
+        _property_table = new NPropertyTable(_header);
+        _mini_store     = new NPOIFSMiniStore(this, _property_table.getRoot(), new ArrayList<BATBlock>(), _header);
+        _xbat_blocks     = new ArrayList<BATBlock>();
+        _bat_blocks     = new ArrayList<BATBlock>();
+        _root           = null;
+    }
+
+    /**
+     * Creates a POIFSFileSystem from a <tt>File</tt>. This uses less memory than
+     *  creating from an <tt>InputStream</tt>.
+     *  
+     * Note that with this constructor, you will need to call {@link #close()}
+     *  when you're done to have the underlying file closed, as the file is
+     *  kept open during normal operation to read the data out. 
+     *  
+     * @param file the File from which to read the data
+     *
+     * @exception IOException on errors reading, or on invalid data
+     */
+    public NPOIFSFileSystem(File file)
+         throws IOException
+    {
+       this();
+       
+       // Open the underlying channel
+       FileChannel channel = (new RandomAccessFile(file, "r")).getChannel();
+       
+       // Get the header
+       ByteBuffer headerBuffer = ByteBuffer.allocate(POIFSConstants.SMALLER_BIG_BLOCK_SIZE);
+       IOUtils.readFully(channel, headerBuffer);
+       
+       // Have the header processed
+       _header = new HeaderBlock(headerBuffer);
+       
+       // Now process the various entries
+       _data = new FileBackedDataSource(channel);
+       readCoreContents();
+    }
+    
+    /**
+     * Create a POIFSFileSystem from an <tt>InputStream</tt>.  Normally the stream is read until
+     * EOF.  The stream is always closed.<p/>
+     *
+     * Some streams are usable after reaching EOF (typically those that return <code>true</code>
+     * for <tt>markSupported()</tt>).  In the unlikely case that the caller has such a stream
+     * <i>and</i> needs to use it after this constructor completes, a work around is to wrap the
+     * stream in order to trap the <tt>close()</tt> call.  A convenience method (
+     * <tt>createNonClosingInputStream()</tt>) has been provided for this purpose:
+     * <pre>
+     * InputStream wrappedStream = POIFSFileSystem.createNonClosingInputStream(is);
+     * HSSFWorkbook wb = new HSSFWorkbook(wrappedStream);
+     * is.reset();
+     * doSomethingElse(is);
+     * </pre>
+     * Note also the special case of <tt>ByteArrayInputStream</tt> for which the <tt>close()</tt>
+     * method does nothing.
+     * <pre>
+     * ByteArrayInputStream bais = ...
+     * HSSFWorkbook wb = new HSSFWorkbook(bais); // calls bais.close() !
+     * bais.reset(); // no problem
+     * doSomethingElse(bais);
+     * </pre>
+     *
+     * @param stream the InputStream from which to read the data
+     *
+     * @exception IOException on errors reading, or on invalid data
+     */
+
+    public NPOIFSFileSystem(InputStream stream)
+        throws IOException
+    {
+        this();
+        
+        ReadableByteChannel channel = null;
+        boolean success = false;
+        
+        try {
+           // Turn our InputStream into something NIO based
+           channel = Channels.newChannel(stream);
+           
+           // Get the header
+           ByteBuffer headerBuffer = ByteBuffer.allocate(POIFSConstants.SMALLER_BIG_BLOCK_SIZE);
+           IOUtils.readFully(channel, headerBuffer);
+           
+           // Have the header processed
+           _header = new HeaderBlock(headerBuffer);
+           
+           // Sanity check the block count
+           BlockAllocationTableReader.sanityCheckBlockCount(_header.getBATCount());
+   
+           // We need to buffer the whole file into memory when
+           //  working with an InputStream.
+           // The max possible size is when each BAT block entry is used
+           int maxSize = BATBlock.calculateMaximumSize(_header); 
+           ByteBuffer data = ByteBuffer.allocate(maxSize);
+           // Copy in the header
+           headerBuffer.position(0);
+           data.put(headerBuffer);
+           data.position(headerBuffer.capacity());
+           // Now read the rest of the stream
+           IOUtils.readFully(channel, data);
+           success = true;
+           
+           // Turn it into a DataSource
+           _data = new ByteArrayBackedDataSource(data.array(), data.position());
+        } finally {
+           // As per the constructor contract, always close the stream
+           if(channel != null)
+              channel.close();
+           closeInputStream(stream, success);
+        }
+        
+        // Now process the various entries
+        readCoreContents();
+    }
+    /**
+     * @param stream the stream to be closed
+     * @param success <code>false</code> if an exception is currently being thrown in the calling method
+     */
+    private void closeInputStream(InputStream stream, boolean success) {
+        try {
+            stream.close();
+        } catch (IOException e) {
+            if(success) {
+                throw new RuntimeException(e);
+            }
+            // else not success? Try block did not complete normally
+            // just print stack trace and leave original ex to be thrown
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Checks that the supplied InputStream (which MUST
+     *  support mark and reset, or be a PushbackInputStream)
+     *  has a POIFS (OLE2) header at the start of it.
+     * If your InputStream does not support mark / reset,
+     *  then wrap it in a PushBackInputStream, then be
+     *  sure to always use that, and not the original!
+     * @param inp An InputStream which supports either mark/reset, or is a PushbackInputStream
+     */
+    public static boolean hasPOIFSHeader(InputStream inp) throws IOException {
+        // We want to peek at the first 8 bytes
+        inp.mark(8);
+
+        byte[] header = new byte[8];
+        IOUtils.readFully(inp, header);
+        LongField signature = new LongField(HeaderBlockConstants._signature_offset, header);
+
+        // Wind back those 8 bytes
+        if(inp instanceof PushbackInputStream) {
+            PushbackInputStream pin = (PushbackInputStream)inp;
+            pin.unread(header);
+        } else {
+            inp.reset();
+        }
+
+        // Did it match the signature?
+        return (signature.get() == HeaderBlockConstants._signature);
+    }
+    
+    /**
+     * Read and process the PropertiesTable and the
+     *  FAT / XFAT blocks, so that we're ready to
+     *  work with the file
+     */
+    private void readCoreContents() throws IOException {
+       // Grab the block size
+       bigBlockSize = _header.getBigBlockSize();
+       
+       // Each block should only ever be used by one of the
+       //  FAT, XFAT or Property Table. Ensure it does
+       ChainLoopDetector loopDetector = getChainLoopDetector();
+       
+       // Read the FAT blocks
+       for(int fatAt : _header.getBATArray()) {
+          readBAT(fatAt, loopDetector);
+       }
+       
+       // Now read the XFAT blocks, and the FATs within them
+       BATBlock xfat; 
+       int nextAt = _header.getXBATIndex();
+       for(int i=0; i<_header.getXBATCount(); i++) {
+          loopDetector.claim(nextAt);
+          ByteBuffer fatData = getBlockAt(nextAt);
+          xfat = BATBlock.createBATBlock(bigBlockSize, fatData);
+          xfat.setOurBlockIndex(nextAt);
+          nextAt = xfat.getValueAt(bigBlockSize.getXBATEntriesPerBlock());
+          _xbat_blocks.add(xfat);
+          
+          for(int j=0; j<bigBlockSize.getXBATEntriesPerBlock(); j++) {
+             int fatAt = xfat.getValueAt(j);
+             if(fatAt == POIFSConstants.UNUSED_BLOCK) break;
+             readBAT(fatAt, loopDetector);
+          }
+       }
+       
+       // We're now able to load steams
+       // Use this to read in the properties
+       _property_table = new NPropertyTable(_header, this);
+       
+       // Finally read the Small Stream FAT (SBAT) blocks
+       BATBlock sfat;
+       List<BATBlock> sbats = new ArrayList<BATBlock>();
+       _mini_store     = new NPOIFSMiniStore(this, _property_table.getRoot(), sbats, _header);
+       nextAt = _header.getSBATStart();
+       for(int i=0; i<_header.getSBATCount(); i++) {
+          loopDetector.claim(nextAt);
+          ByteBuffer fatData = getBlockAt(nextAt);
+          sfat = BATBlock.createBATBlock(bigBlockSize, fatData);
+          sfat.setOurBlockIndex(nextAt);
+          sbats.add(sfat);
+          nextAt = getNextBlock(nextAt);  
+       }
+    }
+    private void readBAT(int batAt, ChainLoopDetector loopDetector) throws IOException {
+       loopDetector.claim(batAt);
+       ByteBuffer fatData = getBlockAt(batAt);
+       BATBlock bat = BATBlock.createBATBlock(bigBlockSize, fatData);
+       bat.setOurBlockIndex(batAt);
+       _bat_blocks.add(bat);
+    }
+    private BATBlock createBAT(int offset, boolean isBAT) throws IOException {
+       // Create a new BATBlock
+       BATBlock newBAT = BATBlock.createEmptyBATBlock(bigBlockSize, !isBAT);
+       newBAT.setOurBlockIndex(offset);
+       // Ensure there's a spot in the file for it
+       ByteBuffer buffer = ByteBuffer.allocate(bigBlockSize.getBigBlockSize());
+       int writeTo = (1+offset) * bigBlockSize.getBigBlockSize(); // Header isn't in BATs
+       _data.write(buffer, writeTo);
+       // All done
+       return newBAT;
+    }
+    
+    /**
+     * Load the block at the given offset.
+     */
+    protected ByteBuffer getBlockAt(final int offset) throws IOException {
+       // The header block doesn't count, so add one
+       long startAt = (offset+1) * bigBlockSize.getBigBlockSize();
+       return _data.read(bigBlockSize.getBigBlockSize(), startAt);
+    }
+    
+    /**
+     * Load the block at the given offset, 
+     *  extending the file if needed
+     */
+    protected ByteBuffer createBlockIfNeeded(final int offset) throws IOException {
+       try {
+          return getBlockAt(offset);
+       } catch(IndexOutOfBoundsException e) {
+          // The header block doesn't count, so add one
+          long startAt = (offset+1) * bigBlockSize.getBigBlockSize();
+          // Allocate and write
+          ByteBuffer buffer = ByteBuffer.allocate(getBigBlockSize());
+          _data.write(buffer, startAt);
+          // Retrieve the properly backed block
+          return getBlockAt(offset);
+       }
+    }
+    
+    /**
+     * Returns the BATBlock that handles the specified offset,
+     *  and the relative index within it
+     */
+    protected BATBlockAndIndex getBATBlockAndIndex(final int offset) {
+       return BATBlock.getBATBlockAndIndex(
+             offset, _header, _bat_blocks
+       );
+    }
+    
+    /**
+     * Works out what block follows the specified one.
+     */
+    protected int getNextBlock(final int offset) {
+       BATBlockAndIndex bai = getBATBlockAndIndex(offset);
+       return bai.getBlock().getValueAt( bai.getIndex() );
+    }
+    
+    /**
+     * Changes the record of what block follows the specified one.
+     */
+    protected void setNextBlock(final int offset, final int nextBlock) {
+       BATBlockAndIndex bai = getBATBlockAndIndex(offset);
+       bai.getBlock().setValueAt(
+             bai.getIndex(), nextBlock
+       );
+    }
+    
+    /**
+     * Finds a free block, and returns its offset.
+     * This method will extend the file if needed, and if doing
+     *  so, allocate new FAT blocks to address the extra space.
+     */
+    protected int getFreeBlock() throws IOException {
+       // First up, do we have any spare ones?
+       int offset = 0;
+       for(int i=0; i<_bat_blocks.size(); i++) {
+          int numSectors = bigBlockSize.getBATEntriesPerBlock();
+
+          // Check this one
+          BATBlock bat = _bat_blocks.get(i);
+          if(bat.hasFreeSectors()) {
+             // Claim one of them and return it
+             for(int j=0; j<numSectors; j++) {
+                int batValue = bat.getValueAt(j);
+                if(batValue == POIFSConstants.UNUSED_BLOCK) {
+                   // Bingo
+                   return offset + j;
+                }
+             }
+          }
+          
+          // Move onto the next BAT
+          offset += numSectors;
+       }
+       
+       // If we get here, then there aren't any free sectors
+       //  in any of the BATs, so we need another BAT
+       BATBlock bat = createBAT(offset, true);
+       bat.setValueAt(0, POIFSConstants.FAT_SECTOR_BLOCK);
+       _bat_blocks.add(bat);
+       
+       // Now store a reference to the BAT in the required place 
+       if(_header.getBATCount() >= 109) {
+          // Needs to come from an XBAT
+          BATBlock xbat = null;
+          for(BATBlock x : _xbat_blocks) {
+             if(x.hasFreeSectors()) {
+                xbat = x;
+                break;
+             }
+          }
+          if(xbat == null) {
+             // Oh joy, we need a new XBAT too...
+             xbat = createBAT(offset+1, false);
+             xbat.setValueAt(0, offset);
+             bat.setValueAt(offset+1, POIFSConstants.DIFAT_SECTOR_BLOCK);
+             
+             // Will go one place higher as XBAT added in
+             offset++;
+             
+             // Chain it
+             if(_xbat_blocks.size() == 0) {
+                _header.setXBATStart(offset);
+             } else {
+                _xbat_blocks.get(_xbat_blocks.size()-1).setValueAt(
+                      bigBlockSize.getXBATEntriesPerBlock(), offset
+                );
+             }
+             _xbat_blocks.add(xbat);
+             _header.setXBATCount(_xbat_blocks.size());
+          }
+          // Allocate us in the XBAT
+          for(int i=0; i<bigBlockSize.getXBATEntriesPerBlock(); i++) {
+             if(xbat.getValueAt(i) == POIFSConstants.UNUSED_BLOCK) {
+                xbat.setValueAt(i, offset);
+             }
+          }
+       } else {
+          // Store us in the header
+          int[] newBATs = new int[_header.getBATCount()+1];
+          System.arraycopy(_header.getBATArray(), 0, newBATs, 0, newBATs.length-1);
+          newBATs[newBATs.length-1] = offset;
+          _header.setBATArray(newBATs);
+       }
+       _header.setBATCount(_bat_blocks.size());
+       
+       // The current offset stores us, but the next one is free
+       return offset+1;
+    }
+    
+    @Override
+    protected ChainLoopDetector getChainLoopDetector() throws IOException {
+      return new ChainLoopDetector(_data.size());
+    }
+
+   /**
+     * For unit testing only! Returns the underlying
+     *  properties table
+     */
+    NPropertyTable _get_property_table() {
+      return _property_table;
+    }
+    
+    /**
+     * Returns the MiniStore, which performs a similar low
+     *  level function to this, except for the small blocks.
+     */
+    public NPOIFSMiniStore getMiniStore() {
+       return _mini_store;
+    }
+
+    /**
+     * add a new POIFSDocument to the FileSytem 
+     *
+     * @param document the POIFSDocument being added
+     */
+    void addDocument(final NPOIFSDocument document)
+    {
+        _property_table.addProperty(document.getDocumentProperty());
+    }
+
+    /**
+     * add a new DirectoryProperty to the FileSystem
+     *
+     * @param directory the DirectoryProperty being added
+     */
+    void addDirectory(final DirectoryProperty directory)
+    {
+        _property_table.addProperty(directory);
+    }
+
+   /**
+     * Create a new document to be added to the root directory
+     *
+     * @param stream the InputStream from which the document's data
+     *               will be obtained
+     * @param name the name of the new POIFSDocument
+     *
+     * @return the new DocumentEntry
+     *
+     * @exception IOException on error creating the new POIFSDocument
+     */
+
+    public DocumentEntry createDocument(final InputStream stream,
+                                        final String name)
+        throws IOException
+    {
+        return getRoot().createDocument(name, stream);
+    }
+
+    /**
+     * create a new DocumentEntry in the root entry; the data will be
+     * provided later
+     *
+     * @param name the name of the new DocumentEntry
+     * @param size the size of the new DocumentEntry
+     * @param writer the writer of the new DocumentEntry
+     *
+     * @return the new DocumentEntry
+     *
+     * @exception IOException
+     */
+
+    public DocumentEntry createDocument(final String name, final int size,
+                                        final POIFSWriterListener writer)
+        throws IOException
+    {
+        return getRoot().createDocument(name, size, writer);
+    }
+
+    /**
+     * create a new DirectoryEntry in the root directory
+     *
+     * @param name the name of the new DirectoryEntry
+     *
+     * @return the new DirectoryEntry
+     *
+     * @exception IOException on name duplication
+     */
+
+    public DirectoryEntry createDirectory(final String name)
+        throws IOException
+    {
+        return getRoot().createDirectory(name);
+    }
+    
+    /**
+     * Write the filesystem out to the open file. Will thrown an
+     *  {@link IllegalArgumentException} if opened from an 
+     *  {@link InputStream}.
+     * 
+     * @exception IOException thrown on errors writing to the stream
+     */
+    public void writeFilesystem() throws IOException
+    {
+       if(_data instanceof FileBackedDataSource) {
+          // Good, correct type
+       } else {
+          throw new IllegalArgumentException(
+                "POIFS opened from an inputstream, so writeFilesystem() may " +
+                "not be called. Use writeFilesystem(OutputStream) instead"
+          );
+       }
+       syncWithDataSource();
+    }
+
+    /**
+     * Write the filesystem out
+     *
+     * @param stream the OutputStream to which the filesystem will be
+     *               written
+     *
+     * @exception IOException thrown on errors writing to the stream
+     */
+
+    public void writeFilesystem(final OutputStream stream)
+        throws IOException
+    {
+       // Have the datasource updated
+       syncWithDataSource();
+       
+       // Now copy the contents to the stream
+       _data.copyTo(stream);
+    }
+    
+    /**
+     * Has our in-memory objects write their state
+     *  to their backing blocks 
+     */
+    private void syncWithDataSource() throws IOException
+    {
+       // HeaderBlock
+       HeaderBlockWriter hbw = new HeaderBlockWriter(_header);
+       hbw.writeBlock( getBlockAt(0) );
+       
+       // BATs
+       for(BATBlock bat : _bat_blocks) {
+          ByteBuffer block = getBlockAt(bat.getOurBlockIndex());
+          BlockAllocationTableWriter.writeBlock(bat, block);
+       }
+       
+       // SBATs
+       _mini_store.syncWithDataSource();
+       
+       // Properties
+       _property_table.write(
+             new NPOIFSStream(this, _header.getPropertyStart())
+       );
+    }
+    
+    /**
+     * Closes the FileSystem, freeing any underlying files, streams
+     *  and buffers. After this, you will be unable to read or 
+     *  write from the FileSystem.
+     */
+    public void close() throws IOException {
+       _data.close();
+    }
+
+    /**
+     * read in a file and write it back out again
+     *
+     * @param args names of the files; arg[ 0 ] is the input file,
+     *             arg[ 1 ] is the output file
+     *
+     * @exception IOException
+     */
+
+    public static void main(String args[])
+        throws IOException
+    {
+        if (args.length != 2)
+        {
+            System.err.println(
+                "two arguments required: input filename and output filename");
+            System.exit(1);
+        }
+        FileInputStream  istream = new FileInputStream(args[ 0 ]);
+        FileOutputStream ostream = new FileOutputStream(args[ 1 ]);
+
+        new NPOIFSFileSystem(istream).writeFilesystem(ostream);
+        istream.close();
+        ostream.close();
+    }
+
+    /**
+     * Get the root entry
+     *
+     * @return the root entry
+     */
+    public DirectoryNode getRoot()
+    {
+        if (_root == null) {
+           _root = new DirectoryNode(_property_table.getRoot(), this, null);
+        }
+        return _root;
+    }
+
+    /**
+     * open a document in the root entry's list of entries
+     *
+     * @param documentName the name of the document to be opened
+     *
+     * @return a newly opened DocumentInputStream
+     *
+     * @exception IOException if the document does not exist or the
+     *            name is that of a DirectoryEntry
+     */
+
+    public DocumentInputStream createDocumentInputStream(
+            final String documentName)
+        throws IOException
+    {
+    	return getRoot().createDocumentInputStream(documentName);
+    }
+
+    /**
+     * remove an entry
+     *
+     * @param entry to be removed
+     */
+
+    void remove(EntryNode entry)
+    {
+        _property_table.removeProperty(entry.getProperty());
+    }
+    
+    /* ********** START begin implementation of POIFSViewable ********** */
+
+    /**
+     * Get an array of objects, some of which may implement
+     * POIFSViewable
+     *
+     * @return an array of Object; may not be null, but may be empty
+     */
+
+    public Object [] getViewableArray()
+    {
+        if (preferArray())
+        {
+            return (( POIFSViewable ) getRoot()).getViewableArray();
+        }
+        return new Object[ 0 ];
+    }
+
+    /**
+     * Get an Iterator of objects, some of which may implement
+     * POIFSViewable
+     *
+     * @return an Iterator; may not be null, but may have an empty
+     * back end store
+     */
+
+    public Iterator getViewableIterator()
+    {
+        if (!preferArray())
+        {
+            return (( POIFSViewable ) getRoot()).getViewableIterator();
+        }
+        return Collections.EMPTY_LIST.iterator();
+    }
+
+    /**
+     * Give viewers a hint as to whether to call getViewableArray or
+     * getViewableIterator
+     *
+     * @return true if a viewer should call getViewableArray, false if
+     *         a viewer should call getViewableIterator
+     */
+
+    public boolean preferArray()
+    {
+        return (( POIFSViewable ) getRoot()).preferArray();
+    }
+
+    /**
+     * Provides a short description of the object, to be used when a
+     * POIFSViewable object has not provided its contents.
+     *
+     * @return short description
+     */
+
+    public String getShortDescription()
+    {
+        return "POIFS FileSystem";
+    }
+
+    /* **********  END  begin implementation of POIFSViewable ********** */
+
+    /**
+     * @return The Big Block size, normally 512 bytes, sometimes 4096 bytes
+     */
+    public int getBigBlockSize() {
+      return bigBlockSize.getBigBlockSize();
+    }
+    /**
+     * @return The Big Block size, normally 512 bytes, sometimes 4096 bytes
+     */
+    public POIFSBigBlockSize getBigBlockSizeDetails() {
+      return bigBlockSize;
+    }
+    protected int getBlockStoreBlockSize() {
+       return getBigBlockSize();
+    }
+}
+
diff --git a/src/java/org/apache/poi/poifs/filesystem/NPOIFSMiniStore.java b/src/java/org/apache/poi/poifs/filesystem/NPOIFSMiniStore.java
new file mode 100644
index 0000000..156b73d
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/filesystem/NPOIFSMiniStore.java
@@ -0,0 +1,211 @@
+
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+
+package org.apache.poi.poifs.filesystem;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.property.RootProperty;
+import org.apache.poi.poifs.storage.BATBlock;
+import org.apache.poi.poifs.storage.BlockAllocationTableWriter;
+import org.apache.poi.poifs.storage.HeaderBlock;
+import org.apache.poi.poifs.storage.BATBlock.BATBlockAndIndex;
+
+/**
+ * This class handles the MiniStream (small block store)
+ *  in the NIO case for {@link NPOIFSFileSystem}
+ */
+public class NPOIFSMiniStore extends BlockStore
+{
+    private NPOIFSFileSystem _filesystem;
+    private NPOIFSStream     _mini_stream;
+    private List<BATBlock>   _sbat_blocks;
+    private HeaderBlock      _header;
+    private RootProperty     _root;
+
+    protected NPOIFSMiniStore(NPOIFSFileSystem filesystem, RootProperty root,
+         List<BATBlock> sbats, HeaderBlock header)
+    {
+       this._filesystem = filesystem;
+       this._sbat_blocks = sbats;
+       this._header = header;
+       this._root = root;
+       
+       this._mini_stream = new NPOIFSStream(filesystem, root.getStartBlock());
+    }
+    
+    /**
+     * Load the block at the given offset.
+     */
+    protected ByteBuffer getBlockAt(final int offset) throws IOException {
+       // Which big block is this?
+       int byteOffset = offset * POIFSConstants.SMALL_BLOCK_SIZE;
+       int bigBlockNumber = byteOffset / _filesystem.getBigBlockSize();
+       int bigBlockOffset = byteOffset % _filesystem.getBigBlockSize();
+       
+       // Now locate the data block for it
+       Iterator<ByteBuffer> it = _mini_stream.getBlockIterator();
+       for(int i=0; i<bigBlockNumber; i++) {
+          it.next();
+       }
+       ByteBuffer dataBlock = it.next();
+       
+       // Our blocks are small, so duplicating it is fine 
+       byte[] data = new byte[POIFSConstants.SMALL_BLOCK_SIZE];
+       dataBlock.position(
+             dataBlock.position() + bigBlockOffset
+       );
+       dataBlock.get(data, 0, data.length);
+       
+       // Return a ByteBuffer on this
+       ByteBuffer miniBuffer = ByteBuffer.wrap(data);
+       return miniBuffer;
+    }
+    
+    /**
+     * Load the block, extending the underlying stream if needed
+     */
+    protected ByteBuffer createBlockIfNeeded(final int offset) throws IOException {
+       // TODO Extend the stream if needed
+       // TODO Needs append support on the underlying stream
+       return getBlockAt(offset);
+    }
+    
+    /**
+     * Returns the BATBlock that handles the specified offset,
+     *  and the relative index within it
+     */
+    protected BATBlockAndIndex getBATBlockAndIndex(final int offset) {
+       return BATBlock.getSBATBlockAndIndex(
+             offset, _header, _sbat_blocks
+       );
+    }
+    
+    /**
+     * Works out what block follows the specified one.
+     */
+    protected int getNextBlock(final int offset) {
+       BATBlockAndIndex bai = getBATBlockAndIndex(offset);
+       return bai.getBlock().getValueAt( bai.getIndex() );
+    }
+    
+    /**
+     * Changes the record of what block follows the specified one.
+     */
+    protected void setNextBlock(final int offset, final int nextBlock) {
+       BATBlockAndIndex bai = getBATBlockAndIndex(offset);
+       bai.getBlock().setValueAt(
+             bai.getIndex(), nextBlock
+       );
+    }
+    
+    /**
+     * Finds a free block, and returns its offset.
+     * This method will extend the file if needed, and if doing
+     *  so, allocate new FAT blocks to address the extra space.
+     */
+    protected int getFreeBlock() throws IOException {
+       int sectorsPerSBAT = _filesystem.getBigBlockSizeDetails().getBATEntriesPerBlock();
+       
+       // First up, do we have any spare ones?
+       int offset = 0;
+       for(int i=0; i<_sbat_blocks.size(); i++) {
+          // Check this one
+          BATBlock sbat = _sbat_blocks.get(i);
+          if(sbat.hasFreeSectors()) {
+             // Claim one of them and return it
+             for(int j=0; j<sectorsPerSBAT; j++) {
+                int sbatValue = sbat.getValueAt(j);
+                if(sbatValue == POIFSConstants.UNUSED_BLOCK) {
+                   // Bingo
+                   return offset + j;
+                }
+             }
+          }
+          
+          // Move onto the next SBAT
+          offset += sectorsPerSBAT;
+       }
+       
+       // If we get here, then there aren't any
+       //  free sectors in any of the SBATs
+       // So, we need to extend the chain and add another
+       
+       // Create a new BATBlock
+       BATBlock newSBAT = BATBlock.createEmptyBATBlock(_filesystem.getBigBlockSizeDetails(), false);
+       int batForSBAT = _filesystem.getFreeBlock();
+       newSBAT.setOurBlockIndex(batForSBAT);
+       
+       // Are we the first SBAT?
+       if(_header.getSBATCount() == 0) {
+          _header.setSBATStart(batForSBAT);
+          _header.setSBATBlockCount(1);
+       } else {
+          // Find the end of the SBAT stream, and add the sbat in there
+          ChainLoopDetector loopDetector = _filesystem.getChainLoopDetector();
+          int batOffset = _header.getSBATStart();
+          while(true) {
+             loopDetector.claim(batOffset);
+             int nextBat = _filesystem.getNextBlock(batOffset);
+             if(nextBat == POIFSConstants.END_OF_CHAIN) {
+                break;
+             }
+             batOffset = nextBat;
+          }
+          
+          // Add it in at the end
+          _filesystem.setNextBlock(batOffset, batForSBAT);
+          
+          // And update the count
+          _header.setSBATBlockCount(
+                _header.getSBATCount() + 1
+          );
+       }
+       
+       // Finish allocating
+       _filesystem.setNextBlock(batForSBAT, POIFSConstants.END_OF_CHAIN);
+       _sbat_blocks.add(newSBAT);
+       
+       // Return our first spot
+       return offset;
+    }
+    
+    @Override
+    protected ChainLoopDetector getChainLoopDetector() throws IOException {
+      return new ChainLoopDetector( _root.getSize() );
+    }
+
+    protected int getBlockStoreBlockSize() {
+       return POIFSConstants.SMALL_BLOCK_SIZE;
+    }
+    
+    /**
+     * Writes the SBATs to their backing blocks
+     */
+    protected void syncWithDataSource() throws IOException {
+       for(BATBlock sbat : _sbat_blocks) {
+          ByteBuffer block = _filesystem.getBlockAt(sbat.getOurBlockIndex());
+          BlockAllocationTableWriter.writeBlock(sbat, block);
+       }
+    }
+}
diff --git a/src/java/org/apache/poi/poifs/filesystem/NPOIFSStream.java b/src/java/org/apache/poi/poifs/filesystem/NPOIFSStream.java
new file mode 100644
index 0000000..4581009
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/filesystem/NPOIFSStream.java
@@ -0,0 +1,224 @@
+
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+
+package org.apache.poi.poifs.filesystem;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.filesystem.BlockStore.ChainLoopDetector;
+import org.apache.poi.poifs.property.Property;
+import org.apache.poi.poifs.storage.HeaderBlock;
+
+/**
+ * This handles reading and writing a stream within a
+ *  {@link NPOIFSFileSystem}. It can supply an iterator
+ *  to read blocks, and way to write out to existing and
+ *  new blocks.
+ * Most users will want a higher level version of this, 
+ *  which deals with properties to track which stream
+ *  this is.
+ * This only works on big block streams, it doesn't
+ *  handle small block ones.
+ * This uses the new NIO code
+ * 
+ * TODO Implement a streaming write method, and append
+ */
+
+public class NPOIFSStream implements Iterable<ByteBuffer>
+{
+	private BlockStore blockStore;
+	private int startBlock;
+	
+	/**
+	 * Constructor for an existing stream. It's up to you
+	 *  to know how to get the start block (eg from a 
+	 *  {@link HeaderBlock} or a {@link Property}) 
+	 */
+	public NPOIFSStream(BlockStore blockStore, int startBlock) {
+	   this.blockStore = blockStore;
+	   this.startBlock = startBlock;
+	}
+	
+	/**
+	 * Constructor for a new stream. A start block won't
+	 *  be allocated until you begin writing to it.
+	 */
+	public NPOIFSStream(BlockStore blockStore) {
+      this.blockStore = blockStore;
+	   this.startBlock = POIFSConstants.END_OF_CHAIN;
+	}
+	
+	/**
+	 * What block does this stream start at?
+	 * Will be {@link POIFSConstants#END_OF_CHAIN} for a
+	 *  new stream that hasn't been written to yet.
+	 */
+	public int getStartBlock() {
+	   return startBlock;
+	}
+
+	/**
+	 * Returns an iterator that'll supply one {@link ByteBuffer}
+	 *  per block in the stream.
+	 */
+   public Iterator<ByteBuffer> iterator() {
+      return getBlockIterator();
+   }
+	
+   public Iterator<ByteBuffer> getBlockIterator() {
+      if(startBlock == POIFSConstants.END_OF_CHAIN) {
+         throw new IllegalStateException(
+               "Can't read from a new stream before it has been written to"
+         );
+      }
+      return new StreamBlockByteBufferIterator(startBlock);
+   }
+   
+   /**
+    * Updates the contents of the stream to the new
+    *  set of bytes.
+    * Note - if this is property based, you'll still
+    *  need to update the size in the property yourself
+    */
+   public void updateContents(byte[] contents) throws IOException {
+      // How many blocks are we going to need?
+      int blockSize = blockStore.getBlockStoreBlockSize();
+      int blocks = (int)Math.ceil(contents.length / blockSize);
+      
+      // Make sure we don't encounter a loop whilst overwriting
+      //  the existing blocks
+      ChainLoopDetector loopDetector = blockStore.getChainLoopDetector();
+      
+      // Start writing
+      int prevBlock = POIFSConstants.END_OF_CHAIN;
+      int nextBlock = startBlock;
+      for(int i=0; i<blocks; i++) {
+         int thisBlock = nextBlock;
+         
+         // Allocate a block if needed, otherwise figure
+         //  out what the next block will be
+         if(thisBlock == POIFSConstants.END_OF_CHAIN) {
+            thisBlock = blockStore.getFreeBlock();
+            loopDetector.claim(thisBlock);
+            
+            // We're on the end of the chain
+            nextBlock = POIFSConstants.END_OF_CHAIN;
+            
+            // Mark the previous block as carrying on to us if needed
+            if(prevBlock != POIFSConstants.END_OF_CHAIN) {
+               blockStore.setNextBlock(prevBlock, thisBlock);
+            }
+            blockStore.setNextBlock(thisBlock, POIFSConstants.END_OF_CHAIN);
+            
+            // If we've just written the first block on a 
+            //  new stream, save the start block offset
+            if(this.startBlock == POIFSConstants.END_OF_CHAIN) {
+               this.startBlock = thisBlock;
+            }
+         } else {
+            loopDetector.claim(thisBlock);
+            nextBlock = blockStore.getNextBlock(thisBlock);
+         }
+         
+         // Write it
+         ByteBuffer buffer = blockStore.createBlockIfNeeded(thisBlock);
+         buffer.put(contents, i*blockSize, blockSize);
+         
+         // Update pointers
+         prevBlock = thisBlock;
+      }
+      int lastBlock = prevBlock;
+      
+      // If we're overwriting, free any remaining blocks
+      NPOIFSStream toFree = new NPOIFSStream(blockStore, nextBlock);
+      toFree.free(loopDetector);
+      
+      // Mark the end of the stream
+      blockStore.setNextBlock(lastBlock, POIFSConstants.END_OF_CHAIN);
+   }
+   
+   // TODO Streaming write support
+   // TODO  then convert fixed sized write to use streaming internally
+   // TODO Append write support (probably streaming)
+   
+   /**
+    * Frees all blocks in the stream
+    */
+   public void free() throws IOException {
+      ChainLoopDetector loopDetector = blockStore.getChainLoopDetector();
+      free(loopDetector);
+   }
+   private void free(ChainLoopDetector loopDetector) {
+      int nextBlock = startBlock;
+      while(nextBlock != POIFSConstants.END_OF_CHAIN) {
+         int thisBlock = nextBlock;
+         loopDetector.claim(thisBlock);
+         nextBlock = blockStore.getNextBlock(thisBlock);
+         blockStore.setNextBlock(thisBlock, POIFSConstants.UNUSED_BLOCK);
+      }
+      this.startBlock = POIFSConstants.END_OF_CHAIN;
+   }
+   
+   /**
+    * Class that handles a streaming read of one stream
+    */
+   protected class StreamBlockByteBufferIterator implements Iterator<ByteBuffer> {
+      private ChainLoopDetector loopDetector;
+      private int nextBlock;
+      
+      protected StreamBlockByteBufferIterator(int firstBlock) {
+         this.nextBlock = firstBlock;
+         try {
+            this.loopDetector = blockStore.getChainLoopDetector();
+         } catch(IOException e) {
+            throw new RuntimeException(e);
+         }
+      }
+
+      public boolean hasNext() {
+         if(nextBlock == POIFSConstants.END_OF_CHAIN) {
+            return false;
+         }
+         return true;
+      }
+
+      public ByteBuffer next() {
+         if(nextBlock == POIFSConstants.END_OF_CHAIN) {
+            throw new IndexOutOfBoundsException("Can't read past the end of the stream");
+         }
+         
+         try {
+            loopDetector.claim(nextBlock);
+            ByteBuffer data = blockStore.getBlockAt(nextBlock);
+            nextBlock = blockStore.getNextBlock(nextBlock);
+            return data;
+         } catch(IOException e) {
+            throw new RuntimeException(e);
+         }
+      }
+
+      public void remove() {
+         throw new UnsupportedOperationException();
+      }
+   }
+}
+
diff --git a/src/java/org/apache/poi/poifs/filesystem/ODocumentInputStream.java b/src/java/org/apache/poi/poifs/filesystem/ODocumentInputStream.java
new file mode 100644
index 0000000..a1bc5da
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/filesystem/ODocumentInputStream.java
@@ -0,0 +1,321 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.filesystem;
+
+import java.io.IOException;
+
+import org.apache.poi.poifs.storage.DataInputBlock;
+
+/**
+ * This class provides methods to read a DocumentEntry managed by a
+ * {@link POIFSFileSystem} instance.
+ *
+ * @author Marc Johnson (mjohnson at apache dot org)
+ */
+public final class ODocumentInputStream extends DocumentInputStream {
+	/** current offset into the Document */
+	private int _current_offset;
+
+	/** current marked offset into the Document (used by mark and reset) */
+	private int _marked_offset;
+
+	/** the Document's size */
+	private int _document_size;
+
+	/** have we been closed? */
+	private boolean _closed;
+
+	/** the actual Document */
+	private POIFSDocument _document;
+
+	/** the data block containing the current stream pointer */
+	private DataInputBlock _currentBlock;
+
+	/**
+	 * Create an InputStream from the specified DocumentEntry
+	 * 
+	 * @param document the DocumentEntry to be read
+	 * 
+	 * @exception IOException if the DocumentEntry cannot be opened (like, maybe it has
+	 *                been deleted?)
+	 */
+	public ODocumentInputStream(DocumentEntry document) throws IOException {
+		if (!(document instanceof DocumentNode)) {
+			throw new IOException("Cannot open internal document storage");
+		}
+		DocumentNode documentNode = (DocumentNode)document;
+		if(documentNode.getDocument() == null) {
+         throw new IOException("Cannot open internal document storage");
+		}
+		      
+		_current_offset = 0;
+		_marked_offset = 0;
+		_document_size = document.getSize();
+		_closed = false;
+		_document = documentNode.getDocument();
+		_currentBlock = getDataInputBlock(0);
+	}
+
+	/**
+	 * Create an InputStream from the specified Document
+	 * 
+	 * @param document the Document to be read
+	 */
+	public ODocumentInputStream(POIFSDocument document) {
+		_current_offset = 0;
+		_marked_offset = 0;
+		_document_size = document.getSize();
+		_closed = false;
+		_document = document;
+		_currentBlock = getDataInputBlock(0);
+	}
+
+	@Override
+	public int available() {
+		if (_closed) {
+			throw new IllegalStateException("cannot perform requested operation on a closed stream");
+		}
+		return _document_size - _current_offset;
+	}
+
+   @Override
+	public void close() {
+		_closed = true;
+	}
+
+   @Override
+	public void mark(int ignoredReadlimit) {
+		_marked_offset = _current_offset;
+	}
+
+	private DataInputBlock getDataInputBlock(int offset) {
+		return _document.getDataInputBlock(offset);
+	}
+
+   @Override
+	public int read() throws IOException {
+		dieIfClosed();
+		if (atEOD()) {
+			return EOF;
+		}
+		int result = _currentBlock.readUByte();
+		_current_offset++;
+		if (_currentBlock.available() < 1) {
+			_currentBlock = getDataInputBlock(_current_offset);
+		}
+		return result;
+	}
+
+   @Override
+	public int read(byte[] b, int off, int len) throws IOException {
+		dieIfClosed();
+		if (b == null) {
+			throw new IllegalArgumentException("buffer must not be null");
+		}
+		if (off < 0 || len < 0 || b.length < off + len) {
+			throw new IndexOutOfBoundsException("can't read past buffer boundaries");
+		}
+		if (len == 0) {
+			return 0;
+		}
+		if (atEOD()) {
+			return EOF;
+		}
+		int limit = Math.min(available(), len);
+		readFully(b, off, limit);
+		return limit;
+	}
+
+	/**
+	 * Repositions this stream to the position at the time the mark() method was
+	 * last called on this input stream. If mark() has not been called this
+	 * method repositions the stream to its beginning.
+	 */
+   @Override
+	public void reset() {
+		_current_offset = _marked_offset;
+		_currentBlock = getDataInputBlock(_current_offset);
+	}
+
+   @Override
+	public long skip(long n) throws IOException {
+		dieIfClosed();
+		if (n < 0) {
+			return 0;
+		}
+		int new_offset = _current_offset + (int) n;
+
+		if (new_offset < _current_offset) {
+
+			// wrap around in converting a VERY large long to an int
+			new_offset = _document_size;
+		} else if (new_offset > _document_size) {
+			new_offset = _document_size;
+		}
+		long rval = new_offset - _current_offset;
+
+		_current_offset = new_offset;
+		_currentBlock = getDataInputBlock(_current_offset);
+		return rval;
+	}
+
+	private void dieIfClosed() throws IOException {
+		if (_closed) {
+			throw new IOException("cannot perform requested operation on a closed stream");
+		}
+	}
+
+	private boolean atEOD() {
+		return _current_offset == _document_size;
+	}
+
+	private void checkAvaliable(int requestedSize) {
+		if (_closed) {
+			throw new IllegalStateException("cannot perform requested operation on a closed stream");
+		}
+		if (requestedSize > _document_size - _current_offset) {
+			throw new RuntimeException("Buffer underrun - requested " + requestedSize
+					+ " bytes but " + (_document_size - _current_offset) + " was available");
+		}
+	}
+
+   @Override
+	public byte readByte() {
+		return (byte) readUByte();
+	}
+
+   @Override
+	public double readDouble() {
+		return Double.longBitsToDouble(readLong());
+	}
+
+   @Override
+	public short readShort() {
+		return (short) readUShort();
+	}
+
+   @Override
+	public void readFully(byte[] buf, int off, int len) {
+		checkAvaliable(len);
+		int blockAvailable = _currentBlock.available();
+		if (blockAvailable > len) {
+			_currentBlock.readFully(buf, off, len);
+			_current_offset += len;
+			return;
+		}
+		// else read big amount in chunks
+		int remaining = len;
+		int writePos = off;
+		while (remaining > 0) {
+			boolean blockIsExpiring = remaining >= blockAvailable;
+			int reqSize;
+			if (blockIsExpiring) {
+				reqSize = blockAvailable;
+			} else {
+				reqSize = remaining;
+			}
+			_currentBlock.readFully(buf, writePos, reqSize);
+			remaining -= reqSize;
+			writePos += reqSize;
+			_current_offset += reqSize;
+			if (blockIsExpiring) {
+				if (_current_offset == _document_size) {
+					if (remaining > 0) {
+						throw new IllegalStateException(
+								"reached end of document stream unexpectedly");
+					}
+					_currentBlock = null;
+					break;
+				}
+				_currentBlock = getDataInputBlock(_current_offset);
+				blockAvailable = _currentBlock.available();
+			}
+		}
+	}
+
+   @Override
+	public long readLong() {
+		checkAvaliable(SIZE_LONG);
+		int blockAvailable = _currentBlock.available();
+		long result;
+		if (blockAvailable > SIZE_LONG) {
+			result = _currentBlock.readLongLE();
+		} else {
+			DataInputBlock nextBlock = getDataInputBlock(_current_offset + blockAvailable);
+			if (blockAvailable == SIZE_LONG) {
+				result = _currentBlock.readLongLE();
+			} else {
+				result = nextBlock.readLongLE(_currentBlock, blockAvailable);
+			}
+			_currentBlock = nextBlock;
+		}
+		_current_offset += SIZE_LONG;
+		return result;
+	}
+
+   @Override
+	public int readInt() {
+		checkAvaliable(SIZE_INT);
+		int blockAvailable = _currentBlock.available();
+		int result;
+		if (blockAvailable > SIZE_INT) {
+			result = _currentBlock.readIntLE();
+		} else {
+			DataInputBlock nextBlock = getDataInputBlock(_current_offset + blockAvailable);
+			if (blockAvailable == SIZE_INT) {
+				result = _currentBlock.readIntLE();
+			} else {
+				result = nextBlock.readIntLE(_currentBlock, blockAvailable);
+			}
+			_currentBlock = nextBlock;
+		}
+		_current_offset += SIZE_INT;
+		return result;
+	}
+
+   @Override
+	public int readUShort() {
+		checkAvaliable(SIZE_SHORT);
+		int blockAvailable = _currentBlock.available();
+		int result;
+		if (blockAvailable > SIZE_SHORT) {
+			result = _currentBlock.readUShortLE();
+		} else {
+			DataInputBlock nextBlock = getDataInputBlock(_current_offset + blockAvailable);
+			if (blockAvailable == SIZE_SHORT) {
+				result = _currentBlock.readUShortLE();
+			} else {
+				result = nextBlock.readUShortLE(_currentBlock);
+			}
+			_currentBlock = nextBlock;
+		}
+		_current_offset += SIZE_SHORT;
+		return result;
+	}
+
+   @Override
+	public int readUByte() {
+		checkAvaliable(1);
+		int result = _currentBlock.readUByte();
+		_current_offset++;
+		if (_currentBlock.available() < 1) {
+			_currentBlock = getDataInputBlock(_current_offset);
+		}
+		return result;
+	}
+}
diff --git a/src/java/org/apache/poi/poifs/filesystem/Ole10Native.java b/src/java/org/apache/poi/poifs/filesystem/Ole10Native.java
new file mode 100644
index 0000000..488bfb3
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/filesystem/Ole10Native.java
@@ -0,0 +1,279 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.filesystem;
+
+import org.apache.poi.util.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Arrays;
+
+/**
+ * Represents an Ole10Native record which is wrapped around certain binary
+ * files being embedded in OLE2 documents.
+ *
+ * @author Rainer Schwarze
+ */
+public class Ole10Native {
+  // (the fields as they appear in the raw record:)
+  private final int totalSize;                // 4 bytes, total size of record not including this field
+  private short flags1;                // 2 bytes, unknown, mostly [02 00]
+  private final String label;                // ASCIIZ, stored in this field without the terminating zero
+  private final String fileName;        // ASCIIZ, stored in this field without the terminating zero
+  private short flags2;                // 2 bytes, unknown, mostly [00 00]
+  // private byte unknown1Length;	// 1 byte, specifying the length of the following byte array (unknown1)
+  private byte[] unknown1;        // see below
+  private byte[] unknown2;        // 3 bytes, unknown, mostly [00 00 00]
+  private final String command;                // ASCIIZ, stored in this field without the terminating zero
+  private final int dataSize;                // 4 bytes (if space), size of following buffer
+  private final byte[] dataBuffer;        // varying size, the actual native data
+  private short flags3;                // some final flags? or zero terminators?, sometimes not there
+  public static final String OLE10_NATIVE = "\u0001Ole10Native";
+
+  /**
+   * Creates an instance of this class from an embedded OLE Object. The OLE Object is expected
+   * to include a stream &quot;{01}Ole10Native&quot; which contains the actual
+   * data relevant for this class.
+   *
+   * @param poifs POI Filesystem object
+   * @return Returns an instance of this class
+   * @throws IOException on IO error
+   * @throws Ole10NativeException on invalid or unexcepted data format
+   */
+  public static Ole10Native createFromEmbeddedOleObject(POIFSFileSystem poifs) throws IOException, Ole10NativeException {
+    boolean plain = false;
+
+    try {
+      poifs.getRoot().getEntry("\u0001Ole10ItemName");
+      plain = true;
+    } catch (FileNotFoundException ex) {
+      plain = false;
+    }
+
+    DocumentInputStream dis = poifs.createDocumentInputStream(OLE10_NATIVE);
+    ByteArrayOutputStream bos = new ByteArrayOutputStream();
+    IOUtils.copy(dis, bos);
+    byte[] data = bos.toByteArray();
+
+    return new Ole10Native(data, 0, plain);
+  }
+
+  /**
+   * Creates an instance and fills the fields based on the data in the given buffer.
+   *
+   * @param data   The buffer containing the Ole10Native record
+   * @param offset The start offset of the record in the buffer
+   * @throws Ole10NativeException on invalid or unexcepted data format
+   */
+  public Ole10Native(byte[] data, int offset) throws Ole10NativeException {
+    this(data, offset, false);
+  }
+  /**
+   * Creates an instance and fills the fields based on the data in the given buffer.
+   *
+   * @param data   The buffer containing the Ole10Native record
+   * @param offset The start offset of the record in the buffer
+   * @param plain Specified 'plain' format without filename
+   * @throws Ole10NativeException on invalid or unexcepted data format
+   */
+  public Ole10Native(byte[] data, int offset, boolean plain) throws Ole10NativeException {
+    int ofs = offset;        // current offset, initialized to start
+
+    if (data.length<offset+2) {
+      throw new Ole10NativeException("data is too small");
+    }
+
+    totalSize = LittleEndian.getInt(data, ofs);
+    ofs += LittleEndianConsts.INT_SIZE;
+
+    if (plain) {
+      dataBuffer = new byte[totalSize-4];
+      System.arraycopy(data, 4, dataBuffer, 0, dataBuffer.length);
+      dataSize = totalSize - 4;
+      
+      byte[] oleLabel = new byte[8];
+      System.arraycopy(dataBuffer, 0, oleLabel, 0, Math.min(dataBuffer.length, 8));
+      label = "ole-"+ HexDump.toHex(oleLabel);
+      fileName = label;
+      command = label;
+    } else {
+      flags1 = LittleEndian.getShort(data, ofs);
+      ofs += LittleEndianConsts.SHORT_SIZE;
+      int len = getStringLength(data, ofs);
+      label = StringUtil.getFromCompressedUnicode(data, ofs, len - 1);
+      ofs += len;
+      len = getStringLength(data, ofs);
+      fileName = StringUtil.getFromCompressedUnicode(data, ofs, len - 1);
+      ofs += len;
+      flags2 = LittleEndian.getShort(data, ofs);
+      ofs += LittleEndianConsts.SHORT_SIZE;
+      len = LittleEndian.getUnsignedByte(data, ofs);
+      unknown1 = new byte[len];
+      ofs += len;
+      len = 3;
+      unknown2 = new byte[len];
+      ofs += len;
+      len = getStringLength(data, ofs);
+      command = StringUtil.getFromCompressedUnicode(data, ofs, len - 1);
+      ofs += len;
+
+      if (totalSize + LittleEndianConsts.INT_SIZE - ofs > LittleEndianConsts.INT_SIZE) {
+        dataSize = LittleEndian.getInt(data, ofs);
+        ofs += LittleEndianConsts.INT_SIZE;
+
+        if (dataSize > totalSize || dataSize<0) {
+          throw new Ole10NativeException("Invalid Ole10Native");
+        }
+
+        dataBuffer = new byte[dataSize];
+        System.arraycopy(data, ofs, dataBuffer, 0, dataSize);
+        ofs += dataSize;
+
+        if (unknown1.length > 0) {
+          flags3 = LittleEndian.getShort(data, ofs);
+          ofs += LittleEndianConsts.SHORT_SIZE;
+        } else {
+          flags3 = 0;
+        }
+      } else {
+        throw new Ole10NativeException("Invalid Ole10Native");
+      }
+    }
+  }
+
+  /*
+   * Helper - determine length of zero terminated string (ASCIIZ).
+   */
+  private static int getStringLength(byte[] data, int ofs) {
+    int len = 0;
+    while (len+ofs<data.length && data[ofs + len] != 0) {
+      len++;
+    }
+    len++;
+    return len;
+  }
+
+  /**
+   * Returns the value of the totalSize field - the total length of the structure
+   * is totalSize + 4 (value of this field + size of this field).
+   *
+   * @return the totalSize
+   */
+  public int getTotalSize() {
+    return totalSize;
+  }
+
+  /**
+   * Returns flags1 - currently unknown - usually 0x0002.
+   *
+   * @return the flags1
+   */
+  public short getFlags1() {
+    return flags1;
+  }
+
+  /**
+   * Returns the label field - usually the name of the file (without directory) but
+   * probably may be any name specified during packaging/embedding the data.
+   *
+   * @return the label
+   */
+  public String getLabel() {
+    return label;
+  }
+
+  /**
+   * Returns the fileName field - usually the name of the file being embedded
+   * including the full path.
+   *
+   * @return the fileName
+   */
+  public String getFileName() {
+    return fileName;
+  }
+
+  /**
+   * Returns flags2 - currently unknown - mostly 0x0000.
+   *
+   * @return the flags2
+   */
+  public short getFlags2() {
+    return flags2;
+  }
+
+  /**
+   * Returns unknown1 field - currently unknown.
+   *
+   * @return the unknown1
+   */
+  public byte[] getUnknown1() {
+    return unknown1;
+  }
+
+  /**
+   * Returns the unknown2 field - currently being a byte[3] - mostly {0, 0, 0}.
+   *
+   * @return the unknown2
+   */
+  public byte[] getUnknown2() {
+    return unknown2;
+  }
+
+  /**
+   * Returns the command field - usually the name of the file being embedded
+   * including the full path, may be a command specified during embedding the file.
+   *
+   * @return the command
+   */
+  public String getCommand() {
+    return command;
+  }
+
+  /**
+   * Returns the size of the embedded file. If the size is 0 (zero), no data has been
+   * embedded. To be sure, that no data has been embedded, check whether
+   * {@link #getDataBuffer()} returns <code>null</code>.
+   *
+   * @return the dataSize
+   */
+  public int getDataSize() {
+    return dataSize;
+  }
+
+  /**
+   * Returns the buffer containing the embedded file's data, or <code>null</code>
+   * if no data was embedded. Note that an embedding may provide information about
+   * the data, but the actual data is not included. (So label, filename etc. are
+   * available, but this method returns <code>null</code>.)
+   *
+   * @return the dataBuffer
+   */
+  public byte[] getDataBuffer() {
+    return dataBuffer;
+  }
+
+  /**
+   * Returns the flags3 - currently unknown.
+   *
+   * @return the flags3
+   */
+  public short getFlags3() {
+    return flags3;
+  }
+}
diff --git a/src/java/org/apache/poi/poifs/filesystem/Ole10NativeException.java b/src/java/org/apache/poi/poifs/filesystem/Ole10NativeException.java
new file mode 100644
index 0000000..a186990
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/filesystem/Ole10NativeException.java
@@ -0,0 +1,24 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.filesystem;
+
+public class Ole10NativeException extends Exception {
+    public Ole10NativeException(String message) {
+        super(message);
+    }
+}
diff --git a/src/java/org/apache/poi/poifs/filesystem/POIFSDocument.java b/src/java/org/apache/poi/poifs/filesystem/POIFSDocument.java
index c313baf..5588c8b 100644
--- a/src/java/org/apache/poi/poifs/filesystem/POIFSDocument.java
+++ b/src/java/org/apache/poi/poifs/filesystem/POIFSDocument.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,21 +14,27 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.filesystem;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
 
-import java.util.*;
-
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.poifs.dev.POIFSViewable;
 import org.apache.poi.poifs.property.DocumentProperty;
 import org.apache.poi.poifs.property.Property;
 import org.apache.poi.poifs.storage.BlockWritable;
-import org.apache.poi.poifs.storage.ListManagedBlock;
+import org.apache.poi.poifs.storage.DataInputBlock;
 import org.apache.poi.poifs.storage.DocumentBlock;
+import org.apache.poi.poifs.storage.ListManagedBlock;
 import org.apache.poi.poifs.storage.RawDataBlock;
 import org.apache.poi.poifs.storage.SmallDocumentBlock;
 import org.apache.poi.util.HexDump;
@@ -39,595 +44,525 @@
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
+public final class POIFSDocument implements BATManaged, BlockWritable, POIFSViewable  {
+	private static final DocumentBlock[] EMPTY_BIG_BLOCK_ARRAY = { };
+	private static final SmallDocumentBlock[] EMPTY_SMALL_BLOCK_ARRAY = { };
+	private DocumentProperty _property;
+	private int _size;
+	
+   private final POIFSBigBlockSize _bigBigBlockSize;
 
-public class POIFSDocument
-    implements BATManaged, BlockWritable, POIFSViewable
-{
-    private DocumentProperty _property;
-    private int              _size;
+	// one of these stores will be valid
+	private SmallBlockStore  _small_store;
+	private BigBlockStore	 _big_store;
+	
+		/**
+	 * Constructor from large blocks
+	 *
+	 * @param name the name of the POIFSDocument
+	 * @param blocks the big blocks making up the POIFSDocument
+	 * @param length the actual length of the POIFSDocument
+	 */
+	public POIFSDocument(String name, RawDataBlock[] blocks, int length) throws IOException {
+		_size = length;
+		if(blocks.length == 0) {
+		   _bigBigBlockSize = POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS;
+		} else {
+		   _bigBigBlockSize = (blocks[0].getBigBlockSize() == POIFSConstants.SMALLER_BIG_BLOCK_SIZE ?
+		         POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS : 
+		         POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS
+		   );
+		}
+		
+		_big_store = new BigBlockStore(_bigBigBlockSize, convertRawBlocksToBigBlocks(blocks));
+		_property = new DocumentProperty(name, _size);
+		_small_store = new SmallBlockStore(_bigBigBlockSize, EMPTY_SMALL_BLOCK_ARRAY);
+		_property.setDocument(this);
+	}
 
-    // one of these stores will be valid
-    private SmallBlockStore  _small_store;
-    private BigBlockStore    _big_store;
+	// TODO - awkward typing going on here
+	private static DocumentBlock[] convertRawBlocksToBigBlocks(ListManagedBlock[] blocks) throws IOException {
+		DocumentBlock[] result = new DocumentBlock[blocks.length];
+		for (int i = 0; i < result.length; i++) {
+			result[i] = new DocumentBlock((RawDataBlock)blocks[i]);
+		}
+		return result;
+	}
+	private static SmallDocumentBlock[] convertRawBlocksToSmallBlocks(ListManagedBlock[] blocks) {
+		if (blocks instanceof SmallDocumentBlock[]) {
+			return (SmallDocumentBlock[]) blocks;
+		}
+		SmallDocumentBlock[] result = new SmallDocumentBlock[blocks.length];
+		System.arraycopy(blocks, 0, result, 0, blocks.length);
+		return result;
+	}
 
-    /**
-     * Constructor from large blocks
-     *
-     * @param name the name of the POIFSDocument
-     * @param blocks the big blocks making up the POIFSDocument
-     * @param length the actual length of the POIFSDocument
-     *
-     * @exception IOException
-     */
+	/**
+	 * Constructor from small blocks
+	 *
+	 * @param name the name of the POIFSDocument
+	 * @param blocks the small blocks making up the POIFSDocument
+	 * @param length the actual length of the POIFSDocument
+	 */
+	public POIFSDocument(String name, SmallDocumentBlock[] blocks, int length) {
+		_size = length;
+		
+		if(blocks.length == 0) {
+		   _bigBigBlockSize = POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS;
+		} else {
+		   _bigBigBlockSize = blocks[0].getBigBlockSize();
+		}
 
-    public POIFSDocument(final String name, final RawDataBlock [] blocks,
-                         final int length)
-        throws IOException
-    {
-        _size        = length;
-        _big_store   = new BigBlockStore(blocks);
-        _property    = new DocumentProperty(name, _size);
-        _small_store = new SmallBlockStore(new BlockWritable[ 0 ]);
-        _property.setDocument(this);
-    }
+		_big_store = new BigBlockStore(_bigBigBlockSize, EMPTY_BIG_BLOCK_ARRAY);
+		_property = new DocumentProperty(name, _size);
+		_small_store = new SmallBlockStore(_bigBigBlockSize, blocks);
+		_property.setDocument(this);
+	}
 
-    /**
-     * Constructor from small blocks
-     *
-     * @param name the name of the POIFSDocument
-     * @param blocks the small blocks making up the POIFSDocument
-     * @param length the actual length of the POIFSDocument
-     */
+	/**
+	 * Constructor from small blocks
+	 *
+	 * @param name the name of the POIFSDocument
+	 * @param blocks the small blocks making up the POIFSDocument
+	 * @param length the actual length of the POIFSDocument
+	 */
+	public POIFSDocument(String name, POIFSBigBlockSize bigBlockSize, ListManagedBlock[] blocks, int length) throws IOException {
+		_size = length;
+		_bigBigBlockSize = bigBlockSize;
+		_property = new DocumentProperty(name, _size);
+		_property.setDocument(this);
+		if (Property.isSmall(_size)) {
+			_big_store = new BigBlockStore(bigBlockSize,EMPTY_BIG_BLOCK_ARRAY);
+			_small_store = new SmallBlockStore(bigBlockSize,convertRawBlocksToSmallBlocks(blocks));
+		} else {
+			_big_store = new BigBlockStore(bigBlockSize,convertRawBlocksToBigBlocks(blocks));
+			_small_store = new SmallBlockStore(bigBlockSize,EMPTY_SMALL_BLOCK_ARRAY);
+		}
+	}
+	public POIFSDocument(String name, ListManagedBlock[] blocks, int length) throws IOException {
+	   this(name, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, blocks, length);
+	}
 
-    public POIFSDocument(final String name,
-                         final SmallDocumentBlock [] blocks, final int length)
-    {
-        _size = length;
-        try
-        {
-            _big_store = new BigBlockStore(new RawDataBlock[ 0 ]);
-        }
-        catch (IOException ignored)
-        {
+	/**
+	 * Constructor
+	 *
+	 * @param name the name of the POIFSDocument
+	 * @param stream the InputStream we read data from
+	 */
+	public POIFSDocument(String name, POIFSBigBlockSize bigBlockSize, InputStream stream) throws IOException {
+		List<DocumentBlock> blocks = new ArrayList<DocumentBlock>();
 
-            // can't happen with that constructor
-        }
-        _property    = new DocumentProperty(name, _size);
-        _small_store = new SmallBlockStore(blocks);
-        _property.setDocument(this);
-    }
+		_size = 0;
+		_bigBigBlockSize = bigBlockSize;
+		while (true) {
+			DocumentBlock block = new DocumentBlock(stream, bigBlockSize);
+			int blockSize = block.size();
 
-    /**
-     * Constructor from small blocks
-     *
-     * @param name the name of the POIFSDocument
-     * @param blocks the small blocks making up the POIFSDocument
-     * @param length the actual length of the POIFSDocument
-     *
-     * @exception IOException
-     */
+			if (blockSize > 0) {
+				blocks.add(block);
+				_size += blockSize;
+			}
+			if (block.partiallyRead()) {
+				break;
+			}
+		}
+		DocumentBlock[] bigBlocks = blocks.toArray(new DocumentBlock[blocks.size()]);
 
-    public POIFSDocument(final String name, final ListManagedBlock [] blocks,
-                         final int length)
-        throws IOException
-    {
-        _size     = length;
-        _property = new DocumentProperty(name, _size);
-        _property.setDocument(this);
-        if (Property.isSmall(_size))
-        {
-            _big_store   = new BigBlockStore(new RawDataBlock[ 0 ]);
-            _small_store = new SmallBlockStore(blocks);
-        }
-        else
-        {
-            _big_store   = new BigBlockStore(blocks);
-            _small_store = new SmallBlockStore(new BlockWritable[ 0 ]);
-        }
-    }
+		_big_store = new BigBlockStore(bigBlockSize,bigBlocks);
+		_property = new DocumentProperty(name, _size);
+		_property.setDocument(this);
+		if (_property.shouldUseSmallBlocks()) {
+			_small_store = new SmallBlockStore(bigBlockSize,SmallDocumentBlock.convert(bigBlockSize,bigBlocks, _size));
+			_big_store = new BigBlockStore(bigBlockSize,new DocumentBlock[0]);
+		} else {
+			_small_store = new SmallBlockStore(bigBlockSize,EMPTY_SMALL_BLOCK_ARRAY);
+		}
+	}
+	public POIFSDocument(String name, InputStream stream) throws IOException {
+	   this(name, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, stream);
+	}
 
-    /**
-     * Constructor
-     *
-     * @param name the name of the POIFSDocument
-     * @param stream the InputStream we read data from
-     *
-     * @exception IOException thrown on read errors
-     */
+	/**
+	 * Constructor
+	 *
+	 * @param name the name of the POIFSDocument
+	 * @param size the length of the POIFSDocument
+	 * @param path the path of the POIFSDocument
+	 * @param writer the writer who will eventually write the document contents
+	 */
+	public POIFSDocument(String name, int size, POIFSBigBlockSize bigBlockSize, POIFSDocumentPath path, POIFSWriterListener writer) {
+		_size = size;
+		_bigBigBlockSize = bigBlockSize;
+		_property = new DocumentProperty(name, _size);
+		_property.setDocument(this);
+		if (_property.shouldUseSmallBlocks()) {
+			_small_store = new SmallBlockStore(_bigBigBlockSize, path, name, size, writer);
+			_big_store = new BigBlockStore(_bigBigBlockSize, EMPTY_BIG_BLOCK_ARRAY);
+		} else {
+			_small_store = new SmallBlockStore(_bigBigBlockSize, EMPTY_SMALL_BLOCK_ARRAY);
+			_big_store = new BigBlockStore(_bigBigBlockSize, path, name, size, writer);
+		}
+	}
+	public POIFSDocument(String name, int size, POIFSDocumentPath path, POIFSWriterListener writer) {
+	   this(name, size, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, path, writer);
+	}
 
-    public POIFSDocument(final String name, final InputStream stream)
-        throws IOException
-    {
-        List blocks = new ArrayList();
+	/**
+	 * @return array of SmallDocumentBlocks; may be empty, cannot be null
+	 */
+	public BlockWritable[] getSmallBlocks() {
+		return _small_store.getBlocks();
+	}
 
-        _size = 0;
-        while (true)
-        {
-            DocumentBlock block     = new DocumentBlock(stream);
-            int           blockSize = block.size();
+	/**
+	 * @return size of the document
+	 */
+	public int getSize() {
+		return _size;
+	}
 
-            if (blockSize > 0)
-            {
-                blocks.add(block);
-                _size += blockSize;
-            }
-            if (block.partiallyRead())
-            {
-                break;
-            }
-        }
-        DocumentBlock[] bigBlocks =
-            ( DocumentBlock [] ) blocks.toArray(new DocumentBlock[ 0 ]);
+	/**
+	 * read data from the internal stores
+	 *
+	 * @param buffer the buffer to write to
+	 * @param offset the offset into our storage to read from
+	 * This method is currently (Oct 2008) only used by test code. Perhaps it can be deleted
+	 */
+	void read(byte[] buffer, int offset) {
+		int len = buffer.length;
 
-        _big_store = new BigBlockStore(bigBlocks);
-        _property  = new DocumentProperty(name, _size);
-        _property.setDocument(this);
-        if (_property.shouldUseSmallBlocks())
-        {
-            _small_store =
-                new SmallBlockStore(SmallDocumentBlock.convert(bigBlocks,
-                    _size));
-            _big_store   = new BigBlockStore(new DocumentBlock[ 0 ]);
-        }
-        else
-        {
-            _small_store = new SmallBlockStore(new BlockWritable[ 0 ]);
-        }
-    }
+		DataInputBlock currentBlock = getDataInputBlock(offset);
 
-    /**
-     * Constructor
-     *
-     * @param name the name of the POIFSDocument
-     * @param size the length of the POIFSDocument
-     * @param path the path of the POIFSDocument
-     * @param writer the writer who will eventually write the document
-     *               contents
-     *
-     * @exception IOException thrown on read errors
-     */
+		int blockAvailable = currentBlock.available();
+		if (blockAvailable > len) {
+			currentBlock.readFully(buffer, 0, len);
+			return;
+		}
+		// else read big amount in chunks
+		int remaining = len;
+		int writePos = 0;
+		int currentOffset = offset;
+		while (remaining > 0) {
+			boolean blockIsExpiring = remaining >= blockAvailable;
+			int reqSize;
+			if (blockIsExpiring) {
+				reqSize = blockAvailable;
+			} else {
+				reqSize = remaining;
+			}
+			currentBlock.readFully(buffer, writePos, reqSize);
+			remaining-=reqSize;
+			writePos+=reqSize;
+			currentOffset += reqSize;
+			if (blockIsExpiring) {
+				if (currentOffset == _size) {
+					if (remaining > 0) {
+						throw new IllegalStateException("reached end of document stream unexpectedly");
+					}
+					currentBlock = null;
+					break;
+				}
+				currentBlock = getDataInputBlock(currentOffset);
+				blockAvailable = currentBlock.available();
+			}
+		}
+	}
 
-    public POIFSDocument(final String name, final int size,
-                         final POIFSDocumentPath path,
-                         final POIFSWriterListener writer)
-        throws IOException
-    {
-        _size     = size;
-        _property = new DocumentProperty(name, _size);
-        _property.setDocument(this);
-        if (_property.shouldUseSmallBlocks())
-        {
-            _small_store = new SmallBlockStore(path, name, size, writer);
-            _big_store   = new BigBlockStore(new Object[ 0 ]);
-        }
-        else
-        {
-            _small_store = new SmallBlockStore(new BlockWritable[ 0 ]);
-            _big_store   = new BigBlockStore(path, name, size, writer);
-        }
-    }
+	/**
+	 * @return <code>null</code> if <tt>offset</tt> points to the end of the document stream
+	 */
+	DataInputBlock getDataInputBlock(int offset) {
+		if (offset >= _size) {
+			if (offset > _size) {
+				throw new RuntimeException("Request for Offset " + offset + " doc size is " + _size);
+			}
+			return null;
+		}
+		if (_property.shouldUseSmallBlocks()) {
+			return SmallDocumentBlock.getDataInputBlock(_small_store.getBlocks(), offset);
+		}
+		return DocumentBlock.getDataInputBlock(_big_store.getBlocks(), offset);
+	}
 
-    /**
-     * return the array of SmallDocumentBlocks used
-     *
-     * @return array of SmallDocumentBlocks; may be empty, cannot be null
-     */
+	/**
+	 * @return the instance's DocumentProperty
+	 */
 
-    public BlockWritable [] getSmallBlocks()
-    {
-        return _small_store.getBlocks();
-    }
+	DocumentProperty getDocumentProperty() {
+		return _property;
+	}
 
-    /**
-     * @return size of the document
-     */
+	/* ********** START implementation of BlockWritable ********** */
 
-    public int getSize()
-    {
-        return _size;
-    }
+	/**
+	 * Write the storage to an OutputStream
+	 *
+	 * @param stream the OutputStream to which the stored data should be written
+	 */
+	public void writeBlocks(OutputStream stream) throws IOException {
+		_big_store.writeBlocks(stream);
+	}
 
-    /**
-     * read data from the internal stores
-     *
-     * @param buffer the buffer to write to
-     * @param offset the offset into our storage to read from
-     */
+	/* **********  END  implementation of BlockWritable ********** */
+	/* ********** START implementation of BATManaged ********** */
 
-    void read(final byte [] buffer, final int offset)
-    {
-        if (_property.shouldUseSmallBlocks())
-        {
-            SmallDocumentBlock.read(_small_store.getBlocks(), buffer, offset);
-        }
-        else
-        {
-            DocumentBlock.read(_big_store.getBlocks(), buffer, offset);
-        }
-    }
+	/**
+	 * Return the number of BigBlock's this instance uses
+	 *
+	 * @return count of BigBlock instances
+	 */
+	public int countBlocks() {
+		return _big_store.countBlocks();
+	}
 
-    /**
-     * Get the DocumentProperty
-     *
-     * @return the instance's DocumentProperty
-     */
+	/**
+	 * Set the start block for this instance
+	 *
+	 * @param index index into the array of blocks making up the filesystem
+	 */
+	public void setStartBlock(int index) {
+		_property.setStartBlock(index);
+	}
 
-    DocumentProperty getDocumentProperty()
-    {
-        return _property;
-    }
+	/* **********  END  implementation of BATManaged ********** */
+	/* ********** START begin implementation of POIFSViewable ********** */
 
-    /* ********** START implementation of BlockWritable ********** */
+	/**
+	 * Get an array of objects, some of which may implement POIFSViewable
+	 *
+	 * @return an array of Object; may not be null, but may be empty
+	 */
+	public Object[] getViewableArray() {
+		Object[] results = new Object[1];
+		String result;
 
-    /**
-     * Write the storage to an OutputStream
-     *
-     * @param stream the OutputStream to which the stored data should
-     *               be written
-     *
-     * @exception IOException on problems writing to the specified
-     *            stream
-     */
+		try {
+			ByteArrayOutputStream output = new ByteArrayOutputStream();
+			BlockWritable[] blocks = null;
 
-    public void writeBlocks(final OutputStream stream)
-        throws IOException
-    {
-        _big_store.writeBlocks(stream);
-    }
+			if (_big_store.isValid()) {
+				blocks = _big_store.getBlocks();
+			} else if (_small_store.isValid()) {
+				blocks = _small_store.getBlocks();
+			}
+			if (blocks != null) {
+				for (int k = 0; k < blocks.length; k++) {
+					blocks[k].writeBlocks(output);
+				}
+				byte[] data = output.toByteArray();
 
-    /* **********  END  implementation of BlockWritable ********** */
-    /* ********** START implementation of BATManaged ********** */
+				if (data.length > _property.getSize()) {
+					byte[] tmp = new byte[_property.getSize()];
 
-    /**
-     * Return the number of BigBlock's this instance uses
-     *
-     * @return count of BigBlock instances
-     */
-
-    public int countBlocks()
-    {
-        return _big_store.countBlocks();
-    }
-
-    /**
-     * Set the start block for this instance
-     *
-     * @param index index into the array of blocks making up the
-     *        filesystem
-     */
-
-    public void setStartBlock(final int index)
-    {
-        _property.setStartBlock(index);
-    }
-
-    /* **********  END  implementation of BATManaged ********** */
-    /* ********** START begin implementation of POIFSViewable ********** */
-
-    /**
-     * Get an array of objects, some of which may implement
-     * POIFSViewable
-     *
-     * @return an array of Object; may not be null, but may be empty
-     */
-
-    public Object [] getViewableArray()
-    {
-        Object[] results = new Object[ 1 ];
-        String   result;
-
-        try
-        {
-            ByteArrayOutputStream output = new ByteArrayOutputStream();
-            BlockWritable[]       blocks = null;
-
-            if (_big_store.isValid())
-            {
-                blocks = _big_store.getBlocks();
-            }
-            else if (_small_store.isValid())
-            {
-                blocks = _small_store.getBlocks();
-            }
-            if (blocks != null)
-            {
-                for (int k = 0; k < blocks.length; k++)
-                {
-                    blocks[ k ].writeBlocks(output);
-                }
-                byte[] data = output.toByteArray();
-
-                if (data.length > _property.getSize())
-                {
-                    byte[] tmp = new byte[ _property.getSize() ];
-
-                    System.arraycopy(data, 0, tmp, 0, tmp.length);
-                    data = tmp;
-                }
-                output = new ByteArrayOutputStream();
-                HexDump.dump(data, 0, output, 0);
-                result = output.toString();
-            }
-            else
-            {
-                result = "<NO DATA>";
-            }
-        }
-        catch (IOException e)
-        {
-            result = e.getMessage();
-        }
-        results[ 0 ] = result;
-        return results;
-    }
-
-    /**
-     * Get an Iterator of objects, some of which may implement
-     * POIFSViewable
-     *
-     * @return an Iterator; may not be null, but may have an empty
-     * back end store
-     */
-
-    public Iterator getViewableIterator()
-    {
-        return Collections.EMPTY_LIST.iterator();
-    }
-
-    /**
-     * Give viewers a hint as to whether to call getViewableArray or
-     * getViewableIterator
-     *
-     * @return true if a viewer should call getViewableArray, false if
-     *         a viewer should call getViewableIterator
-     */
-
-    public boolean preferArray()
-    {
-        return true;
-    }
-
-    /**
-     * Provides a short description of the object, to be used when a
-     * POIFSViewable object has not provided its contents.
-     *
-     * @return short description
-     */
-
-    public String getShortDescription()
-    {
-        StringBuffer buffer = new StringBuffer();
-
-        buffer.append("Document: \"").append(_property.getName())
-            .append("\"");
-        buffer.append(" size = ").append(getSize());
-        return buffer.toString();
-    }
-
-    /* **********  END  begin implementation of POIFSViewable ********** */
-    private class SmallBlockStore
-    {
-        private SmallDocumentBlock[] smallBlocks;
-        private POIFSDocumentPath    path;
-        private String               name;
-        private int                  size;
-        private POIFSWriterListener  writer;
-
-        /**
-         * Constructor
-         *
-         * @param blocks blocks to construct the store from
-         */
-
-        SmallBlockStore(final Object [] blocks)
-        {
-            smallBlocks = new SmallDocumentBlock[ blocks.length ];
-            for (int j = 0; j < blocks.length; j++)
-            {
-                smallBlocks[ j ] = ( SmallDocumentBlock ) blocks[ j ];
-            }
-            this.path   = null;
-            this.name   = null;
-            this.size   = -1;
-            this.writer = null;
-        }
-
-        /**
-         * Constructor for a small block store that will be written
-         * later
-         *
-         * @param path path of the document
-         * @param name name of the document
-         * @param size length of the document
-         * @param writer the object that will eventually write the document
-         */
-
-        SmallBlockStore(final POIFSDocumentPath path, final String name,
-                        final int size, final POIFSWriterListener writer)
-        {
-            smallBlocks = new SmallDocumentBlock[ 0 ];
-            this.path   = path;
-            this.name   = name;
-            this.size   = size;
-            this.writer = writer;
-        }
-
-        /**
-         * @return true if this store is a valid source of data
-         */
-
-        boolean isValid()
-        {
-            return ((smallBlocks.length > 0) || (writer != null));
-        }
+					System.arraycopy(data, 0, tmp, 0, tmp.length);
+					data = tmp;
+				}
+				output = new ByteArrayOutputStream();
+				HexDump.dump(data, 0, output, 0);
+				result = output.toString();
+			} else {
+				result = "<NO DATA>";
+			}
+		} catch (IOException e) {
+			result = e.getMessage();
+		}
+		results[0] = result;
+		return results;
+	}
 
-        /**
-         * @return the SmallDocumentBlocks
-         */
+	/**
+	 * Get an Iterator of objects, some of which may implement POIFSViewable
+	 *
+	 * @return an Iterator; may not be null, but may have an empty back end
+	 *		 store
+	 */
+	public Iterator getViewableIterator() {
+		return Collections.EMPTY_LIST.iterator();
+	}
 
-        BlockWritable [] getBlocks()
-        {
-            if (isValid() && (writer != null))
-            {
-                ByteArrayOutputStream stream  =
-                    new ByteArrayOutputStream(size);
-                DocumentOutputStream  dstream =
-                    new DocumentOutputStream(stream, size);
+	/**
+	 * Give viewers a hint as to whether to call getViewableArray or
+	 * getViewableIterator
+	 *
+	 * @return <code>true</code> if a viewer should call getViewableArray,
+	 *		 <code>false</code> if a viewer should call getViewableIterator
+	 */
+	public boolean preferArray() {
+		return true;
+	}
 
-                writer.processPOIFSWriterEvent(new POIFSWriterEvent(dstream,
-                        path, name, size));
-                smallBlocks = SmallDocumentBlock.convert(stream.toByteArray(),
-                                                         size);
-            }
-            return smallBlocks;
-        }
-    }   // end private class SmallBlockStore
+	/**
+	 * Provides a short description of the object, to be used when a
+	 * POIFSViewable object has not provided its contents.
+	 *
+	 * @return short description
+	 */
+	public String getShortDescription() {
+		StringBuffer buffer = new StringBuffer();
 
-    private class BigBlockStore
-    {
-        private DocumentBlock[]     bigBlocks;
-        private POIFSDocumentPath   path;
-        private String              name;
-        private int                 size;
-        private POIFSWriterListener writer;
+		buffer.append("Document: \"").append(_property.getName()).append("\"");
+		buffer.append(" size = ").append(getSize());
+		return buffer.toString();
+	}
 
-        /**
-         * Constructor
-         *
-         * @param blocks the blocks making up the store
-         *
-         * @exception IOException on I/O error
-         */
+	/* **********  END  begin implementation of POIFSViewable ********** */
+	private static final class SmallBlockStore {
+		private SmallDocumentBlock[] _smallBlocks;
+		private final POIFSDocumentPath _path;
+		private final String _name;
+		private final int _size;
+		private final POIFSWriterListener _writer;
+		private final POIFSBigBlockSize _bigBlockSize;
 
-        BigBlockStore(final Object [] blocks)
-            throws IOException
-        {
-            bigBlocks = new DocumentBlock[ blocks.length ];
-            for (int j = 0; j < blocks.length; j++)
-            {
-                if (blocks[ j ] instanceof DocumentBlock)
-                {
-                    bigBlocks[ j ] = ( DocumentBlock ) blocks[ j ];
-                }
-                else
-                {
-                    bigBlocks[ j ] =
-                        new DocumentBlock(( RawDataBlock ) blocks[ j ]);
-                }
-            }
-            this.path   = null;
-            this.name   = null;
-            this.size   = -1;
-            this.writer = null;
-        }
+		/**
+		 * Constructor
+		 *
+		 * @param blocks blocks to construct the store from
+		 */
+		SmallBlockStore(POIFSBigBlockSize bigBlockSize, SmallDocumentBlock[] blocks) {
+		   _bigBlockSize = bigBlockSize;
+			_smallBlocks = blocks.clone();
+			this._path = null;
+			this._name = null;
+			this._size = -1;
+			this._writer = null;
+		}
 
-        /**
-         * Constructor for a big block store that will be written
-         * later
-         *
-         * @param path path of the document
-         * @param name name of the document
-         * @param size length of the document
-         * @param writer the object that will eventually write the
-         *               document
-         */
+		/**
+		 * Constructor for a small block store that will be written later
+		 *
+		 * @param path path of the document
+		 * @param name name of the document
+		 * @param size length of the document
+		 * @param writer the object that will eventually write the document
+		 */
+		SmallBlockStore(POIFSBigBlockSize bigBlockSize, POIFSDocumentPath path, 
+		                String name, int size, POIFSWriterListener writer) {
+		   _bigBlockSize = bigBlockSize;
+			_smallBlocks = new SmallDocumentBlock[0];
+			this._path = path;
+			this._name = name;
+			this._size = size;
+			this._writer = writer;
+		}
 
-        BigBlockStore(final POIFSDocumentPath path, final String name,
-                      final int size, final POIFSWriterListener writer)
-        {
-            bigBlocks   = new DocumentBlock[ 0 ];
-            this.path   = path;
-            this.name   = name;
-            this.size   = size;
-            this.writer = writer;
-        }
+		/**
+		 * @return <code>true</code> if this store is a valid source of data
+		 */
+		boolean isValid() {
+			return _smallBlocks.length > 0 || _writer != null;
+		}
 
-        /**
-         * @return true if this store is a valid source of data
-         */
+		/**
+		 * @return the SmallDocumentBlocks
+		 */
+		SmallDocumentBlock[] getBlocks() {
+			if (isValid() && _writer != null) {
+				ByteArrayOutputStream stream = new ByteArrayOutputStream(_size);
+				DocumentOutputStream dstream = new DocumentOutputStream(stream, _size);
 
-        boolean isValid()
-        {
-            return ((bigBlocks.length > 0) || (writer != null));
-        }
+				_writer.processPOIFSWriterEvent(new POIFSWriterEvent(dstream, _path, _name, _size));
+				_smallBlocks = SmallDocumentBlock.convert(_bigBlockSize, stream.toByteArray(), _size);
+			}
+			return _smallBlocks;
+		}
+	} // end private class SmallBlockStore
 
-        /**
-         * @return the DocumentBlocks
-         */
+	private static final class BigBlockStore {
+		private DocumentBlock[] bigBlocks;
+		private final POIFSDocumentPath _path;
+		private final String _name;
+		private final int _size;
+		private final POIFSWriterListener _writer;
+      private final POIFSBigBlockSize _bigBlockSize;
 
-        DocumentBlock [] getBlocks()
-        {
-            if (isValid() && (writer != null))
-            {
-                ByteArrayOutputStream stream  =
-                    new ByteArrayOutputStream(size);
-                DocumentOutputStream  dstream =
-                    new DocumentOutputStream(stream, size);
+		/**
+		 * Constructor
+		 *
+		 * @param blocks the blocks making up the store
+		 */
+		BigBlockStore(POIFSBigBlockSize bigBlockSize, DocumentBlock[] blocks) {
+		   _bigBlockSize = bigBlockSize;
+			bigBlocks = blocks.clone();
+			_path = null;
+			_name = null;
+			_size = -1;
+			_writer = null;
+		}
 
-                writer.processPOIFSWriterEvent(new POIFSWriterEvent(dstream,
-                        path, name, size));
-                bigBlocks = DocumentBlock.convert(stream.toByteArray(), size);
-            }
-            return bigBlocks;
-        }
+		/**
+		 * Constructor for a big block store that will be written later
+		 *
+		 * @param path path of the document
+		 * @param name name of the document
+		 * @param size length of the document
+		 * @param writer the object that will eventually write the document
+		 */
+		BigBlockStore(POIFSBigBlockSize bigBlockSize, POIFSDocumentPath path, 
+		              String name, int size, POIFSWriterListener writer) {
+		   _bigBlockSize = bigBlockSize;
+			bigBlocks = new DocumentBlock[0];
+			_path = path;
+			_name = name;
+			_size = size;
+			_writer = writer;
+		}
 
-        /**
-         * write the blocks to a stream
-         *
-         * @param stream the stream to which the data is to be written
-         *
-         * @exception IOException on error
-         */
+		/**
+		 * @return <code>true</code> if this store is a valid source of data
+		 */
+		boolean isValid() {
+			return bigBlocks.length > 0 || _writer != null;
+		}
 
-        void writeBlocks(OutputStream stream)
-            throws IOException
-        {
-            if (isValid())
-            {
-                if (writer != null)
-                {
-                    DocumentOutputStream dstream =
-                        new DocumentOutputStream(stream, size);
+		/**
+		 * @return the DocumentBlocks
+		 */
+		DocumentBlock[] getBlocks() {
+			if (isValid() && _writer != null) {
+				ByteArrayOutputStream stream = new ByteArrayOutputStream(_size);
+				DocumentOutputStream dstream = new DocumentOutputStream(stream, _size);
 
-                    writer.processPOIFSWriterEvent(
-                        new POIFSWriterEvent(dstream, path, name, size));
-                    dstream.writeFiller(countBlocks()
-                                        * POIFSConstants
-                                            .BIG_BLOCK_SIZE, DocumentBlock
-                                            .getFillByte());
-                }
-                else
-                {
-                    for (int k = 0; k < bigBlocks.length; k++)
-                    {
-                        bigBlocks[ k ].writeBlocks(stream);
-                    }
-                }
-            }
-        }
+				_writer.processPOIFSWriterEvent(new POIFSWriterEvent(dstream, _path, _name, _size));
+				bigBlocks = DocumentBlock.convert(_bigBlockSize, stream.toByteArray(), _size);
+			}
+			return bigBlocks;
+		}
 
-        /**
-         * @return number of big blocks making up this document
-         */
+		/**
+		 * write the blocks to a stream
+		 *
+		 * @param stream the stream to which the data is to be written
+		 */
+		void writeBlocks(OutputStream stream) throws IOException {
+			if (isValid()) {
+				if (_writer != null) {
+					DocumentOutputStream dstream = new DocumentOutputStream(stream, _size);
 
-        int countBlocks()
-        {
-            int rval = 0;
+					_writer.processPOIFSWriterEvent(new POIFSWriterEvent(dstream, _path, _name, _size));
+					dstream.writeFiller(countBlocks() * _bigBlockSize.getBigBlockSize(),
+							DocumentBlock.getFillByte());
+				} else {
+					for (int k = 0; k < bigBlocks.length; k++) {
+						bigBlocks[k].writeBlocks(stream);
+					}
+				}
+			}
+		}
 
-            if (isValid())
-            {
-                if (writer != null)
-                {
-                    rval = (size + POIFSConstants.BIG_BLOCK_SIZE - 1)
-                           / POIFSConstants.BIG_BLOCK_SIZE;
-                }
-                else
-                {
-                    rval = bigBlocks.length;
-                }
-            }
-            return rval;
-        }
-    }   // end private class BigBlockStore
-}       // end class POIFSDocument
+		/**
+		 * @return number of big blocks making up this document
+		 */
+		int countBlocks() {
 
+			if (isValid()) {
+				if (_writer == null) {
+					return bigBlocks.length;
+				}
+				return (_size + _bigBlockSize.getBigBlockSize() - 1)
+							/ _bigBlockSize.getBigBlockSize();
+			}
+			return 0;
+		}
+	} // end private class BigBlockStore
+}
diff --git a/src/java/org/apache/poi/poifs/filesystem/POIFSDocumentPath.java b/src/java/org/apache/poi/poifs/filesystem/POIFSDocumentPath.java
index 9617d68..dc1539a 100644
--- a/src/java/org/apache/poi/poifs/filesystem/POIFSDocumentPath.java
+++ b/src/java/org/apache/poi/poifs/filesystem/POIFSDocumentPath.java
@@ -21,6 +21,9 @@
 
 import java.io.File;
 
+import org.apache.poi.util.POILogFactory;
+import org.apache.poi.util.POILogger;
+
 /**
  * Class POIFSDocumentPath
  *
@@ -30,6 +33,8 @@
 
 public class POIFSDocumentPath
 {
+    private static final POILogger log = POILogFactory.getLogger(POIFSDocumentPath.class);
+          
     private String[] components;
     private int      hashcode = 0;
 
@@ -125,12 +130,17 @@
         {
             for (int j = 0; j < components.length; j++)
             {
-                if ((components[ j ] == null)
-                        || (components[ j ].length() == 0))
+                if (components[ j ] == null)
                 {
                     throw new IllegalArgumentException(
-                        "components cannot contain null or empty strings");
+                        "components cannot contain null");
                 }
+                if (components[ j ].length() == 0)
+                {
+                    log.log(POILogger.WARN, "Directory under " + path + " has an empty name, " +
+                            "not all OLE2 readers will handle this file correctly!");
+                }
+                
                 this.components[ j + path.components.length ] =
                     components[ j ];
             }
diff --git a/src/java/org/apache/poi/poifs/filesystem/POIFSFileSystem.java b/src/java/org/apache/poi/poifs/filesystem/POIFSFileSystem.java
index 92348ce..acc8a4b 100644
--- a/src/java/org/apache/poi/poifs/filesystem/POIFSFileSystem.java
+++ b/src/java/org/apache/poi/poifs/filesystem/POIFSFileSystem.java
@@ -15,7 +15,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 
 package org.apache.poi.poifs.filesystem;
 
@@ -31,6 +31,7 @@
 import java.util.Iterator;
 import java.util.List;
 
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.poifs.dev.POIFSViewable;
 import org.apache.poi.poifs.property.DirectoryProperty;
@@ -42,11 +43,12 @@
 import org.apache.poi.poifs.storage.BlockList;
 import org.apache.poi.poifs.storage.BlockWritable;
 import org.apache.poi.poifs.storage.HeaderBlockConstants;
-import org.apache.poi.poifs.storage.HeaderBlockReader;
+import org.apache.poi.poifs.storage.HeaderBlock;
 import org.apache.poi.poifs.storage.HeaderBlockWriter;
 import org.apache.poi.poifs.storage.RawDataBlockList;
 import org.apache.poi.poifs.storage.SmallBlockTableReader;
 import org.apache.poi.poifs.storage.SmallBlockTableWriter;
+import org.apache.poi.util.CloseIgnoringInputStream;
 import org.apache.poi.util.IOUtils;
 import org.apache.poi.util.LongField;
 import org.apache.poi.util.POILogFactory;
@@ -64,47 +66,32 @@
 {
 	private static final POILogger _logger =
 		POILogFactory.getLogger(POIFSFileSystem.class);
-    
-    private static final class CloseIgnoringInputStream extends InputStream {
 
-        private final InputStream _is;
-        public CloseIgnoringInputStream(InputStream is) {
-            _is = is;
-        }
-        public int read() throws IOException {
-            return _is.read();
-        }
-        public int read(byte[] b, int off, int len) throws IOException {
-            return _is.read(b, off, len);
-        }
-        public void close() {
-            // do nothing
-        }
-    }
-    
     /**
      * Convenience method for clients that want to avoid the auto-close behaviour of the constructor.
      */
     public static InputStream createNonClosingInputStream(InputStream is) {
         return new CloseIgnoringInputStream(is);
     }
-    
+
     private PropertyTable _property_table;
     private List          _documents;
     private DirectoryNode _root;
-    
+
     /**
      * What big block size the file uses. Most files
      *  use 512 bytes, but a few use 4096
      */
-    private int bigBlockSize = POIFSConstants.BIG_BLOCK_SIZE;
+    private POIFSBigBlockSize bigBlockSize = 
+       POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS;
 
     /**
      * Constructor, intended for writing
      */
     public POIFSFileSystem()
     {
-        _property_table = new PropertyTable();
+        HeaderBlock header_block = new HeaderBlock(bigBlockSize);
+        _property_table = new PropertyTable(header_block);
         _documents      = new ArrayList();
         _root           = null;
     }
@@ -112,20 +99,20 @@
     /**
      * Create a POIFSFileSystem from an <tt>InputStream</tt>.  Normally the stream is read until
      * EOF.  The stream is always closed.<p/>
-     * 
-     * Some streams are usable after reaching EOF (typically those that return <code>true</code> 
-     * for <tt>markSupported()</tt>).  In the unlikely case that the caller has such a stream 
+     *
+     * Some streams are usable after reaching EOF (typically those that return <code>true</code>
+     * for <tt>markSupported()</tt>).  In the unlikely case that the caller has such a stream
      * <i>and</i> needs to use it after this constructor completes, a work around is to wrap the
      * stream in order to trap the <tt>close()</tt> call.  A convenience method (
      * <tt>createNonClosingInputStream()</tt>) has been provided for this purpose:
      * <pre>
      * InputStream wrappedStream = POIFSFileSystem.createNonClosingInputStream(is);
      * HSSFWorkbook wb = new HSSFWorkbook(wrappedStream);
-     * is.reset(); 
-     * doSomethingElse(is); 
+     * is.reset();
+     * doSomethingElse(is);
      * </pre>
      * Note also the special case of <tt>ByteArrayInputStream</tt> for which the <tt>close()</tt>
-     * method does nothing. 
+     * method does nothing.
      * <pre>
      * ByteArrayInputStream bais = ...
      * HSSFWorkbook wb = new HSSFWorkbook(bais); // calls bais.close() !
@@ -144,49 +131,57 @@
         this();
         boolean success = false;
 
-        HeaderBlockReader header_block_reader;
+        HeaderBlock header_block;
         RawDataBlockList data_blocks;
         try {
             // read the header block from the stream
-            header_block_reader = new HeaderBlockReader(stream);
-            bigBlockSize = header_block_reader.getBigBlockSize();
-            
+            header_block = new HeaderBlock(stream);
+            bigBlockSize = header_block.getBigBlockSize();
+
             // read the rest of the stream into blocks
             data_blocks = new RawDataBlockList(stream, bigBlockSize);
             success = true;
         } finally {
             closeInputStream(stream, success);
         }
-        
+
 
         // set up the block allocation table (necessary for the
         // data_blocks to be manageable
-        new BlockAllocationTableReader(header_block_reader.getBATCount(),
-                                       header_block_reader.getBATArray(),
-                                       header_block_reader.getXBATCount(),
-                                       header_block_reader.getXBATIndex(),
+        new BlockAllocationTableReader(header_block.getBigBlockSize(),
+                                       header_block.getBATCount(),
+                                       header_block.getBATArray(),
+                                       header_block.getXBATCount(),
+                                       header_block.getXBATIndex(),
                                        data_blocks);
 
         // get property table from the document
         PropertyTable properties =
-            new PropertyTable(header_block_reader.getPropertyStart(),
-                              data_blocks);
+            new PropertyTable(header_block, data_blocks);
 
         // init documents
-        processProperties(SmallBlockTableReader
-            .getSmallDocumentBlocks(data_blocks, properties
-                .getRoot(), header_block_reader
-                    .getSBATStart()), data_blocks, properties.getRoot()
-                        .getChildren(), null);
+        processProperties(
+        		SmallBlockTableReader.getSmallDocumentBlocks(
+        		      bigBlockSize, data_blocks, properties.getRoot(),
+        				header_block.getSBATStart()
+        		),
+        		data_blocks,
+        		properties.getRoot().getChildren(),
+        		null,
+        		header_block.getPropertyStart()
+        );
+
+        // For whatever reason CLSID of root is always 0.
+        getRoot().setStorageClsid(properties.getRoot().getStorageClsid());
     }
     /**
      * @param stream the stream to be closed
      * @param success <code>false</code> if an exception is currently being thrown in the calling method
      */
     private void closeInputStream(InputStream stream, boolean success) {
-        
+
         if(stream.markSupported() && !(stream instanceof ByteArrayInputStream)) {
-            String msg = "POIFS is closing the supplied input stream of type (" 
+            String msg = "POIFS is closing the supplied input stream of type ("
                     + stream.getClass().getName() + ") which supports mark/reset.  "
                     + "This will be a problem for the caller if the stream will still be used.  "
                     + "If that is the case the caller should wrap the input stream to avoid this close logic.  "
@@ -199,7 +194,7 @@
             if(success) {
                 throw new RuntimeException(e);
             }
-            // else not success? Try block did not complete normally 
+            // else not success? Try block did not complete normally
             // just print stack trace and leave original ex to be thrown
             e.printStackTrace();
         }
@@ -207,15 +202,15 @@
 
     /**
      * Checks that the supplied InputStream (which MUST
-     *  support mark and reset, or be a PushbackInputStream) 
+     *  support mark and reset, or be a PushbackInputStream)
      *  has a POIFS (OLE2) header at the start of it.
      * If your InputStream does not support mark / reset,
      *  then wrap it in a PushBackInputStream, then be
      *  sure to always use that, and not the original!
-     * @param inp An InputStream which supports either mark/reset, or is a PushbackInputStream 
+     * @param inp An InputStream which supports either mark/reset, or is a PushbackInputStream
      */
     public static boolean hasPOIFSHeader(InputStream inp) throws IOException {
-        // We want to peek at the first 8 bytes 
+        // We want to peek at the first 8 bytes
         inp.mark(8);
 
         byte[] header = new byte[8];
@@ -229,7 +224,7 @@
         } else {
             inp.reset();
         }
-        
+
         // Did it match the signature?
         return (signature.get() == HeaderBlockConstants._signature);
     }
@@ -288,7 +283,7 @@
     {
         return getRoot().createDirectory(name);
     }
-    
+
     /**
      * Write the filesystem out
      *
@@ -307,11 +302,11 @@
 
         // create the small block store, and the SBAT
         SmallBlockTableWriter      sbtw       =
-            new SmallBlockTableWriter(_documents, _property_table.getRoot());
+            new SmallBlockTableWriter(bigBlockSize, _documents, _property_table.getRoot());
 
         // create the block allocation table
         BlockAllocationTableWriter bat        =
-            new BlockAllocationTableWriter();
+            new BlockAllocationTableWriter(bigBlockSize);
 
         // create a list of BATManaged objects: the documents plus the
         // property table and the small block table
@@ -349,7 +344,7 @@
         int               batStartBlock       = bat.createBlocks();
 
         // get the extended block allocation table blocks
-        HeaderBlockWriter header_block_writer = new HeaderBlockWriter();
+        HeaderBlockWriter header_block_writer = new HeaderBlockWriter(bigBlockSize);
         BATBlock[]        xbat_blocks         =
             header_block_writer.setBATBlocks(bat.countBlocks(),
                                              batStartBlock);
@@ -491,7 +486,8 @@
     private void processProperties(final BlockList small_blocks,
                                    final BlockList big_blocks,
                                    final Iterator properties,
-                                   final DirectoryNode dir)
+                                   final DirectoryNode dir,
+                                   final int headerPropertiesStartAt)
         throws IOException
     {
         while (properties.hasNext())
@@ -511,7 +507,8 @@
 
                 processProperties(
                     small_blocks, big_blocks,
-                    (( DirectoryProperty ) property).getChildren(), new_dir);
+                    (( DirectoryProperty ) property).getChildren(),
+                    new_dir, headerPropertiesStartAt);
             }
             else
             {
@@ -522,14 +519,15 @@
                 if (property.shouldUseSmallBlocks())
                 {
                     document =
-                        new POIFSDocument(name, small_blocks
-                            .fetchBlocks(startBlock), size);
+                        new POIFSDocument(name,
+                                          small_blocks.fetchBlocks(startBlock, headerPropertiesStartAt),
+                                          size);
                 }
                 else
                 {
                     document =
                         new POIFSDocument(name,
-                                          big_blocks.fetchBlocks(startBlock),
+                                          big_blocks.fetchBlocks(startBlock, headerPropertiesStartAt),
                                           size);
                 }
                 parent.createDocument(document);
@@ -552,10 +550,7 @@
         {
             return (( POIFSViewable ) getRoot()).getViewableArray();
         }
-        else
-        {
-            return new Object[ 0 ];
-        }
+        return new Object[ 0 ];
     }
 
     /**
@@ -572,10 +567,7 @@
         {
             return (( POIFSViewable ) getRoot()).getViewableIterator();
         }
-        else
-        {
-            return Collections.EMPTY_LIST.iterator();
-        }
+        return Collections.EMPTY_LIST.iterator();
     }
 
     /**
@@ -607,9 +599,15 @@
      * @return The Big Block size, normally 512 bytes, sometimes 4096 bytes
      */
     public int getBigBlockSize() {
-    	return bigBlockSize;
+    	return bigBlockSize.getBigBlockSize();
     }
-    
+    /**
+     * @return The Big Block size, normally 512 bytes, sometimes 4096 bytes
+     */
+    public POIFSBigBlockSize getBigBlockSizeDetails() {
+      return bigBlockSize;
+    }
+
     /* **********  END  begin implementation of POIFSViewable ********** */
 }   // end public class POIFSFileSystem
 
diff --git a/src/java/org/apache/poi/poifs/nio/ByteArrayBackedDataSource.java b/src/java/org/apache/poi/poifs/nio/ByteArrayBackedDataSource.java
new file mode 100644
index 0000000..24460a2
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/nio/ByteArrayBackedDataSource.java
@@ -0,0 +1,94 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.nio;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+
+/**
+ * A POIFS {@link DataSource} backed by a byte array.
+ */
+public class ByteArrayBackedDataSource extends DataSource {
+   private byte[] buffer;
+   private long size;
+   
+   public ByteArrayBackedDataSource(byte[] data, int size) {
+      this.buffer = data;
+      this.size = size;
+   }
+   public ByteArrayBackedDataSource(byte[] data) {
+      this(data, data.length);
+   }
+                
+   public ByteBuffer read(int length, long position) {
+      if(position >= size) {
+         throw new IndexOutOfBoundsException(
+               "Unable to read " + length + " bytes from " +
+               position + " in stream of length " + size
+         );
+      }
+      
+      int toRead = (int)Math.min(length, size - position);
+      return ByteBuffer.wrap(buffer, (int)position, toRead);
+   }
+   
+   public void write(ByteBuffer src, long position) {
+      // Extend if needed
+      long endPosition = position + src.capacity(); 
+      if(endPosition > buffer.length) {
+         extend(endPosition);
+      }
+      
+      // Now copy
+      src.get(buffer, (int)position, src.capacity());
+      
+      // Update size if needed
+      if(endPosition > size) {
+         size = endPosition;
+      }
+   }
+   
+   private void extend(long length) {
+      // Consider extending by a bit more than requested
+      long difference = length - buffer.length;
+      if(difference < buffer.length*0.25) {
+         difference = (long)(buffer.length*0.25);
+      }
+      if(difference < 4096) {
+         difference = 4096;
+      }
+
+      byte[] nb = new byte[(int)(difference+buffer.length)];
+      System.arraycopy(buffer, 0, nb, 0, (int)size);
+      buffer = nb;
+   }
+   
+   public void copyTo(OutputStream stream) throws IOException {
+      stream.write(buffer, 0, (int)size);
+   }
+   
+   public long size() {
+      return size;
+   }
+   
+   public void close() {
+      buffer = null;
+      size = -1;
+   }
+}
diff --git a/src/java/org/apache/poi/poifs/nio/DataSource.java b/src/java/org/apache/poi/poifs/nio/DataSource.java
new file mode 100644
index 0000000..f436676
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/nio/DataSource.java
@@ -0,0 +1,35 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.nio;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+
+/**
+ * Common definition of how we read and write bytes
+ */
+public abstract class DataSource {
+   public abstract ByteBuffer read(int length, long position) throws IOException;
+   public abstract void write(ByteBuffer src, long position) throws IOException;
+   public abstract long size() throws IOException;
+   /** Close the underlying stream */
+   public abstract void close() throws IOException;
+   /** Copies the contents to the specified OutputStream */
+   public abstract void copyTo(OutputStream stream) throws IOException;
+}
diff --git a/src/java/org/apache/poi/poifs/nio/FileBackedDataSource.java b/src/java/org/apache/poi/poifs/nio/FileBackedDataSource.java
new file mode 100644
index 0000000..ed2f7ce
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/nio/FileBackedDataSource.java
@@ -0,0 +1,88 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.nio;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.FileChannel;
+import java.nio.channels.WritableByteChannel;
+
+import org.apache.poi.util.IOUtils;
+
+/**
+ * A POIFS {@link DataSource} backed by a File
+ */
+public class FileBackedDataSource extends DataSource {
+   private FileChannel channel;
+   
+   public FileBackedDataSource(File file) throws FileNotFoundException {
+      if(!file.exists()) {
+         throw new FileNotFoundException(file.toString());
+      }
+      this.channel = (new RandomAccessFile(file, "r")).getChannel();
+   }
+   public FileBackedDataSource(FileChannel channel) {
+      this.channel = channel;
+   }
+   
+   public ByteBuffer read(int length, long position) throws IOException {
+      if(position >= size()) {
+         throw new IllegalArgumentException("Position " + position + " past the end of the file");
+      }
+
+      // Read
+      channel.position(position);
+      ByteBuffer dst = ByteBuffer.allocate(length);
+      int worked = IOUtils.readFully(channel, dst);
+      
+      // Check
+      if(worked == -1) {
+         throw new IllegalArgumentException("Position " + position + " past the end of the file");
+      }
+      
+      // Ready it for reading
+      dst.position(0);
+      
+      // All done
+      return dst;
+   }
+   
+   public void write(ByteBuffer src, long position) throws IOException {
+      channel.write(src, position);
+   }
+   
+   public void copyTo(OutputStream stream) throws IOException {
+      // Wrap the OutputSteam as a channel
+      WritableByteChannel out = Channels.newChannel(stream);
+      // Now do the transfer
+      channel.transferTo(0, channel.size(), out);
+   }
+   
+   public long size() throws IOException {
+      return channel.size();
+   }
+   
+   public void close() throws IOException {
+      channel.close();
+   }
+}
diff --git a/src/java/org/apache/poi/poifs/property/DirectoryProperty.java b/src/java/org/apache/poi/poifs/property/DirectoryProperty.java
index ece87ef..f263419 100644
--- a/src/java/org/apache/poi/poifs/property/DirectoryProperty.java
+++ b/src/java/org/apache/poi/poifs/property/DirectoryProperty.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,44 +14,35 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.property;
 
-import java.util.*;
-
 import java.io.IOException;
-
-import org.apache.poi.poifs.storage.SmallDocumentBlock;
+import java.util.*;
 
 /**
  * Directory property
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
+public class DirectoryProperty extends Property implements Parent { // TODO - fix instantiable superclass
 
-public class DirectoryProperty
-    extends Property
-    implements Parent
-{
+    /** List of Property instances */
+    private List<Property> _children;
 
-    // List of Property instances
-    private List _children;
-
-    // set of children's names
-    private Set  _children_names;
+    /** set of children's names */
+    private Set<String>  _children_names;
 
     /**
      * Default constructor
      *
      * @param name the name of the directory
      */
-
     public DirectoryProperty(String name)
     {
         super();
-        _children       = new ArrayList();
-        _children_names = new HashSet();
+        _children       = new ArrayList<Property>();
+        _children_names = new HashSet<String>();
         setName(name);
         setSize(0);
         setPropertyType(PropertyConstants.DIRECTORY_TYPE);
@@ -67,13 +57,12 @@
      * @param array byte data
      * @param offset offset into byte data
      */
-
     protected DirectoryProperty(final int index, final byte [] array,
                                 final int offset)
     {
         super(index, array, offset);
-        _children       = new ArrayList();
-        _children_names = new HashSet();
+        _children       = new ArrayList<Property>();
+        _children_names = new HashSet<String>();
     }
 
     /**
@@ -84,8 +73,7 @@
      *
      * @return true if the name change could be made, else false
      */
-
-    public boolean changeName(final Property property, final String newName)
+    public boolean changeName(Property property, String newName)
     {
         boolean result;
         String  oldName = property.getName();
@@ -116,8 +104,7 @@
      *
      * @return true if the Property could be deleted, else false
      */
-
-    public boolean deleteChild(final Property property)
+    public boolean deleteChild(Property property)
     {
         boolean result = _children.remove(property);
 
@@ -128,9 +115,7 @@
         return result;
     }
 
-    public static class PropertyComparator
-        implements Comparator
-    {
+    public static class PropertyComparator implements Comparator<Property> {
 
         /**
          * Object equality, implemented as object identity
@@ -139,7 +124,6 @@
          *
          * @return true if identical, else false
          */
-
         public boolean equals(Object o)
         {
             return this == o;
@@ -160,12 +144,11 @@
          *         zero           if o1 == o2,
          *         positive value if o1 >  o2.
          */
-
-        public int compare(Object o1, Object o2)
+        public int compare(Property o1, Property o2)
         {
             String VBA_PROJECT = "_VBA_PROJECT";
-            String name1  = (( Property ) o1).getName();
-            String name2  = (( Property ) o2).getName();
+            String name1  = o1.getName();
+            String name2  = o2.getName();
             int  result = name1.length() - name2.length();
 
             if (result == 0)
@@ -200,14 +183,11 @@
             }
             return result;
         }
-    }   // end private class PropertyComparator
-
-    /* ********** START extension of Property ********** */
+    }
 
     /**
      * @return true if a directory type Property
      */
-
     public boolean isDirectory()
     {
         return true;
@@ -217,13 +197,11 @@
      * Perform whatever activities need to be performed prior to
      * writing
      */
-
     protected void preWrite()
     {
         if (_children.size() > 0)
         {
-            Property[] children =
-                ( Property [] ) _children.toArray(new Property[ 0 ]);
+            Property[] children = _children.toArray(new Property[ 0 ]);
 
             Arrays.sort(children, new PropertyComparator());
             int midpoint = children.length / 2;
@@ -259,17 +237,13 @@
         }
     }
 
-    /* **********  END  extension of Property ********** */
-    /* ********** START implementation of Parent ********** */
-
     /**
      * Get an iterator over the children of this Parent; all elements
      * are instances of Property.
      *
      * @return Iterator of children; may refer to an empty collection
      */
-
-    public Iterator getChildren()
+    public Iterator<Property> getChildren()
     {
         return _children.iterator();
     }
@@ -282,7 +256,6 @@
      * @exception IOException if we already have a child with the same
      *                        name
      */
-
     public void addChild(final Property property)
         throws IOException
     {
@@ -295,7 +268,4 @@
         _children_names.add(name);
         _children.add(property);
     }
-
-    /* **********  END  implementation of Parent ********** */
-}   // end public class DirectoryProperty
-
+}
diff --git a/src/java/org/apache/poi/poifs/property/NPropertyTable.java b/src/java/org/apache/poi/poifs/property/NPropertyTable.java
new file mode 100644
index 0000000..36ded35
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/property/NPropertyTable.java
@@ -0,0 +1,128 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.property;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
+import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;
+import org.apache.poi.poifs.filesystem.NPOIFSStream;
+import org.apache.poi.poifs.storage.HeaderBlock;
+
+/**
+ * This class embodies the Property Table for a {@link NPOIFSFileSystem}; 
+ *  this is basically the directory for all of the documents in the
+ * filesystem.
+ */
+public final class NPropertyTable extends PropertyTableBase {
+    private POIFSBigBlockSize _bigBigBlockSize;
+
+    public NPropertyTable(HeaderBlock headerBlock)
+    {
+        super(headerBlock);
+        _bigBigBlockSize = headerBlock.getBigBlockSize();
+    }
+
+    /**
+     * reading constructor (used when we've read in a file and we want
+     * to extract the property table from it). Populates the
+     * properties thoroughly
+     *
+     * @param headerBlock the header block of the file
+     * @param filesystem the filesystem to read from
+     *
+     * @exception IOException if anything goes wrong (which should be
+     *            a result of the input being NFG)
+     */
+    public NPropertyTable(final HeaderBlock headerBlock,
+                          final NPOIFSFileSystem filesystem)
+        throws IOException
+    {
+        super(
+              headerBlock,
+              buildProperties(
+                    (new NPOIFSStream(filesystem, headerBlock.getPropertyStart())).iterator(),
+                    headerBlock.getBigBlockSize()
+              )
+        );
+        _bigBigBlockSize = headerBlock.getBigBlockSize();
+    }
+    
+    /**
+     * Builds
+     * @param startAt
+     * @param filesystem
+     * @return
+     * @throws IOException
+     */
+    private static List<Property> buildProperties(final Iterator<ByteBuffer> dataSource,
+          final POIFSBigBlockSize bigBlockSize) throws IOException
+    {
+       List<Property> properties = new ArrayList<Property>();
+       while(dataSource.hasNext()) {
+          ByteBuffer bb = dataSource.next();
+          
+          // Turn it into an array
+          byte[] data;
+          if(bb.hasArray() && bb.arrayOffset() == 0 && 
+                bb.array().length == bigBlockSize.getBigBlockSize()) {
+             data = bb.array();
+          } else {
+             data = new byte[bigBlockSize.getBigBlockSize()];
+             bb.get(data, 0, data.length);
+          }
+          
+          PropertyFactory.convertToProperties(data, properties);
+       }
+       return properties;
+    }
+
+    /**
+     * Return the number of BigBlock's this instance uses
+     *
+     * @return count of BigBlock instances
+     */
+    public int countBlocks()
+    {
+       int size = _properties.size() * POIFSConstants.PROPERTY_SIZE;
+       return (int)Math.ceil(size / _bigBigBlockSize.getBigBlockSize());
+    }
+ 
+    /**
+     * Writes the properties out into the given low-level stream
+     */
+    public void write(NPOIFSStream stream) throws IOException {
+       // TODO - Use a streaming write
+       ByteArrayOutputStream baos = new ByteArrayOutputStream();
+       for(Property property : _properties) {
+          property.writeData(baos);
+       }
+       stream.updateContents(baos.toByteArray());
+       
+       // Update the start position if needed
+       if(getStartBlock() != stream.getStartBlock()) {
+          setStartBlock(stream.getStartBlock());
+       }
+    }
+}
diff --git a/src/java/org/apache/poi/poifs/property/Property.java b/src/java/org/apache/poi/poifs/property/Property.java
index fe0e8d9..127dab1 100644
--- a/src/java/org/apache/poi/poifs/property/Property.java
+++ b/src/java/org/apache/poi/poifs/property/Property.java
@@ -15,7 +15,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 
 package org.apache.poi.poifs.property;
 
@@ -39,9 +39,7 @@
  * @author Marc Johnson (mjohnson at apache dot org)
  */
 
-public abstract class Property
-    implements Child, POIFSViewable
-{
+public abstract class Property implements Child, POIFSViewable {
     static final private byte   _default_fill             = ( byte ) 0x00;
     static final private int    _name_size_offset         = 0x40;
     static final private int    _max_name_length          =
@@ -67,7 +65,7 @@
     static final protected byte _NODE_RED                 = 0;
 
     // documents must be at least this size to be stored in big blocks
-    static final private int    _big_block_minimum_bytes  = 4096;
+    static final private int    _big_block_minimum_bytes  = POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE;
     private String              _name;
     private ShortField          _name_size;
     private ByteField           _property_type;
@@ -88,10 +86,6 @@
     private Child               _next_child;
     private Child               _previous_child;
 
-    /**
-     * Default constructor
-     */
-
     protected Property()
     {
         _raw_data = new byte[ POIFSConstants.PROPERTY_SIZE ];
@@ -129,8 +123,7 @@
      * @param array byte data
      * @param offset offset into byte data
      */
-
-    protected Property(final int index, final byte [] array, final int offset)
+    protected Property(int index, byte [] array, int offset)
     {
         _raw_data = new byte[ POIFSConstants.PROPERTY_SIZE ];
         System.arraycopy(array, offset, _raw_data, 0,
@@ -187,8 +180,7 @@
      * @exception IOException on problems writing to the specified
      *            stream.
      */
-
-    public void writeData(final OutputStream stream)
+    public void writeData(OutputStream stream)
         throws IOException
     {
         stream.write(_raw_data);
@@ -200,8 +192,7 @@
      *
      * @param startBlock the start block index
      */
-
-    public void setStartBlock(final int startBlock)
+    public void setStartBlock(int startBlock)
     {
         _start_block.set(startBlock, _raw_data);
     }
@@ -209,7 +200,6 @@
     /**
      * @return the start block
      */
-
     public int getStartBlock()
     {
         return _start_block.get();
@@ -220,7 +210,6 @@
      *
      * @return size in bytes
      */
-
     public int getSize()
     {
         return _size.get();
@@ -232,7 +221,6 @@
      *
      * @return true if the size is less than _big_block_minimum_bytes
      */
-
     public boolean shouldUseSmallBlocks()
     {
         return Property.isSmall(_size.get());
@@ -246,8 +234,7 @@
      * @return true if the length is less than
      *         _big_block_minimum_bytes
      */
-
-    public static boolean isSmall(final int length)
+    public static boolean isSmall(int length)
     {
         return length < _big_block_minimum_bytes;
     }
@@ -257,7 +244,6 @@
      *
      * @return property name as String
      */
-
     public String getName()
     {
         return _name;
@@ -266,7 +252,6 @@
     /**
      * @return true if a directory type Property
      */
-
     abstract public boolean isDirectory();
 
     /**
@@ -284,7 +269,7 @@
      *
      * @param name the new name
      */
-    protected final void setName(final String name)
+    protected void setName(String name)
     {
         char[] char_array = name.toCharArray();
         int    limit      = Math.min(char_array.length, _max_name_length);
@@ -329,8 +314,7 @@
      *
      * @param propertyType the property type (root, file, directory)
      */
-
-    protected void setPropertyType(final byte propertyType)
+    protected void setPropertyType(byte propertyType)
     {
         _property_type.set(propertyType, _raw_data);
     }
@@ -340,8 +324,7 @@
      *
      * @param nodeColor the node color (red or black)
      */
-
-    protected void setNodeColor(final byte nodeColor)
+    protected void setNodeColor(byte nodeColor)
     {
         _node_color.set(nodeColor, _raw_data);
     }
@@ -351,8 +334,7 @@
      *
      * @param child the child property's index in the Property Table
      */
-
-    protected void setChildProperty(final int child)
+    protected void setChildProperty(int child)
     {
         _child_property.set(child, _raw_data);
     }
@@ -362,7 +344,6 @@
      *
      * @return child property index
      */
-
     protected int getChildIndex()
     {
         return _child_property.get();
@@ -373,8 +354,7 @@
      *
      * @param size the size of the document, in bytes
      */
-
-    protected void setSize(final int size)
+    protected void setSize(int size)
     {
         _size.set(size, _raw_data);
     }
@@ -385,8 +365,7 @@
      * @param index this Property's index within its containing
      *              Property Table
      */
-
-    protected void setIndex(final int index)
+    protected void setIndex(int index)
     {
         _index = index;
     }
@@ -396,7 +375,6 @@
      *
      * @return the index of this Property within its Property Table
      */
-
     protected int getIndex()
     {
         return _index;
@@ -406,7 +384,6 @@
      * Perform whatever activities need to be performed prior to
      * writing
      */
-
     abstract protected void preWrite();
 
     /**
@@ -414,7 +391,6 @@
      *
      * @return index of next sibling
      */
-
     int getNextChildIndex()
     {
         return _next_property.get();
@@ -425,7 +401,6 @@
      *
      * @return index of previous sibling
      */
-
     int getPreviousChildIndex()
     {
         return _previous_property.get();
@@ -438,20 +413,16 @@
      *
      * @return true if the index is valid
      */
-
     static boolean isValidIndex(int index)
     {
         return index != _NO_INDEX;
     }
 
-    /* ********** START implementation of Child ********** */
-
     /**
      * Get the next Child, if any
      *
      * @return the next Child; may return null
      */
-
     public Child getNextChild()
     {
         return _next_child;
@@ -462,7 +433,6 @@
      *
      * @return the previous Child; may return null
      */
-
     public Child getPreviousChild()
     {
         return _previous_child;
@@ -474,8 +444,7 @@
      * @param child the new 'next' child; may be null, which has the
      *              effect of saying there is no 'next' child
      */
-
-    public void setNextChild(final Child child)
+    public void setNextChild(Child child)
     {
         _next_child = child;
         _next_property.set((child == null) ? _NO_INDEX
@@ -489,8 +458,7 @@
      * @param child the new 'previous' child; may be null, which has
      *              the effect of saying there is no 'previous' child
      */
-
-    public void setPreviousChild(final Child child)
+    public void setPreviousChild(Child child)
     {
         _previous_child = child;
         _previous_property.set((child == null) ? _NO_INDEX
@@ -498,16 +466,12 @@
                                                    .getIndex(), _raw_data);
     }
 
-    /* **********  END  implementation of Child ********** */
-    /* ********** START begin implementation of POIFSViewable ********** */
-
     /**
      * Get an array of objects, some of which may implement
      * POIFSViewable
      *
      * @return an array of Object; may not be null, but may be empty
      */
-
     public Object [] getViewableArray()
     {
         Object[] results = new Object[ 5 ];
@@ -518,11 +482,11 @@
         long time = _days_1.get();
 
         time         <<= 32;
-        time         += (( long ) _seconds_1.get()) & 0x0000FFFFL;
+        time         += _seconds_1.get() & 0x0000FFFFL;
         results[ 3 ] = "Time 1        = " + time;
         time         = _days_2.get();
         time         <<= 32;
-        time         += (( long ) _seconds_2.get()) & 0x0000FFFFL;
+        time         += _seconds_2.get() & 0x0000FFFFL;
         results[ 4 ] = "Time 2        = " + time;
         return results;
     }
@@ -534,7 +498,6 @@
      * @return an Iterator; may not be null, but may have an empty
      * back end store
      */
-
     public Iterator getViewableIterator()
     {
         return Collections.EMPTY_LIST.iterator();
@@ -547,7 +510,6 @@
      * @return true if a viewer should call getViewableArray, false if
      *         a viewer should call getViewableIterator
      */
-
     public boolean preferArray()
     {
         return true;
@@ -559,7 +521,6 @@
      *
      * @return short description
      */
-
     public String getShortDescription()
     {
         StringBuffer buffer = new StringBuffer();
@@ -567,7 +528,4 @@
         buffer.append("Property: \"").append(getName()).append("\"");
         return buffer.toString();
     }
-
-    /* **********  END  begin implementation of POIFSViewable ********** */
-}   // end public abstract class Property
-
+}
diff --git a/src/java/org/apache/poi/poifs/property/PropertyFactory.java b/src/java/org/apache/poi/poifs/property/PropertyFactory.java
index a4036f9..38533b7 100644
--- a/src/java/org/apache/poi/poifs/property/PropertyFactory.java
+++ b/src/java/org/apache/poi/poifs/property/PropertyFactory.java
@@ -28,7 +28,7 @@
 
 /**
  * Factory for turning an array of RawDataBlock instances containing
- * Proprty data into an array of proper Property objects.
+ * Property data into an array of proper Property objects.
  *
  * The array produced may be sparse, in that any portion of data that
  * should correspond to a Property, but which does not map to a proper
@@ -40,7 +40,6 @@
 
 class PropertyFactory
 {
-
     // no need for an accessible constructor
     private PropertyFactory()
     {
@@ -56,48 +55,52 @@
      *
      * @exception IOException if any of the blocks are empty
      */
-
-    static List convertToProperties(ListManagedBlock [] blocks)
+    static List<Property> convertToProperties(ListManagedBlock [] blocks)
         throws IOException
     {
-        List properties = new ArrayList();
+        List<Property> properties = new ArrayList<Property>();
 
-        for (int j = 0; j < blocks.length; j++)
-        {
-            byte[] data           = blocks[ j ].getData();
-            int    property_count = data.length
-                                    / POIFSConstants.PROPERTY_SIZE;
-            int    offset         = 0;
-
-            for (int k = 0; k < property_count; k++)
-            {
-                switch (data[ offset + PropertyConstants.PROPERTY_TYPE_OFFSET ])
-                {
-
-                    case PropertyConstants.DIRECTORY_TYPE :
-                        properties
-                            .add(new DirectoryProperty(properties.size(),
-                                                       data, offset));
-                        break;
-
-                    case PropertyConstants.DOCUMENT_TYPE :
-                        properties.add(new DocumentProperty(properties.size(),
-                                                            data, offset));
-                        break;
-
-                    case PropertyConstants.ROOT_TYPE :
-                        properties.add(new RootProperty(properties.size(),
-                                                        data, offset));
-                        break;
-
-                    default :
-                        properties.add(null);
-                        break;
-                }
-                offset += POIFSConstants.PROPERTY_SIZE;
-            }
+        for (int j = 0; j < blocks.length; j++) {
+            byte[] data = blocks[ j ].getData();
+            convertToProperties(data, properties);
         }
         return properties;
     }
+    
+    static void convertToProperties(byte[] data, List<Property> properties)
+        throws IOException
+    {
+       int property_count = data.length / POIFSConstants.PROPERTY_SIZE;
+       int offset         = 0;
+
+       for (int k = 0; k < property_count; k++) {
+          switch (data[ offset + PropertyConstants.PROPERTY_TYPE_OFFSET ]) {
+          case PropertyConstants.DIRECTORY_TYPE :
+             properties.add(
+                   new DirectoryProperty(properties.size(), data, offset)
+             );
+             break;
+
+          case PropertyConstants.DOCUMENT_TYPE :
+             properties.add(
+                   new DocumentProperty(properties.size(), data, offset)
+             );
+             break;
+
+          case PropertyConstants.ROOT_TYPE :
+             properties.add(
+                   new RootProperty(properties.size(), data, offset)
+             );
+             break;
+
+          default :
+             properties.add(null);
+             break;
+          }
+          
+          offset += POIFSConstants.PROPERTY_SIZE;
+       }
+    }
+    
 }   // end package scope class PropertyFactory
 
diff --git a/src/java/org/apache/poi/poifs/property/PropertyTable.java b/src/java/org/apache/poi/poifs/property/PropertyTable.java
index 11c56e8..45a9734 100644
--- a/src/java/org/apache/poi/poifs/property/PropertyTable.java
+++ b/src/java/org/apache/poi/poifs/property/PropertyTable.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,46 +14,34 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.property;
 
 import java.io.IOException;
 import java.io.OutputStream;
 
-import java.util.*;
-
-import org.apache.poi.poifs.common.POIFSConstants;
-import org.apache.poi.poifs.filesystem.BATManaged;
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
+import org.apache.poi.poifs.filesystem.POIFSFileSystem;
 import org.apache.poi.poifs.storage.BlockWritable;
+import org.apache.poi.poifs.storage.HeaderBlock;
 import org.apache.poi.poifs.storage.PropertyBlock;
-import org.apache.poi.poifs.storage.RawDataBlock;
 import org.apache.poi.poifs.storage.RawDataBlockList;
 
 /**
- * This class embodies the Property Table for the filesystem; this is
- * basically the dsirectory for all of the documents in the
+ * This class embodies the Property Table for the {@link POIFSFileSystem}; 
+ *  this is basically the directory for all of the documents in the
  * filesystem.
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
+public final class PropertyTable extends PropertyTableBase implements BlockWritable {
+    private POIFSBigBlockSize _bigBigBlockSize;
+    private BlockWritable[]   _blocks;
 
-public class PropertyTable
-    implements BATManaged, BlockWritable
-{
-    private int             _start_block;
-    private List            _properties;
-    private BlockWritable[] _blocks;
-
-    /**
-     * Default constructor
-     */
-
-    public PropertyTable()
+    public PropertyTable(HeaderBlock headerBlock)
     {
-        _start_block = POIFSConstants.END_OF_CHAIN;
-        _properties  = new ArrayList();
-        addProperty(new RootProperty());
+        super(headerBlock);
+        _bigBigBlockSize = headerBlock.getBigBlockSize();
         _blocks = null;
     }
 
@@ -63,68 +50,32 @@
      * to extract the property table from it). Populates the
      * properties thoroughly
      *
-     * @param startBlock the first block of the property table
+     * @param headerBlock the header block of the file
      * @param blockList the list of blocks
      *
      * @exception IOException if anything goes wrong (which should be
      *            a result of the input being NFG)
      */
-
-    public PropertyTable(final int startBlock,
+    public PropertyTable(final HeaderBlock headerBlock,
                          final RawDataBlockList blockList)
         throws IOException
     {
-        _start_block = POIFSConstants.END_OF_CHAIN;
+        super(
+              headerBlock,
+              PropertyFactory.convertToProperties(
+                    blockList.fetchBlocks(headerBlock.getPropertyStart(), -1)
+              )
+        );
+        _bigBigBlockSize = headerBlock.getBigBlockSize();
         _blocks      = null;
-        _properties  =
-            PropertyFactory
-                .convertToProperties(blockList.fetchBlocks(startBlock));
-        populatePropertyTree(( DirectoryProperty ) _properties.get(0));
-    }
-
-    /**
-     * Add a property to the list of properties we manage
-     *
-     * @param property the new Property to manage
-     */
-
-    public void addProperty(final Property property)
-    {
-        _properties.add(property);
-    }
-
-    /**
-     * Remove a property from the list of properties we manage
-     *
-     * @param property the Property to be removed
-     */
-
-    public void removeProperty(final Property property)
-    {
-        _properties.remove(property);
-    }
-
-    /**
-     * Get the root property
-     *
-     * @return the root property
-     */
-
-    public RootProperty getRoot()
-    {
-
-        // it's always the first element in the List
-        return ( RootProperty ) _properties.get(0);
     }
 
     /**
      * Prepare to be written
      */
-
     public void preWrite()
     {
-        Property[] properties =
-            ( Property [] ) _properties.toArray(new Property[ 0 ]);
+        Property[] properties = _properties.toArray(new Property[_properties.size()]);
 
         // give each property its index
         for (int k = 0; k < properties.length; k++)
@@ -133,7 +84,7 @@
         }
 
         // allocate the blocks for the property table
-        _blocks = PropertyBlock.createPropertyBlockArray(_properties);
+        _blocks = PropertyBlock.createPropertyBlockArray(_bigBigBlockSize, _properties);
 
         // prepare each property for writing
         for (int k = 0; k < properties.length; k++)
@@ -141,62 +92,12 @@
             properties[ k ].preWrite();
         }
     }
-
-    /**
-     * Get the start block for the property table
-     *
-     * @return start block index
-     */
-
-    public int getStartBlock()
-    {
-        return _start_block;
-    }
-
-    private void populatePropertyTree(DirectoryProperty root)
-        throws IOException
-    {
-        int index = root.getChildIndex();
-
-        if (!Property.isValidIndex(index))
-        {
-
-            // property has no children
-            return;
-        }
-        Stack children = new Stack();
-
-        children.push(_properties.get(index));
-        while (!children.empty())
-        {
-            Property property = ( Property ) children.pop();
-
-            root.addChild(property);
-            if (property.isDirectory())
-            {
-                populatePropertyTree(( DirectoryProperty ) property);
-            }
-            index = property.getPreviousChildIndex();
-            if (Property.isValidIndex(index))
-            {
-                children.push(_properties.get(index));
-            }
-            index = property.getNextChildIndex();
-            if (Property.isValidIndex(index))
-            {
-                children.push(_properties.get(index));
-            }
-        }
-    }
-
-    /* ********** START implementation of BATManaged ********** */
-
+    
     /**
      * Return the number of BigBlock's this instance uses
      *
      * @return count of BigBlock instances
      */
-
     public int countBlocks()
     {
         return (_blocks == null) ? 0
@@ -204,21 +105,6 @@
     }
 
     /**
-     * Set the start block for this instance
-     *
-     * @param index index into the array of BigBlock instances making
-     *              up the the filesystem
-     */
-
-    public void setStartBlock(final int index)
-    {
-        _start_block = index;
-    }
-
-    /* **********  END  implementation of BATManaged ********** */
-    /* ********** START implementation of BlockWritable ********** */
-
-    /**
      * Write the storage to an OutputStream
      *
      * @param stream the OutputStream to which the stored data should
@@ -227,7 +113,6 @@
      * @exception IOException on problems writing to the specified
      *            stream
      */
-
     public void writeBlocks(final OutputStream stream)
         throws IOException
     {
@@ -239,7 +124,4 @@
             }
         }
     }
-
-    /* **********  END  implementation of BlockWritable ********** */
-}   // end public class PropertyTable
-
+}
diff --git a/src/java/org/apache/poi/poifs/property/PropertyTableBase.java b/src/java/org/apache/poi/poifs/property/PropertyTableBase.java
new file mode 100644
index 0000000..a352081
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/property/PropertyTableBase.java
@@ -0,0 +1,153 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.property;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+import org.apache.poi.poifs.filesystem.BATManaged;
+import org.apache.poi.poifs.storage.HeaderBlock;
+
+/**
+ * This class embodies the Property Table for the filesystem,
+ *  which looks up entries in the filesystem to their
+ *  chain of blocks.
+ * This is the core support, there are implementations
+ *  for the different block schemes as needed.
+ */
+public abstract class PropertyTableBase implements BATManaged {
+    private   final HeaderBlock    _header_block;
+    protected final List<Property> _properties;
+
+    public PropertyTableBase(final HeaderBlock header_block)
+    {
+        _header_block = header_block;
+        _properties  = new ArrayList<Property>();
+        addProperty(new RootProperty());
+    }
+
+    /**
+     * Reading constructor (used when we've read in a file and we want
+     * to extract the property table from it). Populates the
+     * properties thoroughly
+     *
+     * @param startBlock the first block of the property table
+     * @param blockList the list of blocks
+     *
+     * @exception IOException if anything goes wrong (which should be
+     *            a result of the input being NFG)
+     */
+    public PropertyTableBase(final HeaderBlock header_block,
+                         final List<Property> properties)
+        throws IOException
+    {
+        _header_block = header_block;
+        _properties   = properties;
+        populatePropertyTree( (DirectoryProperty)_properties.get(0));
+    }
+
+    /**
+     * Add a property to the list of properties we manage
+     *
+     * @param property the new Property to manage
+     */
+    public void addProperty(Property property)
+    {
+        _properties.add(property);
+    }
+
+    /**
+     * Remove a property from the list of properties we manage
+     *
+     * @param property the Property to be removed
+     */
+    public void removeProperty(final Property property)
+    {
+        _properties.remove(property);
+    }
+
+    /**
+     * Get the root property
+     *
+     * @return the root property
+     */
+    public RootProperty getRoot()
+    {
+        // it's always the first element in the List
+        return ( RootProperty ) _properties.get(0);
+    }
+    
+    private void populatePropertyTree(DirectoryProperty root)
+        throws IOException
+    {
+        int index = root.getChildIndex();
+
+        if (!Property.isValidIndex(index))
+        {
+
+            // property has no children
+            return;
+        }
+        Stack<Property> children = new Stack<Property>();
+
+        children.push(_properties.get(index));
+        while (!children.empty())
+        {
+            Property property = children.pop();
+
+            root.addChild(property);
+            if (property.isDirectory())
+            {
+                populatePropertyTree(( DirectoryProperty ) property);
+            }
+            index = property.getPreviousChildIndex();
+            if (Property.isValidIndex(index))
+            {
+                children.push(_properties.get(index));
+            }
+            index = property.getNextChildIndex();
+            if (Property.isValidIndex(index))
+            {
+                children.push(_properties.get(index));
+            }
+        }
+    }
+
+    /**
+     * Get the start block for the property table
+     *
+     * @return start block index
+     */
+    public int getStartBlock()
+    {
+        return _header_block.getPropertyStart();
+    }
+
+    /**
+     * Set the start block for this instance
+     *
+     * @param index index into the array of BigBlock instances making
+     *              up the the filesystem
+     */
+    public void setStartBlock(final int index)
+    {
+        _header_block.setPropertyStart(index);
+    }
+}
diff --git a/src/java/org/apache/poi/poifs/property/RootProperty.java b/src/java/org/apache/poi/poifs/property/RootProperty.java
index afa82ed..b934a26 100644
--- a/src/java/org/apache/poi/poifs/property/RootProperty.java
+++ b/src/java/org/apache/poi/poifs/property/RootProperty.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,14 +14,9 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.property;
 
-import java.util.*;
-
-import java.io.IOException;
-
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.poifs.storage.SmallDocumentBlock;
 
@@ -31,18 +25,12 @@
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-
-public class RootProperty
-    extends DirectoryProperty
-{
-
-    /**
-     * Default constructor
-     */
+public final class RootProperty extends DirectoryProperty {
+   private static final String NAME = "Root Entry";
 
     RootProperty()
     {
-        super("Root Entry");
+        super(NAME);
 
         // overrides
         setNodeColor(_NODE_BLACK);
@@ -57,7 +45,6 @@
      * @param array byte data
      * @param offset offset into byte data
      */
-
     protected RootProperty(final int index, final byte [] array,
                            final int offset)
     {
@@ -69,10 +56,17 @@
      *
      * @param size size in terms of small blocks
      */
-
     public void setSize(int size)
     {
         super.setSize(SmallDocumentBlock.calcSize(size));
     }
-}   // end public class RootProperty
 
+    /**
+     * Returns the fixed name "Root Entry", as the
+     *  raw property doesn't have a real name set
+     */
+    @Override
+    public String getName() {
+        return NAME;
+    }
+}
diff --git a/src/java/org/apache/poi/poifs/storage/BATBlock.java b/src/java/org/apache/poi/poifs/storage/BATBlock.java
index 5aa4678..661cd12 100644
--- a/src/java/org/apache/poi/poifs/storage/BATBlock.java
+++ b/src/java/org/apache/poi/poifs/storage/BATBlock.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,19 +14,18 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
 import java.io.IOException;
 import java.io.OutputStream;
-
+import java.nio.ByteBuffer;
 import java.util.Arrays;
+import java.util.List;
 
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.common.POIFSConstants;
-import org.apache.poi.util.IntegerField;
 import org.apache.poi.util.LittleEndian;
-import org.apache.poi.util.LittleEndianConsts;
 
 /**
  * A block of block allocation table entries. BATBlocks are created
@@ -35,163 +33,37 @@
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-
-public class BATBlock
-    extends BigBlock
-{
-    private static final int  _entries_per_block      =
-        POIFSConstants.BIG_BLOCK_SIZE / LittleEndianConsts.INT_SIZE;
-    private static final int  _entries_per_xbat_block = _entries_per_block
-                                                            - 1;
-    private static final int  _xbat_chain_offset      =
-        _entries_per_xbat_block * LittleEndianConsts.INT_SIZE;
-    private static final byte _default_value          = ( byte ) 0xFF;
-    private IntegerField[]    _fields;
-    private byte[]            _data;
-
+public final class BATBlock extends BigBlock {
+    /**
+     * For a regular fat block, these are 128 / 1024 
+     *  next sector values.
+     * For a XFat (DIFat) block, these are 127 / 1023
+     *  next sector values, then a chaining value.
+     */
+    private int[] _values;
+    
+    /**
+     * Does this BATBlock have any free sectors in it?
+     */
+    private boolean _has_free_sectors;
+    
+    /**
+     * Where in the file are we?
+     */
+    private int ourBlockIndex;
+    
     /**
      * Create a single instance initialized with default values
      */
-
-    private BATBlock()
+    private BATBlock(POIFSBigBlockSize bigBlockSize)
     {
-        _data = new byte[ POIFSConstants.BIG_BLOCK_SIZE ];
-        Arrays.fill(_data, _default_value);
-        _fields = new IntegerField[ _entries_per_block ];
-        int offset = 0;
+        super(bigBlockSize);
+        
+        int _entries_per_block = bigBlockSize.getBATEntriesPerBlock();
+        _values = new int[_entries_per_block];
+        _has_free_sectors = true;
 
-        for (int j = 0; j < _entries_per_block; j++)
-        {
-            _fields[ j ] = new IntegerField(offset);
-            offset       += LittleEndianConsts.INT_SIZE;
-        }
-    }
-
-    /**
-     * Create an array of BATBlocks from an array of int block
-     * allocation table entries
-     *
-     * @param entries the array of int entries
-     *
-     * @return the newly created array of BATBlocks
-     */
-
-    public static BATBlock [] createBATBlocks(final int [] entries)
-    {
-        int        block_count = calculateStorageRequirements(entries.length);
-        BATBlock[] blocks      = new BATBlock[ block_count ];
-        int        index       = 0;
-        int        remaining   = entries.length;
-
-        for (int j = 0; j < entries.length; j += _entries_per_block)
-        {
-            blocks[ index++ ] = new BATBlock(entries, j,
-                                             (remaining > _entries_per_block)
-                                             ? j + _entries_per_block
-                                             : entries.length);
-            remaining         -= _entries_per_block;
-        }
-        return blocks;
-    }
-
-    /**
-     * Create an array of XBATBlocks from an array of int block
-     * allocation table entries
-     *
-     * @param entries the array of int entries
-     * @param startBlock the start block of the array of XBAT blocks
-     *
-     * @return the newly created array of BATBlocks
-     */
-
-    public static BATBlock [] createXBATBlocks(final int [] entries,
-                                               final int startBlock)
-    {
-        int        block_count =
-            calculateXBATStorageRequirements(entries.length);
-        BATBlock[] blocks      = new BATBlock[ block_count ];
-        int        index       = 0;
-        int        remaining   = entries.length;
-
-        if (block_count != 0)
-        {
-            for (int j = 0; j < entries.length; j += _entries_per_xbat_block)
-            {
-                blocks[ index++ ] =
-                    new BATBlock(entries, j,
-                                 (remaining > _entries_per_xbat_block)
-                                 ? j + _entries_per_xbat_block
-                                 : entries.length);
-                remaining         -= _entries_per_xbat_block;
-            }
-            for (index = 0; index < blocks.length - 1; index++)
-            {
-                blocks[ index ].setXBATChain(startBlock + index + 1);
-            }
-            blocks[ index ].setXBATChain(POIFSConstants.END_OF_CHAIN);
-        }
-        return blocks;
-    }
-
-    /**
-     * Calculate how many BATBlocks are needed to hold a specified
-     * number of BAT entries.
-     *
-     * @param entryCount the number of entries
-     *
-     * @return the number of BATBlocks needed
-     */
-
-    public static int calculateStorageRequirements(final int entryCount)
-    {
-        return (entryCount + _entries_per_block - 1) / _entries_per_block;
-    }
-
-    /**
-     * Calculate how many XBATBlocks are needed to hold a specified
-     * number of BAT entries.
-     *
-     * @param entryCount the number of entries
-     *
-     * @return the number of XBATBlocks needed
-     */
-
-    public static int calculateXBATStorageRequirements(final int entryCount)
-    {
-        return (entryCount + _entries_per_xbat_block - 1)
-               / _entries_per_xbat_block;
-    }
-
-    /**
-     * @return number of entries per block
-     */
-
-    public static final int entriesPerBlock()
-    {
-        return _entries_per_block;
-    }
-
-    /**
-     * @return number of entries per XBAT block
-     */
-
-    public static final int entriesPerXBATBlock()
-    {
-        return _entries_per_xbat_block;
-    }
-
-    /**
-     * @return offset of chain index of XBAT block
-     */
-
-    public static final int getXBATChainOffset()
-    {
-        return _xbat_chain_offset;
-    }
-
-    private void setXBATChain(int chainIndex)
-    {
-        _fields[ _entries_per_xbat_block ].set(chainIndex, _data);
+        Arrays.fill(_values, POIFSConstants.UNUSED_BLOCK);
     }
 
     /**
@@ -205,19 +77,271 @@
      *                  k, start_index <= k < end_index)
      */
 
-    private BATBlock(final int [] entries, final int start_index,
-                     final int end_index)
+    private BATBlock(POIFSBigBlockSize bigBlockSize, final int [] entries,
+                     final int start_index, final int end_index)
     {
-        this();
-        for (int k = start_index; k < end_index; k++)
-        {
-            _fields[ k - start_index ].set(entries[ k ], _data);
+        this(bigBlockSize);
+        for (int k = start_index; k < end_index; k++) {
+           _values[k - start_index] = entries[k];
+        }
+        
+        // Do we have any free sectors?
+        if(end_index - start_index == _values.length) {
+           recomputeFree();
         }
     }
+    
+    private void recomputeFree() {
+       boolean hasFree = false;
+       for(int k=0; k<_values.length; k++) {
+          if(_values[k] == POIFSConstants.UNUSED_BLOCK) {
+             hasFree = true;
+             break;
+          }
+       }
+       _has_free_sectors = hasFree;
+    }
+
+    /**
+     * Create a single BATBlock from the byte buffer, which must hold at least
+     *  one big block of data to be read.
+     */
+    public static BATBlock createBATBlock(final POIFSBigBlockSize bigBlockSize, ByteBuffer data)
+    {
+       // Create an empty block
+       BATBlock block = new BATBlock(bigBlockSize);
+       
+       // Fill it
+       byte[] buffer = new byte[LittleEndian.INT_SIZE];
+       for(int i=0; i<block._values.length; i++) {
+          data.get(buffer);
+          block._values[i] = LittleEndian.getInt(buffer);
+       }
+       block.recomputeFree();
+       
+       // All done
+       return block;
+    }
+    
+    /**
+     * Creates a single BATBlock, with all the values set to empty.
+     */
+    public static BATBlock createEmptyBATBlock(final POIFSBigBlockSize bigBlockSize, boolean isXBAT) {
+       BATBlock block = new BATBlock(bigBlockSize);
+       if(isXBAT) {
+          block.setXBATChain(bigBlockSize, POIFSConstants.END_OF_CHAIN);
+       }
+       return block;
+    }
+
+    /**
+     * Create an array of BATBlocks from an array of int block
+     * allocation table entries
+     *
+     * @param entries the array of int entries
+     *
+     * @return the newly created array of BATBlocks
+     */
+    public static BATBlock [] createBATBlocks(final POIFSBigBlockSize bigBlockSize, final int [] entries)
+    {
+        int        block_count = calculateStorageRequirements(bigBlockSize, entries.length);
+        BATBlock[] blocks      = new BATBlock[ block_count ];
+        int        index       = 0;
+        int        remaining   = entries.length;
+
+        int _entries_per_block = bigBlockSize.getBATEntriesPerBlock();
+        for (int j = 0; j < entries.length; j += _entries_per_block)
+        {
+            blocks[ index++ ] = new BATBlock(bigBlockSize, entries, j,
+                                             (remaining > _entries_per_block)
+                                             ? j + _entries_per_block
+                                             : entries.length);
+            remaining         -= _entries_per_block;
+        }
+        return blocks;
+    }
+    
+    /**
+     * Create an array of XBATBlocks from an array of int block
+     * allocation table entries
+     *
+     * @param entries the array of int entries
+     * @param startBlock the start block of the array of XBAT blocks
+     *
+     * @return the newly created array of BATBlocks
+     */
+
+    public static BATBlock [] createXBATBlocks(final POIFSBigBlockSize bigBlockSize,
+                                               final int [] entries,
+                                               final int startBlock)
+    {
+        int        block_count =
+            calculateXBATStorageRequirements(bigBlockSize, entries.length);
+        BATBlock[] blocks      = new BATBlock[ block_count ];
+        int        index       = 0;
+        int        remaining   = entries.length;
+
+        int _entries_per_xbat_block = bigBlockSize.getXBATEntriesPerBlock();
+        if (block_count != 0)
+        {
+            for (int j = 0; j < entries.length; j += _entries_per_xbat_block)
+            {
+                blocks[ index++ ] =
+                    new BATBlock(bigBlockSize, entries, j,
+                                 (remaining > _entries_per_xbat_block)
+                                 ? j + _entries_per_xbat_block
+                                 : entries.length);
+                remaining         -= _entries_per_xbat_block;
+            }
+            for (index = 0; index < blocks.length - 1; index++)
+            {
+                blocks[ index ].setXBATChain(bigBlockSize, startBlock + index + 1);
+            }
+            blocks[ index ].setXBATChain(bigBlockSize, POIFSConstants.END_OF_CHAIN);
+        }
+        return blocks;
+    }
+
+    /**
+     * Calculate how many BATBlocks are needed to hold a specified
+     * number of BAT entries.
+     *
+     * @param entryCount the number of entries
+     *
+     * @return the number of BATBlocks needed
+     */
+    public static int calculateStorageRequirements(final POIFSBigBlockSize bigBlockSize, final int entryCount)
+    {
+        int _entries_per_block = bigBlockSize.getBATEntriesPerBlock();
+        return (entryCount + _entries_per_block - 1) / _entries_per_block;
+    }
+
+    /**
+     * Calculate how many XBATBlocks are needed to hold a specified
+     * number of BAT entries.
+     *
+     * @param entryCount the number of entries
+     *
+     * @return the number of XBATBlocks needed
+     */
+    public static int calculateXBATStorageRequirements(final POIFSBigBlockSize bigBlockSize, final int entryCount)
+    {
+        int _entries_per_xbat_block = bigBlockSize.getXBATEntriesPerBlock();
+        return (entryCount + _entries_per_xbat_block - 1)
+               / _entries_per_xbat_block;
+    }
+    
+    /**
+     * Calculates the maximum size of a file which is addressable given the
+     *  number of FAT (BAT) sectors specified. (We don't care if those BAT
+     *  blocks come from the 109 in the header, or from header + XBATS, it
+     *  won't affect the calculation)
+     *  
+     * The actual file size will be between [size of fatCount-1 blocks] and
+     *   [size of fatCount blocks].
+     *  For 512 byte block sizes, this means we may over-estimate by up to 65kb.
+     *  For 4096 byte block sizes, this means we may over-estimate by up to 4mb
+     */
+    public static int calculateMaximumSize(final POIFSBigBlockSize bigBlockSize,
+          final int numBATs) {
+       int size = 1; // Header isn't FAT addressed
+       
+       // The header has up to 109 BATs, and extra ones are referenced
+       //  from XBATs
+       // However, all BATs can contain 128/1024 blocks
+       size += (numBATs * bigBlockSize.getBATEntriesPerBlock());
+       
+       // So far we've been in sector counts, turn into bytes
+       return size * bigBlockSize.getBigBlockSize();
+    }
+    public static int calculateMaximumSize(final HeaderBlock header)
+    {
+       return calculateMaximumSize(header.getBigBlockSize(), header.getBATCount());
+    }
+
+    /**
+     * Returns the BATBlock that handles the specified offset,
+     *  and the relative index within it.
+     * The List of BATBlocks must be in sequential order
+     */
+    public static BATBlockAndIndex getBATBlockAndIndex(final int offset, 
+                final HeaderBlock header, final List<BATBlock> bats) {
+       POIFSBigBlockSize bigBlockSize = header.getBigBlockSize();
+       
+       int whichBAT = (int)Math.floor(offset / bigBlockSize.getBATEntriesPerBlock());
+       int index = offset % bigBlockSize.getBATEntriesPerBlock();
+       return new BATBlockAndIndex( index, bats.get(whichBAT) );
+    }
+    
+    /**
+     * Returns the BATBlock that handles the specified offset,
+     *  and the relative index within it, for the mini stream.
+     * The List of BATBlocks must be in sequential order
+     */
+    public static BATBlockAndIndex getSBATBlockAndIndex(final int offset, 
+          final HeaderBlock header, final List<BATBlock> sbats) {
+       POIFSBigBlockSize bigBlockSize = header.getBigBlockSize();
+       
+       // SBATs are so much easier, as they're chained streams
+       int whichSBAT = (int)Math.floor(offset / bigBlockSize.getBATEntriesPerBlock());
+       int index = offset % bigBlockSize.getBATEntriesPerBlock();
+       return new BATBlockAndIndex( index, sbats.get(whichSBAT) );
+    }
+    
+    private void setXBATChain(final POIFSBigBlockSize bigBlockSize, int chainIndex)
+    {
+        int _entries_per_xbat_block = bigBlockSize.getXBATEntriesPerBlock();
+        _values[ _entries_per_xbat_block ] = chainIndex;
+    }
+    
+    /**
+     * Does this BATBlock have any free sectors in it, or
+     *  is it full?
+     */
+    public boolean hasFreeSectors() {
+       return _has_free_sectors;
+    }
+    
+    public int getValueAt(int relativeOffset) {
+       if(relativeOffset >= _values.length) {
+          throw new ArrayIndexOutOfBoundsException(
+                "Unable to fetch offset " + relativeOffset + " as the " + 
+                "BAT only contains " + _values.length + " entries"
+          ); 
+       }
+       return _values[relativeOffset];
+    }
+    public void setValueAt(int relativeOffset, int value) {
+       int oldValue = _values[relativeOffset];
+       _values[relativeOffset] = value;
+       
+       // Do we need to re-compute the free?
+       if(value == POIFSConstants.UNUSED_BLOCK) {
+          _has_free_sectors = true;
+          return;
+       }
+       if(oldValue == POIFSConstants.UNUSED_BLOCK) {
+          recomputeFree();
+       }
+    }
+    
+    /**
+     * Record where in the file we live
+     */
+    public void setOurBlockIndex(int index) {
+       this.ourBlockIndex = index;
+    }
+    /**
+     * Retrieve where in the file we live 
+     */
+    public int getOurBlockIndex() {
+       return ourBlockIndex;
+    }
+
 
     /* ********** START extension of BigBlock ********** */
 
-    /**
+   /**
      * Write the block's data to an OutputStream
      *
      * @param stream the OutputStream to which the stored data should
@@ -226,13 +350,51 @@
      * @exception IOException on problems writing to the specified
      *            stream
      */
-
     void writeData(final OutputStream stream)
         throws IOException
     {
-        doWriteData(stream, _data);
+       // Save it out
+       stream.write( serialize() );
+    }
+    
+    void writeData(final ByteBuffer block)
+        throws IOException
+    {
+       // Save it out
+       block.put( serialize() );
+    }
+    
+    private byte[] serialize() {
+       // Create the empty array
+       byte[] data = new byte[ bigBlockSize.getBigBlockSize() ];
+       
+       // Fill in the values
+       int offset = 0;
+       for(int i=0; i<_values.length; i++) {
+          LittleEndian.putInt(data, offset, _values[i]);
+          offset += LittleEndian.INT_SIZE;
+       }
+       
+       // Done
+       return data;
     }
 
     /* **********  END  extension of BigBlock ********** */
-}   // end public class BATBlock
+    
+    
+    public static class BATBlockAndIndex {
+       private final int index;
+       private final BATBlock block;
+       private BATBlockAndIndex(int index, BATBlock block) {
+          this.index = index;
+          this.block = block;
+       }
+       public int getIndex() {
+          return index;
+       }
+       public BATBlock getBlock() {
+          return block;
+       }
+    }
+}
 
diff --git a/src/java/org/apache/poi/poifs/storage/BigBlock.java b/src/java/org/apache/poi/poifs/storage/BigBlock.java
index 2ca0d30..a3fa3f9 100644
--- a/src/java/org/apache/poi/poifs/storage/BigBlock.java
+++ b/src/java/org/apache/poi/poifs/storage/BigBlock.java
@@ -21,8 +21,8 @@
 
 /**
  * Abstract base class of all POIFS block storage classes. All
- * extensions of BigBlock should write 512 bytes of data when
- * requested to write their data.
+ * extensions of BigBlock should write 512 or 4096 bytes of data when
+ * requested to write their data (as per their BigBlockSize).
  *
  * This class has package scope, as there is no reason at this time to
  * make the class public.
@@ -33,9 +33,21 @@
 import java.io.IOException;
 import java.io.OutputStream;
 
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
+import org.apache.poi.poifs.common.POIFSConstants;
+
 abstract class BigBlock
     implements BlockWritable
 {
+    /** 
+     * Either 512 bytes ({@link POIFSConstants#SMALLER_BIG_BLOCK_SIZE}) 
+     *  or 4096 bytes ({@link POIFSConstants#LARGER_BIG_BLOCK_SIZE})
+     */
+    protected POIFSBigBlockSize bigBlockSize;
+    
+    protected BigBlock(POIFSBigBlockSize bigBlockSize) {
+       this.bigBlockSize = bigBlockSize;
+    }
 
     /**
      * Default implementation of write for extending classes that
diff --git a/src/java/org/apache/poi/poifs/storage/BlockAllocationTableReader.java b/src/java/org/apache/poi/poifs/storage/BlockAllocationTableReader.java
index b167d2f..0d1b86d 100644
--- a/src/java/org/apache/poi/poifs/storage/BlockAllocationTableReader.java
+++ b/src/java/org/apache/poi/poifs/storage/BlockAllocationTableReader.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +14,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
@@ -23,6 +21,7 @@
 
 import java.util.*;
 
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.util.IntList;
 import org.apache.poi.util.LittleEndian;
@@ -43,10 +42,22 @@
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-
-public class BlockAllocationTableReader
-{
-    private IntList _entries;
+public final class BlockAllocationTableReader {
+    
+    /**
+     * Maximum number size (in blocks) of the allocation table as supported by
+     * POI.<br/>
+     *
+     * This constant has been chosen to help POI identify corrupted data in the
+     * header block (rather than crash immediately with {@link OutOfMemoryError}
+     * ). It's not clear if the compound document format actually specifies any
+     * upper limits. For files with 512 byte blocks, having an allocation table
+     * of 65,335 blocks would correspond to a total file size of 4GB. Needless
+     * to say, POI probably cannot handle files anywhere near that size.
+     */
+    private static final int MAX_BLOCK_COUNT = 65535;
+    private final IntList _entries;
+    private POIFSBigBlockSize bigBlockSize;
 
     /**
      * create a BlockAllocationTableReader for an existing filesystem. Side
@@ -66,33 +77,41 @@
      * @exception IOException if, in trying to create the table, we
      *            encounter logic errors
      */
+    public BlockAllocationTableReader(POIFSBigBlockSize bigBlockSize, int block_count, int [] block_array,
+            int xbat_count, int xbat_index, BlockList raw_block_list) throws IOException {
+        this(bigBlockSize);
+        
+        sanityCheckBlockCount(block_count);
 
-    public BlockAllocationTableReader(final int block_count,
-                                      final int [] block_array,
-                                      final int xbat_count,
-                                      final int xbat_index,
-                                      final BlockList raw_block_list)
-        throws IOException
-    {
-        this();
-        if (block_count <= 0)
-        {
-            throw new IOException(
-                "Illegal block count; minimum count is 1, got " + block_count
-                + " instead");
-        }
-
-        // acquire raw data blocks containing the BAT block data
-        RawDataBlock blocks[] = new RawDataBlock[ block_count ];
+        // We want to get the whole of the FAT table
+        // To do this:
+        //  * Work through raw_block_list, which points to the 
+        //     first (up to) 109 BAT blocks
+        //  * Jump to the XBAT offset, and read in XBATs which
+        //     point to more BAT blocks
         int          limit    = Math.min(block_count, block_array.length);
         int          block_index;
+        
+        // This will hold all of the BAT blocks in order
+        RawDataBlock blocks[] = new RawDataBlock[ block_count ];
 
+        // Process the first (up to) 109 BAT blocks
         for (block_index = 0; block_index < limit; block_index++)
         {
+            // Check that the sector number of the BAT block is a valid one
+            int nextOffset = block_array[ block_index ];
+            if(nextOffset > raw_block_list.blockCount()) {
+               throw new IOException("Your file contains " + raw_block_list.blockCount() + 
+                     " sectors, but the initial DIFAT array at index " + block_index +
+                     " referenced block # " + nextOffset + ". This isn't allowed and " +
+                     " your file is corrupt");
+            }
+            // Record the sector number of this BAT block 
             blocks[ block_index ] =
-                ( RawDataBlock ) raw_block_list
-                    .remove(block_array[ block_index ]);
+                ( RawDataBlock ) raw_block_list.remove(nextOffset);
         }
+        
+        // Process additional BAT blocks via the XBATs
         if (block_index < block_count)
         {
 
@@ -103,9 +122,12 @@
                     "BAT count exceeds limit, yet XBAT index indicates no valid entries");
             }
             int chain_index           = xbat_index;
-            int max_entries_per_block = BATBlock.entriesPerXBATBlock();
-            int chain_index_offset    = BATBlock.getXBATChainOffset();
+            int max_entries_per_block = bigBlockSize.getXBATEntriesPerBlock(); 
+            int chain_index_offset    = bigBlockSize.getNextXBATChainOffset(); 
 
+            // Each XBAT block contains either:
+            //  (maximum number of sector indexes) + index of next XBAT
+            //  some sector indexes + FREE sectors to max # + EndOfChain
             for (int j = 0; j < xbat_count; j++)
             {
                 limit = Math.min(block_count - block_index,
@@ -132,8 +154,8 @@
             throw new IOException("Could not find all blocks");
         }
 
-        // now that we have all of the raw data blocks, go through and
-        // create the indices
+        // Now that we have all of the raw data blocks which make
+        //  up the FAT, go through and create the indices
         setEntries(blocks, raw_block_list);
     }
 
@@ -145,25 +167,31 @@
      *
      * @exception IOException
      */
-
-    BlockAllocationTableReader(final ListManagedBlock [] blocks,
-                               final BlockList raw_block_list)
-        throws IOException
-    {
-        this();
+    BlockAllocationTableReader(POIFSBigBlockSize bigBlockSize, ListManagedBlock[] blocks, BlockList raw_block_list)
+            throws IOException {
+        this(bigBlockSize);
         setEntries(blocks, raw_block_list);
     }
 
-    /**
-     * Constructor BlockAllocationTableReader
-     *
-     *
-     */
-
-    BlockAllocationTableReader()
-    {
+    BlockAllocationTableReader(POIFSBigBlockSize bigBlockSize) {
+        this.bigBlockSize = bigBlockSize;
         _entries = new IntList();
     }
+    
+    public static void sanityCheckBlockCount(int block_count) throws IOException {
+       if (block_count <= 0) {
+          throw new IOException(
+                "Illegal block count; minimum count is 1, got " + 
+                block_count + " instead"
+          );
+       }
+       if (block_count > MAX_BLOCK_COUNT) {
+          throw new IOException(
+                "Block count " + block_count + 
+                " is too high. POI maximum is " + MAX_BLOCK_COUNT + "."
+          );
+       }
+    }
 
     /**
      * walk the entries from a specified point and return the
@@ -177,21 +205,43 @@
      *
      * @exception IOException if there is a problem acquiring the blocks
      */
-
-    ListManagedBlock [] fetchBlocks(final int startBlock,
-                                    final BlockList blockList)
-        throws IOException
-    {
-        List blocks       = new ArrayList();
+    ListManagedBlock[] fetchBlocks(int startBlock, int headerPropertiesStartBlock,
+            BlockList blockList) throws IOException {
+        List<ListManagedBlock> blocks = new ArrayList<ListManagedBlock>();
         int  currentBlock = startBlock;
+        boolean firstPass = true;
+        ListManagedBlock dataBlock = null;
 
-        while (currentBlock != POIFSConstants.END_OF_CHAIN)
-        {
-            blocks.add(blockList.remove(currentBlock));
-            currentBlock = _entries.get(currentBlock);
+        // Process the chain from the start to the end
+        // Normally we have header, data, end
+        // Sometimes we have data, header, end
+        // For those cases, stop at the header, not the end
+        while (currentBlock != POIFSConstants.END_OF_CHAIN) {
+            try {
+                // Grab the data at the current block offset
+                dataBlock = blockList.remove(currentBlock);
+                blocks.add(dataBlock);
+                // Now figure out which block we go to next
+                currentBlock = _entries.get(currentBlock);
+                firstPass = false;
+            } catch(IOException e) {
+                if(currentBlock == headerPropertiesStartBlock) {
+                    // Special case where things are in the wrong order
+                    System.err.println("Warning, header block comes after data blocks in POIFS block listing");
+                    currentBlock = POIFSConstants.END_OF_CHAIN;
+                } else if(currentBlock == 0 && firstPass) {
+                    // Special case where the termination isn't done right
+                    //  on an empty set
+                    System.err.println("Warning, incorrectly terminated empty data blocks in POIFS block listing (should end at -2, ended at 0)");
+                    currentBlock = POIFSConstants.END_OF_CHAIN;
+                } else {
+                    // Ripple up
+                    throw e;
+                }
+            }
         }
-        return ( ListManagedBlock [] ) blocks
-            .toArray(new ListManagedBlock[ 0 ]);
+
+        return blocks.toArray(new ListManagedBlock[blocks.size()]);
     }
 
     // methods for debugging reader
@@ -203,19 +253,14 @@
      *
      * @return true if the specific block is used, else false
      */
+    boolean isUsed(int index) {
 
-    boolean isUsed(final int index)
-    {
-        boolean rval = false;
-
-        try
-        {
-            rval = _entries.get(index) != -1;
+        try {
+            return _entries.get(index) != -1;
+        } catch (IndexOutOfBoundsException e) {
+            // ignored
+            return false;
         }
-        catch (IndexOutOfBoundsException ignored)
-        {
-        }
-        return rval;
     }
 
     /**
@@ -229,18 +274,11 @@
      *
      * @exception IOException if the current block is unused
      */
-
-    int getNextBlockIndex(final int index)
-        throws IOException
-    {
-        if (isUsed(index))
-        {
+    int getNextBlockIndex(int index) throws IOException {
+        if (isUsed(index)) {
             return _entries.get(index);
         }
-        else
-        {
-            throw new IOException("index " + index + " is unused");
-        }
+        throw new IOException("index " + index + " is unused");
     }
 
     /**
@@ -249,15 +287,9 @@
      * @param blocks the array of blocks containing the indices
      * @param raw_blocks the list of blocks being managed. Unused
      *                   blocks will be eliminated from the list
-     *
-     * @exception IOException
      */
-
-    private void setEntries(final ListManagedBlock [] blocks,
-                            final BlockList raw_blocks)
-        throws IOException
-    {
-        int limit = BATBlock.entriesPerBlock();
+    private void setEntries(ListManagedBlock[] blocks, BlockList raw_blocks) throws IOException {
+        int limit = bigBlockSize.getBATEntriesPerBlock(); 
 
         for (int block_index = 0; block_index < blocks.length; block_index++)
         {
@@ -281,5 +313,4 @@
         }
         raw_blocks.setBAT(this);
     }
-}   // end class BlockAllocationTableReader
-
+}
diff --git a/src/java/org/apache/poi/poifs/storage/BlockAllocationTableWriter.java b/src/java/org/apache/poi/poifs/storage/BlockAllocationTableWriter.java
index b2f6af2..e037b89 100644
--- a/src/java/org/apache/poi/poifs/storage/BlockAllocationTableWriter.java
+++ b/src/java/org/apache/poi/poifs/storage/BlockAllocationTableWriter.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,20 +14,17 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
 import java.io.IOException;
 import java.io.OutputStream;
+import java.nio.ByteBuffer;
 
-import java.util.*;
-
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.poifs.filesystem.BATManaged;
 import org.apache.poi.util.IntList;
-import org.apache.poi.util.LittleEndian;
-import org.apache.poi.util.LittleEndianConsts;
 
 /**
  * This class manages and creates the Block Allocation Table, which is
@@ -45,23 +41,21 @@
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-
-public class BlockAllocationTableWriter
-    implements BlockWritable, BATManaged
-{
+public final class BlockAllocationTableWriter implements BlockWritable, BATManaged {
     private IntList    _entries;
     private BATBlock[] _blocks;
     private int        _start_block;
+    private POIFSBigBlockSize _bigBlockSize;
 
     /**
      * create a BlockAllocationTableWriter
      */
-
-    public BlockAllocationTableWriter()
+    public BlockAllocationTableWriter(POIFSBigBlockSize bigBlockSize)
     {
-        _start_block = POIFSConstants.END_OF_CHAIN;
-        _entries     = new IntList();
-        _blocks      = new BATBlock[ 0 ];
+       _bigBlockSize = bigBlockSize; 
+        _start_block  = POIFSConstants.END_OF_CHAIN;
+        _entries      = new IntList();
+        _blocks       = new BATBlock[ 0 ];
     }
 
     /**
@@ -69,7 +63,6 @@
      *
      * @return start block index of BAT blocks
      */
-
     public int createBlocks()
     {
         int xbat_blocks = 0;
@@ -78,12 +71,13 @@
         while (true)
         {
             int calculated_bat_blocks  =
-                BATBlock.calculateStorageRequirements(bat_blocks
+                BATBlock.calculateStorageRequirements(_bigBlockSize,
+                                                      bat_blocks
                                                       + xbat_blocks
                                                       + _entries.size());
             int calculated_xbat_blocks =
-                HeaderBlockWriter
-                    .calculateXBATStorageRequirements(calculated_bat_blocks);
+                HeaderBlockWriter.calculateXBATStorageRequirements(
+                      _bigBlockSize, calculated_bat_blocks);
 
             if ((bat_blocks == calculated_bat_blocks)
                     && (xbat_blocks == calculated_xbat_blocks))
@@ -92,11 +86,8 @@
                 // stable ... we're OK
                 break;
             }
-            else
-            {
-                bat_blocks  = calculated_bat_blocks;
-                xbat_blocks = calculated_xbat_blocks;
-            }
+            bat_blocks  = calculated_bat_blocks;
+            xbat_blocks = calculated_xbat_blocks;
         }
         int startBlock = allocateSpace(bat_blocks);
 
@@ -112,7 +103,6 @@
      *
      * @return the starting index of the blocks
      */
-
     public int allocateSpace(final int blockCount)
     {
         int startBlock = _entries.size();
@@ -136,7 +126,6 @@
      *
      * @return the starting block index
      */
-
     public int getStartBlock()
     {
         return _start_block;
@@ -145,14 +134,11 @@
     /**
      * create the BATBlocks
      */
-
     void simpleCreateBlocks()
     {
-        _blocks = BATBlock.createBATBlocks(_entries.toArray());
+        _blocks = BATBlock.createBATBlocks(_bigBlockSize, _entries.toArray());
     }
 
-    /* ********** START implementation of BlockWritable ********** */
-
     /**
      * Write the storage to an OutputStream
      *
@@ -162,7 +148,6 @@
      * @exception IOException on problems writing to the specified
      *            stream
      */
-
     public void writeBlocks(final OutputStream stream)
         throws IOException
     {
@@ -171,16 +156,21 @@
             _blocks[ j ].writeBlocks(stream);
         }
     }
-
-    /* **********  END  implementation of BlockWritable ********** */
-    /* ********** START implementation of BATManaged ********** */
+    
+    /**
+     * Write the BAT into its associated block
+     */
+    public static void writeBlock(final BATBlock bat, final ByteBuffer block) 
+        throws IOException
+    {
+        bat.writeData(block);
+    }
 
     /**
      * Return the number of BigBlock's this instance uses
      *
      * @return count of BigBlock instances
      */
-
     public int countBlocks()
     {
         return _blocks.length;
@@ -188,15 +178,9 @@
 
     /**
      * Set the start block for this instance
-     *
-     * @param start_block
      */
-
     public void setStartBlock(int start_block)
     {
         _start_block = start_block;
     }
-
-    /* **********  END  implementation of BATManaged ********** */
-}   // end class BlockAllocationTableWriter
-
+}
diff --git a/src/java/org/apache/poi/poifs/storage/BlockList.java b/src/java/org/apache/poi/poifs/storage/BlockList.java
index 2352d3a..d7e23cf 100644
--- a/src/java/org/apache/poi/poifs/storage/BlockList.java
+++ b/src/java/org/apache/poi/poifs/storage/BlockList.java
@@ -59,13 +59,14 @@
      * blocks are removed from the list.
      *
      * @param startBlock the index of the first block in the stream
+     * @param headerPropertiesStartBlock the index of the first header block in the stream
      *
      * @return the stream as an array of correctly ordered blocks
      *
      * @exception IOException if blocks are missing
      */
 
-    public ListManagedBlock [] fetchBlocks(final int startBlock)
+    public ListManagedBlock [] fetchBlocks(final int startBlock, final int headerPropertiesStartBlock)
         throws IOException;
 
     /**
@@ -78,5 +79,7 @@
 
     public void setBAT(final BlockAllocationTableReader bat)
         throws IOException;
+    
+    public int blockCount();
 }   // end public interface BlockList
 
diff --git a/src/java/org/apache/poi/poifs/storage/BlockListImpl.java b/src/java/org/apache/poi/poifs/storage/BlockListImpl.java
index 7e44fda..b7c6a0c 100644
--- a/src/java/org/apache/poi/poifs/storage/BlockListImpl.java
+++ b/src/java/org/apache/poi/poifs/storage/BlockListImpl.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,30 +14,20 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
-
-import java.util.*;
+import java.io.IOException;
 
 /**
  * A simple implementation of BlockList
  *
  * @author Marc Johnson (mjohnson at apache dot org
  */
-
-class BlockListImpl
-    implements BlockList
-{
+abstract class BlockListImpl implements BlockList {
     private ListManagedBlock[]         _blocks;
     private BlockAllocationTableReader _bat;
 
-    /**
-     * Constructor BlockListImpl
-     */
-
     protected BlockListImpl()
     {
         _blocks = new ListManagedBlock[ 0 ];
@@ -50,21 +39,17 @@
      *
      * @param blocks blocks to be managed
      */
-
     protected void setBlocks(final ListManagedBlock [] blocks)
     {
         _blocks = blocks;
     }
 
-    /* ********** START implementation of BlockList ********** */
-
     /**
      * remove the specified block from the list
      *
      * @param index the index of the specified block; if the index is
      *              out of range, that's ok
      */
-
     public void zap(final int index)
     {
         if ((index >= 0) && (index < _blocks.length))
@@ -74,6 +59,14 @@
     }
 
     /**
+     * Unit testing method. Gets, without sanity checks or
+     *  removing.
+     */
+    protected ListManagedBlock get(final int index) {
+        return _blocks[index];
+    }
+
+    /**
      * remove and return the specified block from the list
      *
      * @param index the index of the specified block
@@ -83,7 +76,6 @@
      * @exception IOException if the index is out of range or has
      *            already been removed
      */
-
     public ListManagedBlock remove(final int index)
         throws IOException
     {
@@ -94,15 +86,17 @@
             result = _blocks[ index ];
             if (result == null)
             {
-                throw new IOException("block[ " + index
-                                      + " ] already removed");
+                throw new IOException(
+                		"block[ " + index + " ] already removed - " +
+                		"does your POIFS have circular or duplicate block references?"
+                );
             }
             _blocks[ index ] = null;
         }
         catch (ArrayIndexOutOfBoundsException ignored)
         {
             throw new IOException("Cannot remove block[ " + index
-                                  + " ]; out of range[ 0 - " + 
+                                  + " ]; out of range[ 0 - " +
                                   (_blocks.length-1) + " ]");
         }
         return result;
@@ -118,8 +112,7 @@
      *
      * @exception IOException if blocks are missing
      */
-
-    public ListManagedBlock [] fetchBlocks(final int startBlock)
+    public ListManagedBlock [] fetchBlocks(final int startBlock, final int headerPropertiesStartBlock)
         throws IOException
     {
         if (_bat == null)
@@ -127,17 +120,14 @@
             throw new IOException(
                 "Improperly initialized list: no block allocation table provided");
         }
-        return _bat.fetchBlocks(startBlock, this);
+        return _bat.fetchBlocks(startBlock, headerPropertiesStartBlock, this);
     }
 
     /**
      * set the associated BlockAllocationTable
      *
      * @param bat the associated BlockAllocationTable
-     *
-     * @exception IOException
      */
-
     public void setBAT(final BlockAllocationTableReader bat)
         throws IOException
     {
@@ -148,7 +138,21 @@
         }
         _bat = bat;
     }
-
-    /* **********  END  implementation of BlockList ********** */
-}   // end package-scope class BlockListImpl
-
+    
+    /**
+     * Returns the count of the number of blocks
+     */
+    public int blockCount() {
+       return _blocks.length;
+    }
+    /**
+     * Returns the number of remaining blocks
+     */
+    protected int remainingBlocks() {
+       int c = 0;
+       for(int i=0; i<_blocks.length; i++) {
+          if(_blocks[i] != null) c++;
+       }
+       return c;
+    }
+}
diff --git a/src/java/org/apache/poi/poifs/storage/DataInputBlock.java b/src/java/org/apache/poi/poifs/storage/DataInputBlock.java
new file mode 100644
index 0000000..a571a4f
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/storage/DataInputBlock.java
@@ -0,0 +1,186 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.storage;
+
+/**
+ * Wraps a <tt>byte</tt> array and provides simple data input access.
+ * Internally, this class maintains a buffer read index, so that for the most part, primitive
+ * data can be read in a data-input-stream-like manner.<p/>
+ *
+ * Note - the calling class should call the {@link #available()} method to detect end-of-buffer
+ * and move to the next data block when the current is exhausted.
+ * For optimisation reasons, no error handling is performed in this class.  Thus, mistakes in
+ * calling code ran may raise ugly exceptions here, like {@link ArrayIndexOutOfBoundsException},
+ * etc .<p/>
+ *
+ * The multi-byte primitive input methods ({@link #readUShortLE()}, {@link #readIntLE()} and
+ * {@link #readLongLE()}) have corresponding 'spanning read' methods which (when required) perform
+ * a read across the block boundary.  These spanning read methods take the previous
+ * {@link DataInputBlock} as a parameter.
+ * Reads of larger amounts of data (into <tt>byte</tt> array buffers) must be managed by the caller
+ * since these could conceivably involve more than two blocks.
+ *
+ * @author Josh Micich
+ */
+public final class DataInputBlock {
+
+	/**
+	 * Possibly any size (usually 512K or 64K).  Assumed to be at least 8 bytes for all blocks
+	 * before the end of the stream.  The last block in the stream can be any size except zero. 
+	 */
+	private final byte[] _buf;
+	private int _readIndex;
+	private int _maxIndex;
+
+	DataInputBlock(byte[] data, int startOffset) {
+		_buf = data;
+		_readIndex = startOffset;
+		_maxIndex = _buf.length;
+	}
+	public int available() {
+		return _maxIndex-_readIndex;
+	}
+
+	public int readUByte() {
+		return _buf[_readIndex++] & 0xFF;
+	}
+
+	/**
+	 * Reads a <tt>short</tt> which was encoded in <em>little endian</em> format.
+	 */
+	public int readUShortLE() {
+		int i = _readIndex;
+		
+		int b0 = _buf[i++] & 0xFF;
+		int b1 = _buf[i++] & 0xFF;
+		_readIndex = i;
+		return (b1 << 8) + (b0 << 0);
+	}
+
+	/**
+	 * Reads a <tt>short</tt> which spans the end of <tt>prevBlock</tt> and the start of this block.
+	 */
+	public int readUShortLE(DataInputBlock prevBlock) {
+		// simple case - will always be one byte in each block
+		int i = prevBlock._buf.length-1;
+		
+		int b0 = prevBlock._buf[i++] & 0xFF;
+		int b1 = _buf[_readIndex++] & 0xFF;
+		return (b1 << 8) + (b0 << 0);
+	}
+
+	/**
+	 * Reads an <tt>int</tt> which was encoded in <em>little endian</em> format.
+	 */
+	public int readIntLE() {
+		int i = _readIndex;
+		
+		int b0 = _buf[i++] & 0xFF;
+		int b1 = _buf[i++] & 0xFF;
+		int b2 = _buf[i++] & 0xFF;
+		int b3 = _buf[i++] & 0xFF;
+		_readIndex = i;
+		return (b3 << 24) + (b2 << 16) + (b1 << 8) + (b0 << 0);
+	}
+
+	/**
+	 * Reads an <tt>int</tt> which spans the end of <tt>prevBlock</tt> and the start of this block.
+	 */
+	public int readIntLE(DataInputBlock prevBlock, int prevBlockAvailable) {
+		byte[] buf = new byte[4];
+		
+		readSpanning(prevBlock, prevBlockAvailable, buf);
+		int b0 = buf[0] & 0xFF;
+		int b1 = buf[1] & 0xFF;
+		int b2 = buf[2] & 0xFF;
+		int b3 = buf[3] & 0xFF;
+		return (b3 << 24) + (b2 << 16) + (b1 << 8) + (b0 << 0);
+	}
+
+	/**
+	 * Reads a <tt>long</tt> which was encoded in <em>little endian</em> format.
+	 */
+	public long readLongLE() {
+		int i = _readIndex;
+		
+		int b0 = _buf[i++] & 0xFF;
+		int b1 = _buf[i++] & 0xFF;
+		int b2 = _buf[i++] & 0xFF;
+		int b3 = _buf[i++] & 0xFF;
+		int b4 = _buf[i++] & 0xFF;
+		int b5 = _buf[i++] & 0xFF;
+		int b6 = _buf[i++] & 0xFF;
+		int b7 = _buf[i++] & 0xFF;
+		_readIndex = i;
+		return (((long)b7 << 56) +
+				((long)b6 << 48) +
+				((long)b5 << 40) +
+				((long)b4 << 32) +
+				((long)b3 << 24) +
+				(b2 << 16) +
+				(b1 <<  8) +
+				(b0 <<  0));
+	}
+
+	/**
+	 * Reads a <tt>long</tt> which spans the end of <tt>prevBlock</tt> and the start of this block.
+	 */
+	public long readLongLE(DataInputBlock prevBlock, int prevBlockAvailable) {
+		byte[] buf = new byte[8];
+		
+		readSpanning(prevBlock, prevBlockAvailable, buf);
+		
+		int b0 = buf[0] & 0xFF;
+		int b1 = buf[1] & 0xFF;
+		int b2 = buf[2] & 0xFF;
+		int b3 = buf[3] & 0xFF;
+		int b4 = buf[4] & 0xFF;
+		int b5 = buf[5] & 0xFF;
+		int b6 = buf[6] & 0xFF;
+		int b7 = buf[7] & 0xFF;
+		return (((long)b7 << 56) +
+				((long)b6 << 48) +
+				((long)b5 << 40) +
+				((long)b4 << 32) +
+				((long)b3 << 24) +
+				(b2 << 16) +
+				(b1 <<  8) +
+				(b0 <<  0));
+	}
+
+	/**
+	 * Reads a small amount of data from across the boundary between two blocks.  
+	 * The {@link #_readIndex} of this (the second) block is updated accordingly.
+	 * Note- this method (and other code) assumes that the second {@link DataInputBlock}
+	 * always is big enough to complete the read without being exhausted.
+	 */
+	private void readSpanning(DataInputBlock prevBlock, int prevBlockAvailable, byte[] buf) {
+		System.arraycopy(prevBlock._buf, prevBlock._readIndex, buf, 0, prevBlockAvailable);
+		int secondReadLen = buf.length-prevBlockAvailable;
+		System.arraycopy(_buf, 0, buf, prevBlockAvailable, secondReadLen);
+		_readIndex = secondReadLen;
+	}
+
+	/**
+	 * Reads <tt>len</tt> bytes from this block into the supplied buffer.
+	 */
+	public void readFully(byte[] buf, int off, int len) {
+		System.arraycopy(_buf, _readIndex, buf, off, len);
+		_readIndex += len;
+	}
+}
diff --git a/src/java/org/apache/poi/poifs/storage/DocumentBlock.java b/src/java/org/apache/poi/poifs/storage/DocumentBlock.java
index ddaf5b3..a7c5686 100644
--- a/src/java/org/apache/poi/poifs/storage/DocumentBlock.java
+++ b/src/java/org/apache/poi/poifs/storage/DocumentBlock.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,31 +14,24 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-
 import java.util.Arrays;
 
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.util.IOUtils;
-import org.apache.poi.util.IntegerField;
-import org.apache.poi.util.LittleEndian;
-import org.apache.poi.util.LittleEndianConsts;
 
 /**
  * A block of document data.
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-
-public class DocumentBlock
-    extends BigBlock
-{
+public final class DocumentBlock extends BigBlock {
     private static final byte _default_value = ( byte ) 0xFF;
     private byte[]            _data;
     private int               _bytes_read;
@@ -55,6 +47,11 @@
     public DocumentBlock(final RawDataBlock block)
         throws IOException
     {
+        super(
+              block.getBigBlockSize() == POIFSConstants.SMALLER_BIG_BLOCK_SIZE ?
+                    POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS :
+                    POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS
+        );
         _data       = block.getData();
         _bytes_read = _data.length;
     }
@@ -67,10 +64,10 @@
      * @exception IOException
      */
 
-    public DocumentBlock(final InputStream stream)
+    public DocumentBlock(final InputStream stream, POIFSBigBlockSize bigBlockSize)
         throws IOException
     {
-        this();
+        this(bigBlockSize);
         int count = IOUtils.readFully(stream, _data);
 
         _bytes_read = (count == -1) ? 0
@@ -81,9 +78,10 @@
      * Create a single instance initialized with default values
      */
 
-    private DocumentBlock()
+    private DocumentBlock(POIFSBigBlockSize bigBlockSize)
     {
-        _data = new byte[ POIFSConstants.BIG_BLOCK_SIZE ];
+        super(bigBlockSize);
+        _data = new byte[ bigBlockSize.getBigBlockSize() ];
         Arrays.fill(_data, _default_value);
     }
 
@@ -106,7 +104,7 @@
 
     public boolean partiallyRead()
     {
-        return _bytes_read != POIFSConstants.BIG_BLOCK_SIZE;
+        return _bytes_read != bigBlockSize.getBigBlockSize();
     }
 
     /**
@@ -129,26 +127,27 @@
      *         input array
      */
 
-    public static DocumentBlock [] convert(final byte [] array,
+    public static DocumentBlock [] convert(final POIFSBigBlockSize bigBlockSize,
+                                           final byte [] array,
                                            final int size)
     {
         DocumentBlock[] rval   =
-            new DocumentBlock[ (size + POIFSConstants.BIG_BLOCK_SIZE - 1) / POIFSConstants.BIG_BLOCK_SIZE ];
+            new DocumentBlock[ (size + bigBlockSize.getBigBlockSize() - 1) / bigBlockSize.getBigBlockSize() ];
         int             offset = 0;
 
         for (int k = 0; k < rval.length; k++)
         {
-            rval[ k ] = new DocumentBlock();
+            rval[ k ] = new DocumentBlock(bigBlockSize);
             if (offset < array.length)
             {
-                int length = Math.min(POIFSConstants.BIG_BLOCK_SIZE,
+                int length = Math.min(bigBlockSize.getBigBlockSize(),
                                       array.length - offset);
 
                 System.arraycopy(array, offset, rval[ k ]._data, 0, length);
-                if (length != POIFSConstants.BIG_BLOCK_SIZE)
+                if (length != bigBlockSize.getBigBlockSize())
                 {
                     Arrays.fill(rval[ k ]._data, length,
-                                POIFSConstants.BIG_BLOCK_SIZE,
+                          bigBlockSize.getBigBlockSize(),
                                 _default_value);
                 }
             }
@@ -156,50 +155,26 @@
             {
                 Arrays.fill(rval[ k ]._data, _default_value);
             }
-            offset += POIFSConstants.BIG_BLOCK_SIZE;
+            offset += bigBlockSize.getBigBlockSize();
         }
         return rval;
     }
 
-    /**
-     * read data from an array of DocumentBlocks
-     *
-     * @param blocks the blocks to read from
-     * @param buffer the buffer to write the data into
-     * @param offset the offset into the array of blocks to read from
-     */
-
-    public static void read(final DocumentBlock [] blocks,
-                            final byte [] buffer, final int offset)
-    {
-        int firstBlockIndex  = offset / POIFSConstants.BIG_BLOCK_SIZE;
-        int firstBlockOffset = offset % POIFSConstants.BIG_BLOCK_SIZE;
-        int lastBlockIndex   = (offset + buffer.length - 1)
-                               / POIFSConstants.BIG_BLOCK_SIZE;
-
-        if (firstBlockIndex == lastBlockIndex)
-        {
-            System.arraycopy(blocks[ firstBlockIndex ]._data,
-                             firstBlockOffset, buffer, 0, buffer.length);
+    public static DataInputBlock getDataInputBlock(DocumentBlock[] blocks, int offset) {
+        if(blocks == null || blocks.length == 0) {
+           return null;
         }
-        else
-        {
-            int buffer_offset = 0;
+        
+        // Key things about the size of the block
+        POIFSBigBlockSize bigBlockSize = blocks[0].bigBlockSize;
+        int BLOCK_SHIFT = bigBlockSize.getHeaderValue();
+        int BLOCK_SIZE = bigBlockSize.getBigBlockSize();
+        int BLOCK_MASK = BLOCK_SIZE - 1;
 
-            System.arraycopy(blocks[ firstBlockIndex ]._data,
-                             firstBlockOffset, buffer, buffer_offset,
-                             POIFSConstants.BIG_BLOCK_SIZE
-                             - firstBlockOffset);
-            buffer_offset += POIFSConstants.BIG_BLOCK_SIZE - firstBlockOffset;
-            for (int j = firstBlockIndex + 1; j < lastBlockIndex; j++)
-            {
-                System.arraycopy(blocks[ j ]._data, 0, buffer, buffer_offset,
-                                 POIFSConstants.BIG_BLOCK_SIZE);
-                buffer_offset += POIFSConstants.BIG_BLOCK_SIZE;
-            }
-            System.arraycopy(blocks[ lastBlockIndex ]._data, 0, buffer,
-                             buffer_offset, buffer.length - buffer_offset);
-        }
+        // Now do the offset lookup
+        int firstBlockIndex = offset >> BLOCK_SHIFT;
+        int firstBlockOffset= offset & BLOCK_MASK;
+        return new DataInputBlock(blocks[firstBlockIndex]._data, firstBlockOffset);
     }
 
     /* ********** START extension of BigBlock ********** */
diff --git a/src/java/org/apache/poi/poifs/storage/HeaderBlock.java b/src/java/org/apache/poi/poifs/storage/HeaderBlock.java
new file mode 100644
index 0000000..5b9e071
--- /dev/null
+++ b/src/java/org/apache/poi/poifs/storage/HeaderBlock.java
@@ -0,0 +1,388 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.storage;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
+import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.filesystem.OfficeXmlFileException;
+import org.apache.poi.util.HexDump;
+import org.apache.poi.util.IOUtils;
+import org.apache.poi.util.IntegerField;
+import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
+import org.apache.poi.util.LongField;
+import org.apache.poi.util.POILogFactory;
+import org.apache.poi.util.POILogger;
+import org.apache.poi.util.ShortField;
+
+/**
+ * The block containing the archive header
+ */
+public final class HeaderBlock implements HeaderBlockConstants {
+   private static final POILogger _logger =
+      POILogFactory.getLogger(HeaderBlock.class);
+   
+	/**
+	 * What big block size the file uses. Most files
+	 *  use 512 bytes, but a few use 4096
+	 */
+	private final POIFSBigBlockSize bigBlockSize;
+
+	/** 
+	 * Number of big block allocation table blocks (int).
+	 * (Number of FAT Sectors in Microsoft parlance).
+	 */
+	private int _bat_count;
+
+	/** 
+	 * Start of the property set block (int index of the property set
+	 * chain's first big block).
+	 */
+	private int _property_start;
+
+	/** 
+	 * start of the small block allocation table (int index of small
+	 * block allocation table's first big block)
+	 */
+	private int _sbat_start;
+	/**
+	 * Number of small block allocation table blocks (int)
+	 * (Number of MiniFAT Sectors in Microsoft parlance)
+	 */
+	private int _sbat_count;
+
+	/** 
+	 * Big block index for extension to the big block allocation table
+	 */
+	private int _xbat_start;
+	/**
+	 * Number of big block allocation table blocks (int)
+	 * (Number of DIFAT Sectors in Microsoft parlance)
+	 */
+	private int _xbat_count;
+	
+	/**
+	 * The data. Only ever 512 bytes, because 4096 byte
+	 *  files use zeros for the extra header space.
+	 */
+	private final byte[] _data;
+	
+   private static final byte _default_value = ( byte ) 0xFF;
+
+	/**
+	 * create a new HeaderBlockReader from an InputStream
+	 *
+	 * @param stream the source InputStream
+	 *
+	 * @exception IOException on errors or bad data
+	 */
+	public HeaderBlock(InputStream stream) throws IOException {
+		// Grab the first 512 bytes
+	   // (For 4096 sized blocks, the remaining 3584 bytes are zero)
+		// Then, process the contents
+		this(readFirst512(stream));
+		
+		// Fetch the rest of the block if needed
+		if(bigBlockSize.getBigBlockSize() != 512) {
+		   int rest = bigBlockSize.getBigBlockSize() - 512;
+		   byte[] tmp = new byte[rest];
+		   IOUtils.readFully(stream, tmp);
+		}
+	}
+	
+	public HeaderBlock(ByteBuffer buffer) throws IOException {
+	   this(IOUtils.toByteArray(buffer, POIFSConstants.SMALLER_BIG_BLOCK_SIZE));
+	}
+	
+	private HeaderBlock(byte[] data) throws IOException {
+	   this._data = data;
+	   
+		// verify signature
+		long signature = LittleEndian.getLong(_data, _signature_offset);
+
+		if (signature != _signature) {
+			// Is it one of the usual suspects?
+			byte[] OOXML_FILE_HEADER = POIFSConstants.OOXML_FILE_HEADER;
+			if(_data[0] == OOXML_FILE_HEADER[0] &&
+				_data[1] == OOXML_FILE_HEADER[1] &&
+				_data[2] == OOXML_FILE_HEADER[2] &&
+				_data[3] == OOXML_FILE_HEADER[3]) {
+				throw new OfficeXmlFileException("The supplied data appears to be in the Office 2007+ XML. You are calling the part of POI that deals with OLE2 Office Documents. You need to call a different part of POI to process this data (eg XSSF instead of HSSF)");
+			}
+			if ((signature & 0xFF8FFFFFFFFFFFFFL) == 0x0010000200040009L) {
+				// BIFF2 raw stream starts with BOF (sid=0x0009, size=0x0004, data=0x00t0)
+				throw new IllegalArgumentException("The supplied data appears to be in BIFF2 format.  "
+						+ "POI only supports BIFF8 format");
+			}
+
+			// Give a generic error
+			throw new IOException("Invalid header signature; read "
+				                  + longToHex(signature) + ", expected "
+				                  + longToHex(_signature));
+		}
+
+
+		// Figure out our block size
+		if (_data[30] == 12) {
+			this.bigBlockSize = POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS;
+		} else if(_data[30] == 9) {
+			this.bigBlockSize = POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS;
+		} else {
+		   throw new IOException("Unsupported blocksize  (2^"+ _data[30] + "). Expected 2^9 or 2^12.");
+		}
+
+	   // Setup the fields to read and write the counts and starts
+      _bat_count      = new IntegerField(_bat_count_offset, data).get();
+      _property_start = new IntegerField(_property_start_offset,_data).get();
+      _sbat_start = new IntegerField(_sbat_start_offset, _data).get();
+      _sbat_count = new IntegerField(_sbat_block_count_offset, _data).get();
+      _xbat_start = new IntegerField(_xbat_start_offset, _data).get();
+      _xbat_count = new IntegerField(_xbat_count_offset, _data).get();
+	}
+	
+   /**
+    * Create a single instance initialized with default values
+    */
+   public HeaderBlock(POIFSBigBlockSize bigBlockSize)
+   {
+      this.bigBlockSize = bigBlockSize;
+
+      // Our data is always 512 big no matter what
+      _data = new byte[ POIFSConstants.SMALLER_BIG_BLOCK_SIZE ];
+      Arrays.fill(_data, _default_value);
+      
+      // Set all the default values
+      new LongField(_signature_offset, _signature, _data);
+      new IntegerField(0x08, 0, _data);
+      new IntegerField(0x0c, 0, _data);
+      new IntegerField(0x10, 0, _data);
+      new IntegerField(0x14, 0, _data);
+      new ShortField(0x18, ( short ) 0x3b, _data);
+      new ShortField(0x1a, ( short ) 0x3, _data);
+      new ShortField(0x1c, ( short ) -2, _data);
+       
+      new ShortField(0x1e, bigBlockSize.getHeaderValue(), _data);
+      new IntegerField(0x20, 0x6, _data);
+      new IntegerField(0x24, 0, _data);
+      new IntegerField(0x28, 0, _data);
+      new IntegerField(0x34, 0, _data);
+      new IntegerField(0x38, 0x1000, _data);
+      
+      // Initialise the variables
+      _bat_count = 0;
+      _sbat_count = 0;
+      _xbat_count = 0;
+      _property_start = POIFSConstants.END_OF_CHAIN;
+      _sbat_start = POIFSConstants.END_OF_CHAIN;
+      _xbat_start = POIFSConstants.END_OF_CHAIN;
+   }
+   
+	private static byte[] readFirst512(InputStream stream) throws IOException {
+      // Grab the first 512 bytes
+      // (For 4096 sized blocks, the remaining 3584 bytes are zero)
+      byte[] data = new byte[512];
+      int bsCount = IOUtils.readFully(stream, data);
+      if(bsCount != 512) {
+         throw alertShortRead(bsCount, 512);
+      }
+      return data;
+	}
+
+	private static String longToHex(long value) {
+		return new String(HexDump.longToHex(value));
+	}
+
+	private static IOException alertShortRead(int pRead, int expectedReadSize) {
+		int read;
+		if (pRead < 0) {
+			//Can't have -1 bytes read in the error message!
+			read = 0;
+		} else {
+			read = pRead;
+		}
+		String type = " byte" + (read == 1 ? (""): ("s"));
+
+		return new IOException("Unable to read entire header; "
+				+ read + type + " read; expected "
+				+ expectedReadSize + " bytes");
+	}
+
+	/**
+	 * get start of Property Table
+	 *
+	 * @return the index of the first block of the Property Table
+	 */
+	public int getPropertyStart() {
+		return _property_start;
+	}
+   /**
+    * Set start of Property Table
+    *
+    * @param startBlock the index of the first block of the Property Table
+    */
+   public void setPropertyStart(final int startBlock) {
+       _property_start = startBlock;
+   }
+
+	/**
+	 * @return start of small block (MiniFAT) allocation table
+	 */
+	public int getSBATStart() {
+		return _sbat_start;
+	}
+	public int getSBATCount() {
+	   return _sbat_count;
+	}
+	
+   /**
+    * Set start of small block allocation table
+    *
+    * @param startBlock the index of the first big block of the small
+    *                   block allocation table
+    */
+   public void setSBATStart(final int startBlock) {
+       _sbat_start = startBlock;
+   }
+   /**
+    * Set count of SBAT blocks
+    *
+    * @param count the number of SBAT blocks
+    */
+   public void setSBATBlockCount(final int count)
+   {
+      _sbat_count = count;
+   }
+
+	/**
+	 * @return number of BAT blocks
+	 */
+	public int getBATCount() {
+		return _bat_count;
+	}
+   /**
+    * Sets the number of BAT blocks that are used.
+    * This is the number used in both the BAT and XBAT. 
+    */
+   public void setBATCount(final int count) {
+      _bat_count = count;
+   }
+
+	/**
+	 * Returns the offsets to the first (up to) 109
+	 *  BAT sectors.
+	 * Any additional BAT sectors are held in the XBAT (DIFAT)
+	 *  sectors in a chain.
+	 * @return BAT offset array
+	 */
+	public int[] getBATArray() {
+      // Read them in
+		int[] result = new int[ Math.min(_bat_count,_max_bats_in_header) ];
+		int offset = _bat_array_offset;
+		for (int j = 0; j < result.length; j++) {
+			result[ j ] = LittleEndian.getInt(_data, offset);
+			offset     += LittleEndianConsts.INT_SIZE;
+		}
+		return result;
+	}
+	/**
+	 * Sets the offsets of the first (up to) 109
+	 *  BAT sectors.
+	 */
+	public void setBATArray(int[] bat_array) {
+	   int count = Math.min(bat_array.length, _max_bats_in_header);
+	   int blank = _max_bats_in_header - count;
+	   
+      int offset = _bat_array_offset;
+	   for(int i=0; i<count; i++) {
+	      LittleEndian.putInt(_data, offset, bat_array[i]);
+         offset += LittleEndianConsts.INT_SIZE;
+	   }
+	   for(int i=0; i<blank; i++) {
+         LittleEndian.putInt(_data, offset, POIFSConstants.UNUSED_BLOCK);
+         offset += LittleEndianConsts.INT_SIZE;
+	   }
+	}
+
+	/**
+	 * @return XBAT (DIFAT) count
+	 */
+	public int getXBATCount() {
+		return _xbat_count;
+	}
+	/**
+	 * Sets the number of XBAT (DIFAT) blocks used
+	 */
+	public void setXBATCount(final int count) {
+	   _xbat_count = count;
+	}
+
+	/**
+	 * @return XBAT (DIFAT) index
+	 */
+	public int getXBATIndex() {
+		return _xbat_start;
+	}
+	/**
+	 * Sets the first XBAT (DIFAT) block location
+	 */
+   public void setXBATStart(final int startBlock) {
+      _xbat_start = startBlock;
+  }
+
+	/**
+	 * @return The Big Block size, normally 512 bytes, sometimes 4096 bytes
+	 */
+	public POIFSBigBlockSize getBigBlockSize() {
+		return bigBlockSize;
+	}
+	
+   /**
+    * Write the block's data to an OutputStream
+    *
+    * @param stream the OutputStream to which the stored data should
+    *               be written
+    *
+    * @exception IOException on problems writing to the specified
+    *            stream
+    */
+   void writeData(final OutputStream stream)
+       throws IOException
+   {
+      // Update the counts and start positions 
+      new IntegerField(_bat_count_offset,      _bat_count, _data);
+      new IntegerField(_property_start_offset, _property_start, _data);
+      new IntegerField(_sbat_start_offset,     _sbat_start, _data);
+      new IntegerField(_sbat_block_count_offset, _sbat_count, _data);
+      new IntegerField(_xbat_start_offset,      _xbat_start, _data);
+      new IntegerField(_xbat_count_offset,      _xbat_count, _data);
+      
+      // Write the main data out
+      stream.write(_data, 0, 512);
+      
+      // Now do the padding if needed
+      for(int i=POIFSConstants.SMALLER_BIG_BLOCK_SIZE; i<bigBlockSize.getBigBlockSize(); i++) {
+         stream.write(0);
+      }
+   }
+}
diff --git a/src/java/org/apache/poi/poifs/storage/HeaderBlockConstants.java b/src/java/org/apache/poi/poifs/storage/HeaderBlockConstants.java
index 075a224..27e4b41 100644
--- a/src/java/org/apache/poi/poifs/storage/HeaderBlockConstants.java
+++ b/src/java/org/apache/poi/poifs/storage/HeaderBlockConstants.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,31 +14,30 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
 import org.apache.poi.poifs.common.POIFSConstants;
-import org.apache.poi.util.IntegerField;
-import org.apache.poi.util.LittleEndian;
 import org.apache.poi.util.LittleEndianConsts;
-import org.apache.poi.util.LongField;
-import org.apache.poi.util.ShortField;
 
 /**
  * Constants used in reading/writing the Header block
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-
 public interface HeaderBlockConstants
 {
     public static final long _signature               = 0xE11AB1A1E011CFD0L;
     public static final int  _bat_array_offset        = 0x4c;
     public static final int  _max_bats_in_header      =
-        (POIFSConstants.BIG_BLOCK_SIZE - _bat_array_offset)
-        / LittleEndianConsts.INT_SIZE;
+        (POIFSConstants.SMALLER_BIG_BLOCK_SIZE - _bat_array_offset)
+        / LittleEndianConsts.INT_SIZE; // If 4k blocks, rest is blank
 
+    // Note - in Microsoft terms:
+    //  BAT ~= FAT
+    //  SBAT ~= MiniFAT
+    //  XBAT ~= DIFat
+    
     // useful offsets
     public static final int  _signature_offset        = 0;
     public static final int  _bat_count_offset        = 0x2C;
diff --git a/src/java/org/apache/poi/poifs/storage/HeaderBlockReader.java b/src/java/org/apache/poi/poifs/storage/HeaderBlockReader.java
deleted file mode 100644
index b001b81..0000000
--- a/src/java/org/apache/poi/poifs/storage/HeaderBlockReader.java
+++ /dev/null
@@ -1,205 +0,0 @@
-
-/* ====================================================================
-   Licensed to the Apache Software Foundation (ASF) under one or more
-   contributor license agreements.  See the NOTICE file distributed with
-   this work for additional information regarding copyright ownership.
-   The ASF licenses this file to You 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.
-==================================================================== */
-        
-
-package org.apache.poi.poifs.storage;
-
-import java.io.*;
-
-import org.apache.poi.poifs.common.POIFSConstants;
-import org.apache.poi.poifs.filesystem.OfficeXmlFileException;
-import org.apache.poi.util.IOUtils;
-import org.apache.poi.util.IntegerField;
-import org.apache.poi.util.LittleEndian;
-import org.apache.poi.util.LittleEndianConsts;
-import org.apache.poi.util.LongField;
-
-/**
- * The block containing the archive header
- *
- * @author Marc Johnson (mjohnson at apache dot org)
- */
-
-public class HeaderBlockReader
-    implements HeaderBlockConstants
-{
-    /**
-     * What big block size the file uses. Most files
-     *  use 512 bytes, but a few use 4096
-     */
-    private int bigBlockSize = POIFSConstants.BIG_BLOCK_SIZE;
-
-    // number of big block allocation table blocks (int)
-    private IntegerField _bat_count;
-
-    // start of the property set block (int index of the property set
-    // chain's first big block)
-    private IntegerField _property_start;
-
-    // start of the small block allocation table (int index of small
-    // block allocation table's first big block)
-    private IntegerField _sbat_start;
-
-    // big block index for extension to the big block allocation table
-    private IntegerField _xbat_start;
-    private IntegerField _xbat_count;
-    private byte[]       _data;
-
-    /**
-     * create a new HeaderBlockReader from an InputStream
-     *
-     * @param stream the source InputStream
-     *
-     * @exception IOException on errors or bad data
-     */
-
-    public HeaderBlockReader(final InputStream stream)
-        throws IOException
-    {
-    	// At this point, we don't know how big our
-    	//  block sizes are
-    	// So, read the first 32 bytes to check, then
-    	//  read the rest of the block
-    	byte[] blockStart = new byte[32];
-    	int bsCount = IOUtils.readFully(stream, blockStart);
-    	if(bsCount != 32) {
-    		alertShortRead(bsCount);
-    	}
-    	
-    	// Figure out our block size
-    	if(blockStart[30] == 12) {
-    		bigBlockSize = POIFSConstants.LARGER_BIG_BLOCK_SIZE;
-    	}
-        _data = new byte[ bigBlockSize ];
-        System.arraycopy(blockStart, 0, _data, 0, blockStart.length);
-    	
-    	// Now we can read the rest of our header
-        int byte_count = IOUtils.readFully(stream, _data, blockStart.length, _data.length - blockStart.length);
-        if (byte_count+bsCount != bigBlockSize) {
-    		alertShortRead(byte_count);
-        }
-
-        // verify signature
-        LongField signature = new LongField(_signature_offset, _data);
-
-        if (signature.get() != _signature)
-        {
-			// Is it one of the usual suspects?
-        	byte[] OOXML_FILE_HEADER = POIFSConstants.OOXML_FILE_HEADER;
-			if(_data[0] == OOXML_FILE_HEADER[0] && 
-					_data[1] == OOXML_FILE_HEADER[1] && 
-					_data[2] == OOXML_FILE_HEADER[2] &&
-					_data[3] == OOXML_FILE_HEADER[3]) {
-				throw new OfficeXmlFileException("The supplied data appears to be in the Office 2007+ XML. POI only supports OLE2 Office documents");
-			}
-
-			// Give a generic error
-            throw new IOException("Invalid header signature; read "
-                                  + signature.get() + ", expected "
-                                  + _signature);
-        }
-        _bat_count      = new IntegerField(_bat_count_offset, _data);
-        _property_start = new IntegerField(_property_start_offset, _data);
-        _sbat_start     = new IntegerField(_sbat_start_offset, _data);
-        _xbat_start     = new IntegerField(_xbat_start_offset, _data);
-        _xbat_count     = new IntegerField(_xbat_count_offset, _data);
-    }
-    
-    private void alertShortRead(int read) throws IOException {
-    	if (read == -1)
-    		//Cant have -1 bytes read in the error message!
-    		read = 0;
-        String type = " byte" + ((read == 1) ? ("")
-                                                   : ("s"));
-
-        throw new IOException("Unable to read entire header; "
-                              + read + type + " read; expected "
-                              + bigBlockSize + " bytes");
-    }
-
-    /**
-     * get start of Property Table
-     *
-     * @return the index of the first block of the Property Table
-     */
-    public int getPropertyStart()
-    {
-        return _property_start.get();
-    }
-
-    /**
-     * @return start of small block allocation table
-     */
-
-    public int getSBATStart()
-    {
-        return _sbat_start.get();
-    }
-
-    /**
-     * @return number of BAT blocks
-     */
-
-    public int getBATCount()
-    {
-        return _bat_count.get();
-    }
-
-    /**
-     * @return BAT array
-     */
-
-    public int [] getBATArray()
-    {
-        int[] result = new int[ _max_bats_in_header ];
-        int   offset = _bat_array_offset;
-
-        for (int j = 0; j < _max_bats_in_header; j++)
-        {
-            result[ j ] = LittleEndian.getInt(_data, offset);
-            offset      += LittleEndianConsts.INT_SIZE;
-        }
-        return result;
-    }
-
-    /**
-     * @return XBAT count
-     */
-
-    public int getXBATCount()
-    {
-        return _xbat_count.get();
-    }
-
-    /**
-     * @return XBAT index
-     */
-
-    public int getXBATIndex()
-    {
-        return _xbat_start.get();
-    }
-    
-    /**
-     * @return The Big Block size, normally 512 bytes, sometimes 4096 bytes
-     */
-    public int getBigBlockSize() {
-    	return bigBlockSize;
-    }
-}   // end public class HeaderBlockReader
-
diff --git a/src/java/org/apache/poi/poifs/storage/HeaderBlockWriter.java b/src/java/org/apache/poi/poifs/storage/HeaderBlockWriter.java
index 84d0036..531c2e8 100644
--- a/src/java/org/apache/poi/poifs/storage/HeaderBlockWriter.java
+++ b/src/java/org/apache/poi/poifs/storage/HeaderBlockWriter.java
@@ -19,80 +19,38 @@
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
 
-import java.util.*;
-
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.common.POIFSConstants;
-import org.apache.poi.util.IntegerField;
-import org.apache.poi.util.LittleEndianConsts;
-import org.apache.poi.util.LongField;
-import org.apache.poi.util.ShortField;
 
 /**
  * The block containing the archive header
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-
-public class HeaderBlockWriter
-    extends BigBlock
-    implements HeaderBlockConstants
+public class HeaderBlockWriter implements HeaderBlockConstants, BlockWritable
 {
-    private static final byte _default_value = ( byte ) 0xFF;
-
-    // number of big block allocation table blocks (int)
-    private IntegerField      _bat_count;
-
-    // start of the property set block (int index of the property set
-    // chain's first big block)
-    private IntegerField      _property_start;
-
-    // start of the small block allocation table (int index of small
-    // block allocation table's first big block)
-    private IntegerField      _sbat_start;
-
-    // number of big blocks holding the small block allocation table
-    private IntegerField      _sbat_block_count;
-
-    // big block index for extension to the big block allocation table
-    private IntegerField      _xbat_start;
-    private IntegerField      _xbat_count;
-    private byte[]            _data;
+   private final HeaderBlock _header_block;
 
     /**
      * Create a single instance initialized with default values
      */
-
-    public HeaderBlockWriter()
+    public HeaderBlockWriter(POIFSBigBlockSize bigBlockSize)
     {
-        _data = new byte[ POIFSConstants.BIG_BLOCK_SIZE ];
-        Arrays.fill(_data, _default_value);
-        new LongField(_signature_offset, _signature, _data);
-        new IntegerField(0x08, 0, _data);
-        new IntegerField(0x0c, 0, _data);
-        new IntegerField(0x10, 0, _data);
-        new IntegerField(0x14, 0, _data);
-        new ShortField(0x18, ( short ) 0x3b, _data);
-        new ShortField(0x1a, ( short ) 0x3, _data);
-        new ShortField(0x1c, ( short ) -2, _data);
-        new ShortField(0x1e, ( short ) 0x9, _data);
-        new IntegerField(0x20, 0x6, _data);
-        new IntegerField(0x24, 0, _data);
-        new IntegerField(0x28, 0, _data);
-        _bat_count      = new IntegerField(_bat_count_offset, 0, _data);
-        _property_start = new IntegerField(_property_start_offset,
-                                           POIFSConstants.END_OF_CHAIN,
-                                           _data);
-        new IntegerField(0x34, 0, _data);
-        new IntegerField(0x38, 0x1000, _data);
-        _sbat_start = new IntegerField(_sbat_start_offset,
-                                       POIFSConstants.END_OF_CHAIN, _data);
-        _sbat_block_count = new IntegerField(_sbat_block_count_offset, 0,
-					     _data);
-        _xbat_start = new IntegerField(_xbat_start_offset,
-                                       POIFSConstants.END_OF_CHAIN, _data);
-        _xbat_count = new IntegerField(_xbat_count_offset, 0, _data);
+       _header_block = new HeaderBlock(bigBlockSize);
+    }
+
+    /**
+     * Create a single instance initialized with the specified 
+     *  existing values
+     */
+    public HeaderBlockWriter(HeaderBlock headerBlock)
+    {
+       _header_block = headerBlock;
     }
 
     /**
@@ -111,16 +69,19 @@
                                     final int startBlock)
     {
         BATBlock[] rvalue;
+        POIFSBigBlockSize bigBlockSize = _header_block.getBigBlockSize();
 
-        _bat_count.set(blockCount, _data);
+        _header_block.setBATCount(blockCount);
+
+        // Set the BAT locations
         int limit  = Math.min(blockCount, _max_bats_in_header);
-        int offset = _bat_array_offset;
-
-        for (int j = 0; j < limit; j++)
-        {
-            new IntegerField(offset, startBlock + j, _data);
-            offset += LittleEndianConsts.INT_SIZE;
+        int[] bat_blocks = new int[limit];
+        for (int j = 0; j < limit; j++) {
+           bat_blocks[j] = startBlock + j;
         }
+        _header_block.setBATArray(bat_blocks);
+        
+        // Now do the XBATs
         if (blockCount > _max_bats_in_header)
         {
             int   excess_blocks      = blockCount - _max_bats_in_header;
@@ -131,16 +92,16 @@
                 excess_block_array[ j ] = startBlock + j
                                           + _max_bats_in_header;
             }
-            rvalue = BATBlock.createXBATBlocks(excess_block_array,
+            rvalue = BATBlock.createXBATBlocks(bigBlockSize, excess_block_array,
                                                startBlock + blockCount);
-            _xbat_start.set(startBlock + blockCount, _data);
+            _header_block.setXBATStart(startBlock + blockCount);
         }
         else
         {
-            rvalue = BATBlock.createXBATBlocks(new int[ 0 ], 0);
-            _xbat_start.set(POIFSConstants.END_OF_CHAIN, _data);
+            rvalue = BATBlock.createXBATBlocks(bigBlockSize, new int[ 0 ], 0);
+            _header_block.setXBATStart(POIFSConstants.END_OF_CHAIN);
         }
-        _xbat_count.set(rvalue.length, _data);
+        _header_block.setXBATCount(rvalue.length);
         return rvalue;
     }
 
@@ -150,10 +111,9 @@
      * @param startBlock the index of the first block of the Property
      *                   Table
      */
-
     public void setPropertyStart(final int startBlock)
     {
-        _property_start.set(startBlock, _data);
+       _header_block.setPropertyStart(startBlock);
     }
 
     /**
@@ -162,10 +122,9 @@
      * @param startBlock the index of the first big block of the small
      *                   block allocation table
      */
-
     public void setSBATStart(final int startBlock)
     {
-        _sbat_start.set(startBlock, _data);
+        _header_block.setSBATStart(startBlock);
     }
 
     /**
@@ -173,10 +132,9 @@
      *
      * @param count the number of SBAT blocks
      */
-
     public void setSBATBlockCount(final int count)
     {
-	_sbat_block_count.set(count, _data);
+       _header_block.setSBATBlockCount(count);
     }
 
     /**
@@ -188,11 +146,11 @@
      * @return number of XBAT blocks needed
      */
 
-    static int calculateXBATStorageRequirements(final int blockCount)
+    static int calculateXBATStorageRequirements(POIFSBigBlockSize bigBlockSize, final int blockCount)
     {
         return (blockCount > _max_bats_in_header)
-               ? BATBlock.calculateXBATStorageRequirements(blockCount
-                   - _max_bats_in_header)
+               ? BATBlock.calculateXBATStorageRequirements(
+                     bigBlockSize, blockCount - _max_bats_in_header)
                : 0;
     }
 
@@ -207,11 +165,29 @@
      * @exception IOException on problems writing to the specified
      *            stream
      */
-
-    void writeData(final OutputStream stream)
+    public void writeBlocks(final OutputStream stream)
         throws IOException
     {
-        doWriteData(stream, _data);
+        _header_block.writeData(stream);
+    }
+    
+    /**
+     * Write the block's data to an existing block
+     *
+     * @param block the ByteBuffer of the block to which the 
+     *               stored data should be written
+     *
+     * @exception IOException on problems writing to the block
+     */
+    public void writeBlock(ByteBuffer block)
+        throws IOException
+    {
+       ByteArrayOutputStream baos = new ByteArrayOutputStream(
+             _header_block.getBigBlockSize().getBigBlockSize()
+       );
+       _header_block.writeData(baos);
+       
+       block.put(baos.toByteArray());
     }
 
     /* **********  END  extension of BigBlock ********** */
diff --git a/src/java/org/apache/poi/poifs/storage/PropertyBlock.java b/src/java/org/apache/poi/poifs/storage/PropertyBlock.java
index 5dfaac5..c824166 100644
--- a/src/java/org/apache/poi/poifs/storage/PropertyBlock.java
+++ b/src/java/org/apache/poi/poifs/storage/PropertyBlock.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,31 +14,22 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.List;
 
-import java.util.*;
-
-import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.property.Property;
-import org.apache.poi.util.IntegerField;
-import org.apache.poi.util.LittleEndian;
-import org.apache.poi.util.LittleEndianConsts;
 
 /**
  * A block of Property instances
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-
-public class PropertyBlock
-    extends BigBlock
-{
-    private static final int _properties_per_block =
-        POIFSConstants.BIG_BLOCK_SIZE / POIFSConstants.PROPERTY_SIZE;
+public final class PropertyBlock extends BigBlock {
     private Property[]       _properties;
 
     /**
@@ -49,10 +39,12 @@
      * @param offset the offset into the properties array
      */
 
-    private PropertyBlock(final Property [] properties, final int offset)
+    private PropertyBlock(final POIFSBigBlockSize bigBlockSize, final Property [] properties, final int offset)
     {
-        _properties = new Property[ _properties_per_block ];
-        for (int j = 0; j < _properties_per_block; j++)
+        super(bigBlockSize);
+        
+        _properties = new Property[ bigBlockSize.getPropertiesPerBlock() ]; 
+        for (int j = 0; j < _properties.length; j++)
         {
             _properties[ j ] = properties[ j + offset ];
         }
@@ -70,8 +62,9 @@
      */
 
     public static BlockWritable [] createPropertyBlockArray(
-            final List properties)
+            final POIFSBigBlockSize bigBlockSize, final List<Property> properties)
     {
+        int _properties_per_block = bigBlockSize.getPropertiesPerBlock();
         int        block_count   =
             (properties.size() + _properties_per_block - 1)
             / _properties_per_block;
@@ -101,7 +94,7 @@
 
         for (int j = 0; j < block_count; j++)
         {
-            rvalue[ j ] = new PropertyBlock(to_be_written,
+            rvalue[ j ] = new PropertyBlock(bigBlockSize, to_be_written,
                                             j * _properties_per_block);
         }
         return rvalue;
@@ -122,6 +115,7 @@
     void writeData(final OutputStream stream)
         throws IOException
     {
+        int _properties_per_block = bigBlockSize.getPropertiesPerBlock();
         for (int j = 0; j < _properties_per_block; j++)
         {
             _properties[ j ].writeData(stream);
diff --git a/src/java/org/apache/poi/poifs/storage/RawDataBlock.java b/src/java/org/apache/poi/poifs/storage/RawDataBlock.java
index 5ca1781..018ee8f 100644
--- a/src/java/org/apache/poi/poifs/storage/RawDataBlock.java
+++ b/src/java/org/apache/poi/poifs/storage/RawDataBlock.java
@@ -51,13 +51,14 @@
      */
     public RawDataBlock(final InputStream stream)
     		throws IOException {
-    	this(stream, POIFSConstants.BIG_BLOCK_SIZE);
+    	this(stream, POIFSConstants.SMALLER_BIG_BLOCK_SIZE);
     }
     /**
      * Constructor RawDataBlock
      *
      * @param stream the InputStream from which the data will be read
-     * @param blockSize the size of the POIFS blocks, normally 512 bytes {@link POIFSConstants#BIG_BLOCK_SIZE}
+     * @param blockSize the size of the POIFS blocks, normally 512 bytes
+     * {@link org.apache.poi.poifs.common.POIFSConstants#SMALLER_BIG_BLOCK_SIZE}
      *
      * @exception IOException on I/O errors, and if an insufficient
      *            amount of data is read (the InputStream must
@@ -111,6 +112,10 @@
     public boolean hasData() {
     	return _hasData;
     }
+    
+    public String toString() {
+       return "RawDataBlock of size " + _data.length; 
+    }
 
     /* ********** START implementation of ListManagedBlock ********** */
 
@@ -130,6 +135,13 @@
         }
         return _data;
     }
+    
+    /**
+     * What's the big block size?
+     */
+    public int getBigBlockSize() {
+       return _data.length;
+    }
 
     /* **********  END  implementation of ListManagedBlock ********** */
 }   // end public class RawDataBlock
diff --git a/src/java/org/apache/poi/poifs/storage/RawDataBlockList.java b/src/java/org/apache/poi/poifs/storage/RawDataBlockList.java
index 66eb237..eb8bcc0 100644
--- a/src/java/org/apache/poi/poifs/storage/RawDataBlockList.java
+++ b/src/java/org/apache/poi/poifs/storage/RawDataBlockList.java
@@ -23,6 +23,8 @@
 
 import java.util.*;
 
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
+
 /**
  * A list of RawDataBlocks instances, and methods to manage the list
  *
@@ -43,14 +45,14 @@
      *            block is read
      */
 
-    public RawDataBlockList(final InputStream stream, int bigBlockSize)
+    public RawDataBlockList(final InputStream stream, POIFSBigBlockSize bigBlockSize)
         throws IOException
     {
-        List blocks = new ArrayList();
+        List<RawDataBlock> blocks = new ArrayList<RawDataBlock>();
 
         while (true)
         {
-            RawDataBlock block = new RawDataBlock(stream, bigBlockSize);
+            RawDataBlock block = new RawDataBlock(stream, bigBlockSize.getBigBlockSize());
             
             // If there was data, add the block to the list
             if(block.hasData()) {
@@ -62,7 +64,7 @@
                 break;
             }
         }
-        setBlocks(( RawDataBlock [] ) blocks.toArray(new RawDataBlock[ 0 ]));
+        setBlocks( blocks.toArray(new RawDataBlock[ blocks.size() ]) );
     }
 }   // end public class RawDataBlockList
 
diff --git a/src/java/org/apache/poi/poifs/storage/SmallBlockTableReader.java b/src/java/org/apache/poi/poifs/storage/SmallBlockTableReader.java
index e70774a..8b6efd3 100644
--- a/src/java/org/apache/poi/poifs/storage/SmallBlockTableReader.java
+++ b/src/java/org/apache/poi/poifs/storage/SmallBlockTableReader.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,25 +14,21 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
+import java.io.IOException;
+
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.property.RootProperty;
 
-import java.util.*;
-
-import java.io.*;
-
 /**
  * This class implements reading the small document block list from an
  * existing file
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-
-public class SmallBlockTableReader
-{
+public final class SmallBlockTableReader {
 
     /**
      * fetch the small document block list from an existing file
@@ -48,17 +43,23 @@
      *
      * @exception IOException
      */
-
     public static BlockList getSmallDocumentBlocks(
+            final POIFSBigBlockSize bigBlockSize,
             final RawDataBlockList blockList, final RootProperty root,
             final int sbatStart)
         throws IOException
     {
-        BlockList list =
-            new SmallDocumentBlockList(SmallDocumentBlock
-                .extract(blockList.fetchBlocks(root.getStartBlock())));
+       // Fetch the blocks which hold the Small Blocks stream
+       ListManagedBlock [] smallBlockBlocks = 
+          blockList.fetchBlocks(root.getStartBlock(), -1);
+        
+       // Turn that into a list
+       BlockList list =new SmallDocumentBlockList(
+             SmallDocumentBlock.extract(bigBlockSize, smallBlockBlocks));
 
-        new BlockAllocationTableReader(blockList.fetchBlocks(sbatStart),
+       // Process
+        new BlockAllocationTableReader(bigBlockSize,
+                                       blockList.fetchBlocks(sbatStart, -1),
                                        list);
         return list;
     }
diff --git a/src/java/org/apache/poi/poifs/storage/SmallBlockTableWriter.java b/src/java/org/apache/poi/poifs/storage/SmallBlockTableWriter.java
index 4f89af1..2db7bf4 100644
--- a/src/java/org/apache/poi/poifs/storage/SmallBlockTableWriter.java
+++ b/src/java/org/apache/poi/poifs/storage/SmallBlockTableWriter.java
@@ -19,6 +19,7 @@
 
 package org.apache.poi.poifs.storage;
 
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.poifs.filesystem.BATManaged;
 import org.apache.poi.poifs.filesystem.POIFSDocument;
@@ -50,10 +51,11 @@
      * @param root the Filesystem's root property
      */
 
-    public SmallBlockTableWriter(final List documents,
+    public SmallBlockTableWriter(final POIFSBigBlockSize bigBlockSize,
+                                 final List documents,
                                  final RootProperty root)
     {
-        _sbat         = new BlockAllocationTableWriter();
+        _sbat         = new BlockAllocationTableWriter(bigBlockSize);
         _small_blocks = new ArrayList();
         _root         = root;
         Iterator iter = documents.iterator();
@@ -76,7 +78,7 @@
         }
         _sbat.simpleCreateBlocks();
         _root.setSize(_small_blocks.size());
-        _big_block_count = SmallDocumentBlock.fill(_small_blocks);
+        _big_block_count = SmallDocumentBlock.fill(bigBlockSize,_small_blocks);
     }
 
     /**
diff --git a/src/java/org/apache/poi/poifs/storage/SmallDocumentBlock.java b/src/java/org/apache/poi/poifs/storage/SmallDocumentBlock.java
index dabf280..e7762ff 100644
--- a/src/java/org/apache/poi/poifs/storage/SmallDocumentBlock.java
+++ b/src/java/org/apache/poi/poifs/storage/SmallDocumentBlock.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,14 +14,17 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
-import java.util.*;
-
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.common.POIFSConstants;
 
 /**
@@ -31,26 +33,34 @@
  *
  * @author  Marc Johnson (mjohnson at apache dot org)
  */
+public final class SmallDocumentBlock implements BlockWritable, ListManagedBlock {
+    private static final int BLOCK_SHIFT = 6;
 
-public class SmallDocumentBlock
-    implements BlockWritable, ListManagedBlock
-{
     private byte[]            _data;
     private static final byte _default_fill         = ( byte ) 0xff;
-    private static final int  _block_size           = 64;
-    private static final int  _blocks_per_big_block =
-        POIFSConstants.BIG_BLOCK_SIZE / _block_size;
+    private static final int  _block_size           = 1 << BLOCK_SHIFT;
+    private static final int BLOCK_MASK = _block_size-1;
 
-    private SmallDocumentBlock(final byte [] data, final int index)
+    private final int  _blocks_per_big_block;
+    private final POIFSBigBlockSize _bigBlockSize;
+
+    private SmallDocumentBlock(final POIFSBigBlockSize bigBlockSize, final byte [] data, final int index)
     {
-        this();
+        this(bigBlockSize);
         System.arraycopy(data, index * _block_size, _data, 0, _block_size);
     }
 
-    private SmallDocumentBlock()
+    private SmallDocumentBlock(final POIFSBigBlockSize bigBlockSize)
     {
+        _bigBlockSize = bigBlockSize;
+        _blocks_per_big_block = getBlocksPerBigBlock(bigBlockSize);
         _data = new byte[ _block_size ];
     }
+    
+    private static int getBlocksPerBigBlock(final POIFSBigBlockSize bigBlockSize)
+    {
+       return bigBlockSize.getBigBlockSize() / _block_size;
+    }
 
     /**
      * convert a single long array into an array of SmallDocumentBlock
@@ -62,9 +72,9 @@
      * @return an array of SmallDocumentBlock instances, filled from
      *         the array
      */
-
-    public static SmallDocumentBlock [] convert(final byte [] array,
-                                                final int size)
+    public static SmallDocumentBlock [] convert(POIFSBigBlockSize bigBlockSize,
+                                                byte [] array,
+                                                int size)
     {
         SmallDocumentBlock[] rval   =
             new SmallDocumentBlock[ (size + _block_size - 1) / _block_size ];
@@ -72,7 +82,7 @@
 
         for (int k = 0; k < rval.length; k++)
         {
-            rval[ k ] = new SmallDocumentBlock();
+            rval[ k ] = new SmallDocumentBlock(bigBlockSize);
             if (offset < array.length)
             {
                 int length = Math.min(_block_size, array.length - offset);
@@ -101,9 +111,10 @@
      *
      * @return number of big blocks the list encompasses
      */
-
-    public static int fill(final List blocks)
+    public static int fill(POIFSBigBlockSize bigBlockSize, List blocks)
     {
+        int _blocks_per_big_block = getBlocksPerBigBlock(bigBlockSize);
+        
         int count           = blocks.size();
         int big_block_count = (count + _blocks_per_big_block - 1)
                               / _blocks_per_big_block;
@@ -111,7 +122,7 @@
 
         for (; count < full_count; count++)
         {
-            blocks.add(makeEmptySmallDocumentBlock());
+            blocks.add(makeEmptySmallDocumentBlock(bigBlockSize));
         }
         return big_block_count;
     }
@@ -128,9 +139,9 @@
      * @exception ArrayIndexOutOfBoundsException if, somehow, the store
      *            contains less data than size indicates
      */
-
-    public static SmallDocumentBlock [] convert(final BlockWritable [] store,
-                                                final int size)
+    public static SmallDocumentBlock [] convert(POIFSBigBlockSize bigBlockSize,
+                                                BlockWritable [] store,
+                                                int size)
         throws IOException, ArrayIndexOutOfBoundsException
     {
         ByteArrayOutputStream stream = new ByteArrayOutputStream();
@@ -145,7 +156,7 @@
 
         for (int index = 0; index < rval.length; index++)
         {
-            rval[ index ] = new SmallDocumentBlock(data, index);
+            rval[ index ] = new SmallDocumentBlock(bigBlockSize, data, index);
         }
         return rval;
     }
@@ -157,13 +168,12 @@
      *               data
      *
      * @return a List of SmallDocumentBlock's extracted from the input
-     *
-     * @exception IOException
      */
-
-    public static List extract(ListManagedBlock [] blocks)
+    public static List extract(POIFSBigBlockSize bigBlockSize, ListManagedBlock [] blocks)
         throws IOException
     {
+        int _blocks_per_big_block = getBlocksPerBigBlock(bigBlockSize);
+        
         List sdbs = new ArrayList();
 
         for (int j = 0; j < blocks.length; j++)
@@ -172,52 +182,16 @@
 
             for (int k = 0; k < _blocks_per_big_block; k++)
             {
-                sdbs.add(new SmallDocumentBlock(data, k));
+                sdbs.add(new SmallDocumentBlock(bigBlockSize, data, k));
             }
         }
         return sdbs;
     }
 
-    /**
-     * read data from an array of SmallDocumentBlocks
-     *
-     * @param blocks the blocks to read from
-     * @param buffer the buffer to write the data into
-     * @param offset the offset into the array of blocks to read from
-     */
-
-    public static void read(final BlockWritable [] blocks,
-                            final byte [] buffer, final int offset)
-    {
-        int firstBlockIndex  = offset / _block_size;
-        int firstBlockOffset = offset % _block_size;
-        int lastBlockIndex   = (offset + buffer.length - 1) / _block_size;
-
-        if (firstBlockIndex == lastBlockIndex)
-        {
-            System.arraycopy(
-                (( SmallDocumentBlock ) blocks[ firstBlockIndex ])._data,
-                firstBlockOffset, buffer, 0, buffer.length);
-        }
-        else
-        {
-            int buffer_offset = 0;
-
-            System.arraycopy(
-                (( SmallDocumentBlock ) blocks[ firstBlockIndex ])._data,
-                firstBlockOffset, buffer, buffer_offset,
-                _block_size - firstBlockOffset);
-            buffer_offset += _block_size - firstBlockOffset;
-            for (int j = firstBlockIndex + 1; j < lastBlockIndex; j++)
-            {
-                System.arraycopy((( SmallDocumentBlock ) blocks[ j ])._data,
-                                 0, buffer, buffer_offset, _block_size);
-                buffer_offset += _block_size;
-            }
-            System.arraycopy(
-                (( SmallDocumentBlock ) blocks[ lastBlockIndex ])._data, 0,
-                buffer, buffer_offset, buffer.length - buffer_offset);
-        }
+    public static DataInputBlock getDataInputBlock(SmallDocumentBlock[] blocks, int offset) {
+        int firstBlockIndex = offset >> BLOCK_SHIFT;
+        int firstBlockOffset= offset & BLOCK_MASK;
+        return new DataInputBlock(blocks[firstBlockIndex]._data, firstBlockOffset);
     }
 
     /**
@@ -227,27 +201,24 @@
      *
      * @return total size
      */
-
     public static int calcSize(int size)
     {
         return size * _block_size;
     }
 
-    private static SmallDocumentBlock makeEmptySmallDocumentBlock()
+    private static SmallDocumentBlock makeEmptySmallDocumentBlock(POIFSBigBlockSize bigBlockSize)
     {
-        SmallDocumentBlock block = new SmallDocumentBlock();
+        SmallDocumentBlock block = new SmallDocumentBlock(bigBlockSize);
 
         Arrays.fill(block._data, _default_fill);
         return block;
     }
 
-    private static int convertToBlockCount(final int size)
+    private static int convertToBlockCount(int size)
     {
         return (size + _block_size - 1) / _block_size;
     }
 
-    /* ********** START implementation of BlockWritable ********** */
-
     /**
      * Write the storage to an OutputStream
      *
@@ -257,16 +228,12 @@
      * @exception IOException on problems writing to the specified
      *            stream
      */
-
-    public void writeBlocks(final OutputStream stream)
+    public void writeBlocks(OutputStream stream)
         throws IOException
     {
         stream.write(_data);
     }
 
-    /* **********  END  implementation of BlockWritable ********** */
-    /* ********** START implementation of ListManagedBlock ********** */
-
     /**
      * Get the data from the block
      *
@@ -274,13 +241,11 @@
      *
      * @exception IOException if there is no data
      */
-
-    public byte [] getData()
-        throws IOException
-    {
+    public byte [] getData() {
         return _data;
     }
-
-    /* **********  END  implementation of ListManagedBlock ********** */
-}   // end public class SmallDocumentBlock
-
+    
+    public POIFSBigBlockSize getBigBlockSize() {
+       return _bigBlockSize;
+    }
+}
diff --git a/src/java/org/apache/poi/poifs/storage/SmallDocumentBlockList.java b/src/java/org/apache/poi/poifs/storage/SmallDocumentBlockList.java
index b83ac22..a510f8e 100644
--- a/src/java/org/apache/poi/poifs/storage/SmallDocumentBlockList.java
+++ b/src/java/org/apache/poi/poifs/storage/SmallDocumentBlockList.java
@@ -40,7 +40,7 @@
     public SmallDocumentBlockList(final List blocks)
     {
         setBlocks(( SmallDocumentBlock [] ) blocks
-            .toArray(new SmallDocumentBlock[ 0 ]));
+            .toArray(new SmallDocumentBlock[ blocks.size() ]));
     }
 }   // end public class SmallDocumentBlockList
 
diff --git a/src/java/org/apache/poi/util/ArrayUtil.java b/src/java/org/apache/poi/util/ArrayUtil.java
index a4000d2..be2b499 100644
--- a/src/java/org/apache/poi/util/ArrayUtil.java
+++ b/src/java/org/apache/poi/util/ArrayUtil.java
@@ -21,7 +21,6 @@
  * Utility classes for dealing with arrays.
  *
  * @author Glen Stampoultzis
- * @version $Id$
  */
 public class ArrayUtil
 {
diff --git a/src/java/org/apache/poi/util/BinaryTree.java b/src/java/org/apache/poi/util/BinaryTree.java
index 58d7820..551d588 100644
--- a/src/java/org/apache/poi/util/BinaryTree.java
+++ b/src/java/org/apache/poi/util/BinaryTree.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +14,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
@@ -89,34 +87,20 @@
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-public final class BinaryTree   // final for performance
-
-    extends AbstractMap
-{
-    private Node[]                _root             = new Node[]
-    {
-        null, null
-    };
-    private int                   _size             = 0;
-    private int                   _modifications    = 0;
-    private Set[]                 _key_set          = new Set[]
-    {
-        null, null
-    };
-    private Set[]                 _entry_set        = new Set[]
-    {
-        null, null
-    };
-    private Collection[]          _value_collection = new Collection[]
-    {
-        null, null
-    };
-    private static final int      _KEY              = 0;
-    private static final int      _VALUE            = 1;
-    private static final int      _INDEX_SUM        = _KEY + _VALUE;
-    private static final int      _MINIMUM_INDEX    = 0;
-    private static final int      _INDEX_COUNT      = 2;
-    private static final String[] _data_name        = new String[]
+//for performance
+public class BinaryTree extends AbstractMap {
+    final Node[] _root;
+    int _size = 0;
+    int _modifications = 0;
+    private final Set[] _key_set = new Set[] { null, null };
+    private final Set[] _entry_set = new Set[] { null, null };
+    private final Collection[] _value_collection = new Collection[] { null, null };
+    static int      _KEY              = 0;
+    static int      _VALUE            = 1;
+    private static int      _INDEX_SUM        = _KEY + _VALUE;
+    private static int      _MINIMUM_INDEX    = 0;
+    private static int      _INDEX_COUNT      = 2;
+    private static String[] _data_name        = new String[]
     {
         "key", "value"
     };
@@ -124,9 +108,8 @@
     /**
      * Construct a new BinaryTree
      */
-
-    public BinaryTree()
-    {
+    public BinaryTree() {
+        _root = new Node[]{ null, null, };
     }
 
     /**
@@ -146,11 +129,11 @@
      *                                     or duplicate values in the
      *                                     map
      */
-
-    public BinaryTree(final Map map)
+    public BinaryTree(Map map)
         throws ClassCastException, NullPointerException,
                 IllegalArgumentException
     {
+    	this();
         putAll(map);
     }
 
@@ -167,8 +150,7 @@
      *                               inappropriate type for this map.
      * @exception NullPointerException if the value is null
      */
-
-    public Object getKeyForValue(final Object value)
+    public Object getKeyForValue(Object value)
         throws ClassCastException, NullPointerException
     {
         return doGet(( Comparable ) value, _VALUE);
@@ -182,8 +164,7 @@
      * @return previous key associated with specified value, or null
      *         if there was no mapping for value.
      */
-
-    public Object removeValue(final Object value)
+    public Object removeValue(Object value)
     {
         return doRemove(( Comparable ) value, _VALUE);
     }
@@ -207,7 +188,6 @@
      *
      * @return a set view of the mappings contained in this map.
      */
-
     public Set entrySetByValue()
     {
         if (_entry_set[ _VALUE ] == null)
@@ -423,8 +403,7 @@
      *         key. null if the specified key or value could not be
      *         found
      */
-
-    private Object doRemove(final Comparable o, final int index)
+    private Object doRemove(Comparable o, int index)
     {
         Node   node = lookup(o, index);
         Object rval = null;
@@ -447,8 +426,7 @@
      *         key was mapped); null if we couldn't find the specified
      *         object
      */
-
-    private Object doGet(final Comparable o, final int index)
+    private Object doGet(Comparable o, int index)
     {
         checkNonNullComparable(o, index);
         Node node = lookup(o, index);
@@ -464,8 +442,7 @@
      *
      * @return _VALUE (if _KEY was specified), else _KEY
      */
-
-    private int oppositeIndex(final int index)
+    private int oppositeIndex(int index)
     {
 
         // old trick ... to find the opposite of a value, m or n,
@@ -483,8 +460,7 @@
      * @return the desired Node, or null if there is no mapping of the
      *         specified data
      */
-
-    private Node lookup(final Comparable data, final int index)
+    public Node lookup(Comparable data, int index)
     {
         Node rval = null;
         Node node = _root[ index ];
@@ -498,11 +474,8 @@
                 rval = node;
                 break;
             }
-            else
-            {
-                node = (cmp < 0) ? node.getLeft(index)
-                                 : node.getRight(index);
-            }
+            node = (cmp < 0) ? node.getLeft(index)
+                             : node.getRight(index);
         }
         return rval;
     }
@@ -516,10 +489,9 @@
      * @return negative value if o1 < o2; 0 if o1 == o2; positive
      *         value if o1 > o2
      */
-
-    private static int compare(final Comparable o1, final Comparable o2)
+    private static int compare(Comparable o1, Comparable o2)
     {
-        return (( Comparable ) o1).compareTo(o2);
+        return o1.compareTo(o2);
     }
 
     /**
@@ -532,8 +504,7 @@
      * @return the smallest node, from the specified node, in the
      *         specified mapping
      */
-
-    private static Node leastNode(final Node node, final int index)
+    static Node leastNode(Node node, int index)
     {
         Node rval = node;
 
@@ -555,8 +526,7 @@
      *
      * @return the specified node
      */
-
-    private Node nextGreater(final Node node, final int index)
+    static Node nextGreater(Node node, int index)
     {
         Node rval = null;
 
@@ -601,9 +571,7 @@
      * @param to the node whose color we're changing; may be null
      * @param index _KEY or _VALUE
      */
-
-    private static void copyColor(final Node from, final Node to,
-                                  final int index)
+    private static void copyColor(Node from, Node to, int index)
     {
         if (to != null)
         {
@@ -627,11 +595,9 @@
      * @param node the node (may be null) in question
      * @param index _KEY or _VALUE
      */
-
-    private static boolean isRed(final Node node, final int index)
+    private static boolean isRed(Node node, int index)
     {
-        return ((node == null) ? false
-                               : node.isRed(index));
+        return node == null ? false : node.isRed(index);
     }
 
     /**
@@ -641,11 +607,9 @@
      * @param node the node (may be null) in question
      * @param index _KEY or _VALUE
      */
-
-    private static boolean isBlack(final Node node, final int index)
+    private static boolean isBlack(Node node, int index)
     {
-        return ((node == null) ? true
-                               : node.isBlack(index));
+        return node == null ? true : node.isBlack(index);
     }
 
     /**
@@ -654,8 +618,7 @@
      * @param node the node (may be null) in question
      * @param index _KEY or _VALUE
      */
-
-    private static void makeRed(final Node node, final int index)
+    private static void makeRed(Node node, int index)
     {
         if (node != null)
         {
@@ -669,8 +632,7 @@
      * @param node the node (may be null) in question
      * @param index _KEY or _VALUE
      */
-
-    private static void makeBlack(final Node node, final int index)
+    private static void makeBlack(Node node, int index)
     {
         if (node != null)
         {
@@ -685,8 +647,7 @@
      * @param node the node (may be null) in question
      * @param index _KEY or _VALUE
      */
-
-    private static Node getGrandParent(final Node node, final int index)
+    private static Node getGrandParent(Node node, int index)
     {
         return getParent(getParent(node, index), index);
     }
@@ -698,8 +659,7 @@
      * @param node the node (may be null) in question
      * @param index _KEY or _VALUE
      */
-
-    private static Node getParent(final Node node, final int index)
+    private static Node getParent(Node node, int index)
     {
         return ((node == null) ? null
                                : node.getParent(index));
@@ -712,8 +672,7 @@
      * @param node the node (may be null) in question
      * @param index _KEY or _VALUE
      */
-
-    private static Node getRightChild(final Node node, final int index)
+    private static Node getRightChild(Node node, int index)
     {
         return (node == null) ? null
                               : node.getRight(index);
@@ -726,8 +685,7 @@
      * @param node the node (may be null) in question
      * @param index _KEY or _VALUE
      */
-
-    private static Node getLeftChild(final Node node, final int index)
+    private static Node getLeftChild(Node node, int index)
     {
         return (node == null) ? null
                               : node.getLeft(index);
@@ -744,15 +702,14 @@
      * @param node the node (may be null) in question
      * @param index _KEY or _VALUE
      */
-
-    private static boolean isLeftChild(final Node node, final int index)
-    {
-        return (node == null) ? true
-                              : ((node.getParent(index) == null) ? false
-                                                                 : (node
-                                                                    == node.getParent(
-                                                                        index).getLeft(
-                                                                        index)));
+    private static boolean isLeftChild(Node node, int index) {
+        if (node == null) {
+            return true;
+        }
+        if (node.getParent(index) == null) {
+            return false;
+        }
+        return node == node.getParent(index).getLeft(index);
     }
 
     /**
@@ -766,15 +723,15 @@
      * @param node the node (may be null) in question
      * @param index _KEY or _VALUE
      */
-
-    private static boolean isRightChild(final Node node, final int index)
+    private static boolean isRightChild(Node node, int index)
     {
-        return (node == null) ? true
-                              : ((node.getParent(index) == null) ? false
-                                                                 : (node
-                                                                    == node.getParent(
-                                                                        index).getRight(
-                                                                        index)));
+        if (node == null) {
+            return true;
+        }
+        if (node.getParent(index) == null) {
+            return false;
+        }
+        return node == node.getParent(index).getRight(index);
     }
 
     /**
@@ -783,8 +740,7 @@
      * @param node the node to be rotated
      * @param index _KEY or _VALUE
      */
-
-    private void rotateLeft(final Node node, final int index)
+    private void rotateLeft(Node node, int index)
     {
         Node right_child = node.getRight(index);
 
@@ -818,8 +774,7 @@
      * @param node the node to be rotated
      * @param index _KEY or _VALUE
      */
-
-    private void rotateRight(final Node node, final int index)
+    private void rotateRight(Node node, int index)
     {
         Node left_child = node.getLeft(index);
 
@@ -854,8 +809,7 @@
      * @param inserted_node the node to be inserted
      * @param index _KEY or _VALUE
      */
-
-    private void doRedBlackInsert(final Node inserted_node, final int index)
+    private void doRedBlackInsert(Node inserted_node, int index)
     {
         Node current_node = inserted_node;
 
@@ -931,8 +885,7 @@
      *
      * @param deleted_node the node to be deleted
      */
-
-    private void doRedBlackDelete(final Node deleted_node)
+    void doRedBlackDelete(Node deleted_node)
     {
         for (int index = _MINIMUM_INDEX; index < _INDEX_COUNT; index++)
         {
@@ -1023,9 +976,8 @@
      * @param replacement_node  the node being replaced
      * @param index _KEY or _VALUE
      */
-
-    private void doRedBlackDeleteFixup(final Node replacement_node,
-                                       final int index)
+    private void doRedBlackDeleteFixup(Node replacement_node,
+                                       int index)
     {
         Node current_node = replacement_node;
 
@@ -1121,8 +1073,7 @@
      * @param y another node
      * @param index _KEY or _VALUE
      */
-
-    private void swapPosition(final Node x, final Node y, final int index)
+    private void swapPosition(Node x, Node y, int index)
     {
 
         // Save initial values.
@@ -1244,9 +1195,8 @@
      * @exception NullPointerException if o is null
      * @exception ClassCastException if o is not Comparable
      */
-
-    private static void checkNonNullComparable(final Object o,
-                                               final int index)
+    private static void checkNonNullComparable(Object o,
+                                               int index)
     {
         if (o == null)
         {
@@ -1268,8 +1218,7 @@
      * @exception NullPointerException if key is null
      * @exception ClassCastException if key is not Comparable
      */
-
-    private static void checkKey(final Object key)
+    private static void checkKey(Object key)
     {
         checkNonNullComparable(key, _KEY);
     }
@@ -1282,8 +1231,7 @@
      * @exception NullPointerException if value is null
      * @exception ClassCastException if value is not Comparable
      */
-
-    private static void checkValue(final Object value)
+    private static void checkValue(Object value)
     {
         checkNonNullComparable(value, _VALUE);
     }
@@ -1298,8 +1246,7 @@
      * @exception NullPointerException if key or value is null
      * @exception ClassCastException if key or value is not Comparable
      */
-
-    private static void checkKeyAndValue(final Object key, final Object value)
+    private static void checkKeyAndValue(Object key, Object value)
     {
         checkKey(key);
         checkValue(value);
@@ -1310,7 +1257,6 @@
      * concurrent modification of the map through the map and through
      * an Iterator from one of its Set or Collection views
      */
-
     private void modify()
     {
         _modifications++;
@@ -1319,7 +1265,6 @@
     /**
      * bump up the size and note that the map has changed
      */
-
     private void grow()
     {
         modify();
@@ -1329,7 +1274,6 @@
     /**
      * decrement the size and note that the map has changed
      */
-
     private void shrink()
     {
         modify();
@@ -1344,8 +1288,7 @@
      * @exception IllegalArgumentException if the node already exists
      *                                     in the value mapping
      */
-
-    private void insertValue(final Node newNode)
+    private void insertValue(Node newNode)
         throws IllegalArgumentException
     {
         Node node = _root[ _VALUE ];
@@ -1400,7 +1343,6 @@
      *
      * @return the number of key-value mappings in this map.
      */
-
     public int size()
     {
         return _size;
@@ -1419,8 +1361,7 @@
      *                               type for this map.
      * @exception NullPointerException if the key is null
      */
-
-    public boolean containsKey(final Object key)
+    public boolean containsKey(Object key)
         throws ClassCastException, NullPointerException
     {
         checkKey(key);
@@ -1436,8 +1377,7 @@
      * @return true if this map maps one or more keys to the specified
      *         value.
      */
-
-    public boolean containsValue(final Object value)
+    public boolean containsValue(Object value)
     {
         checkValue(value);
         return lookup(( Comparable ) value, _VALUE) != null;
@@ -1456,8 +1396,7 @@
      *                               type for this map.
      * @exception NullPointerException if the key is null
      */
-
-    public Object get(final Object key)
+    public Object get(Object key)
         throws ClassCastException, NullPointerException
     {
         return doGet(( Comparable ) key, _KEY);
@@ -1483,8 +1422,7 @@
      *                                     value duplicates an
      *                                     existing value
      */
-
-    public Object put(final Object key, final Object value)
+    public Object put(Object key, Object value)
         throws ClassCastException, NullPointerException,
                 IllegalArgumentException
     {
@@ -1562,8 +1500,7 @@
      * @return previous value associated with specified key, or null
      *         if there was no mapping for key.
      */
-
-    public Object remove(final Object key)
+    public Object remove(Object key)
     {
         return doRemove(( Comparable ) key, _KEY);
     }
@@ -1571,7 +1508,6 @@
     /**
      * Removes all mappings from this map
      */
-
     public void clear()
     {
         modify();
@@ -1592,7 +1528,6 @@
      *
      * @return a set view of the keys contained in this map.
      */
-
     public Set keySet()
     {
         if (_key_set[ _KEY ] == null)
@@ -1650,7 +1585,6 @@
      *
      * @return a collection view of the values contained in this map.
      */
-
     public Collection values()
     {
         if (_value_collection[ _KEY ] == null)
@@ -1723,7 +1657,6 @@
      *
      * @return a set view of the mappings contained in this map.
      */
-
     public Set entrySet()
     {
         if (_entry_set[ _KEY ] == null)
@@ -1803,8 +1736,7 @@
          *
          * @param type
          */
-
-        BinaryTreeIterator(final int type)
+        BinaryTreeIterator(int type)
         {
             _type                   = type;
             _expected_modifications = BinaryTree.this._modifications;
@@ -1825,7 +1757,7 @@
          * @return true if the iterator has more elements.
          */
 
-        public final boolean hasNext()
+        public boolean hasNext()
         {
             return _next_node != null;
         }
@@ -1842,7 +1774,7 @@
          *                                            back
          */
 
-        public final Object next()
+        public Object next()
             throws NoSuchElementException, ConcurrentModificationException
         {
             if (_next_node == null)
@@ -1878,7 +1810,7 @@
          *                                            back
          */
 
-        public final void remove()
+        public void remove()
             throws IllegalStateException, ConcurrentModificationException
         {
             if (_last_returned_node == null)
@@ -1897,7 +1829,7 @@
         /* **********  END  implementation of Iterator ********** */
     }   // end private abstract class BinaryTreeIterator
 
-    // final for performance
+    // for performance
     private static final class Node
         implements Map.Entry
     {
@@ -1917,7 +1849,7 @@
          * @param value
          */
 
-        Node(final Comparable key, final Comparable value)
+        Node(Comparable key, Comparable value)
         {
             _data                = new Comparable[]
             {
@@ -1949,8 +1881,7 @@
          *
          * @return the key or value
          */
-
-        private Comparable getData(final int index)
+        public Comparable getData(int index)
         {
             return _data[ index ];
         }
@@ -1961,8 +1892,7 @@
          * @param node the new left node
          * @param index _KEY or _VALUE
          */
-
-        private void setLeft(final Node node, final int index)
+        public void setLeft(Node node, int index)
         {
             _left[ index ] = node;
         }
@@ -1975,7 +1905,7 @@
          * @return the left node -- may be null
          */
 
-        private Node getLeft(final int index)
+        public Node getLeft(int index)
         {
             return _left[ index ];
         }
@@ -1986,8 +1916,7 @@
          * @param node the new right node
          * @param index _KEY or _VALUE
          */
-
-        private void setRight(final Node node, final int index)
+        public void setRight(Node node, int index)
         {
             _right[ index ] = node;
         }
@@ -2000,7 +1929,7 @@
          * @return the right node -- may be null
          */
 
-        private Node getRight(final int index)
+        public Node getRight(int index)
         {
             return _right[ index ];
         }
@@ -2011,8 +1940,7 @@
          * @param node the new parent node
          * @param index _KEY or _VALUE
          */
-
-        private void setParent(final Node node, final int index)
+        public void setParent(Node node, int index)
         {
             _parent[ index ] = node;
         }
@@ -2024,8 +1952,7 @@
          *
          * @return the parent node -- may be null
          */
-
-        private Node getParent(final int index)
+        public Node getParent(int index)
         {
             return _parent[ index ];
         }
@@ -2036,8 +1963,7 @@
          * @param node the node to swap with
          * @param index _KEY or _VALUE
          */
-
-        private void swapColors(final Node node, final int index)
+        public void swapColors(Node node, int index)
         {
 
             // Swap colors -- old hacker's trick
@@ -2053,8 +1979,7 @@
          *
          * @return true if black (which is represented as a true boolean)
          */
-
-        private boolean isBlack(final int index)
+        public boolean isBlack(int index)
         {
             return _black[ index ];
         }
@@ -2066,8 +1991,7 @@
          *
          * @return true if non-black
          */
-
-        private boolean isRed(final int index)
+        public boolean isRed(int index)
         {
             return !_black[ index ];
         }
@@ -2077,8 +2001,7 @@
          *
          * @param index _KEY or _VALUE
          */
-
-        private void setBlack(final int index)
+        public void setBlack(int index)
         {
             _black[ index ] = true;
         }
@@ -2088,8 +2011,7 @@
          *
          * @param index _KEY or _VALUE
          */
-
-        private void setRed(final int index)
+        public void setRed(int index)
         {
             _black[ index ] = false;
         }
@@ -2100,8 +2022,7 @@
          * @param node the node whose color we're adopting
          * @param index _KEY or _VALUE
          */
-
-        private void copyColor(final Node node, final int index)
+        public void copyColor(Node node, int index)
         {
             _black[ index ] = node._black[ index ];
         }
@@ -2111,7 +2032,6 @@
         /**
          * @return the key corresponding to this entry.
          */
-
         public Object getKey()
         {
             return _data[ _KEY ];
@@ -2120,7 +2040,6 @@
         /**
          * @return the value corresponding to this entry.
          */
-
         public Object getValue()
         {
             return _data[ _VALUE ];
@@ -2133,10 +2052,7 @@
          * @param ignored
          *
          * @return does not return
-         *
-         * @exception UnsupportedOperationException
          */
-
         public Object setValue(Object ignored)
             throws UnsupportedOperationException
         {
@@ -2154,7 +2070,6 @@
          * @return true if the specified object is equal to this map
          *         entry.
          */
-
         public boolean equals(Object o)
         {
             if (this == o)
@@ -2188,5 +2103,4 @@
 
         /* **********  END  implementation of Map.Entry ********** */
     }
-}   // end public class BinaryTree
-
+}
diff --git a/src/java/org/apache/poi/util/BitFieldFactory.java b/src/java/org/apache/poi/util/BitFieldFactory.java
index a0da1fe..d022ee6 100755
--- a/src/java/org/apache/poi/util/BitFieldFactory.java
+++ b/src/java/org/apache/poi/util/BitFieldFactory.java
@@ -15,7 +15,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
@@ -27,18 +26,15 @@
  * @author Jason Height (jheight at apache dot org)
  */
 
-public class BitFieldFactory
-{
+public class BitFieldFactory {
     private static Map instances = new HashMap();
-    
-    public static BitField getInstance(final int mask) {
-      BitField f = (BitField)instances.get(new Integer(mask));
+
+    public static BitField getInstance(int mask) {
+      BitField f = (BitField)instances.get(Integer.valueOf(mask));
       if (f == null) {
         f = new BitField(mask);
-        instances.put(new Integer(mask), f);        
+        instances.put(Integer.valueOf(mask), f);
       }
       return f;
     }
-
-}   // end public class BitFieldFactory
-
+}
diff --git a/src/java/org/apache/poi/util/CloseIgnoringInputStream.java b/src/java/org/apache/poi/util/CloseIgnoringInputStream.java
new file mode 100644
index 0000000..f4896a8
--- /dev/null
+++ b/src/java/org/apache/poi/util/CloseIgnoringInputStream.java
@@ -0,0 +1,41 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.util;
+
+import java.io.FilterInputStream;
+import java.io.InputStream;
+
+import org.apache.poi.poifs.filesystem.POIFSFileSystem;
+
+/**
+ * A wrapper around an {@link InputStream}, which 
+ *  ignores close requests made to it.
+ *
+ * Useful with {@link POIFSFileSystem}, where you want
+ *  to control the close yourself.
+ */
+public class CloseIgnoringInputStream extends FilterInputStream {
+   public CloseIgnoringInputStream(InputStream in) {
+      super(in);
+   }
+
+   public void close() {
+      // Does nothing and ignores you
+      return;
+   }
+}
diff --git a/src/java/org/apache/poi/util/DelayableLittleEndianOutput.java b/src/java/org/apache/poi/util/DelayableLittleEndianOutput.java
new file mode 100644
index 0000000..13282ac
--- /dev/null
+++ b/src/java/org/apache/poi/util/DelayableLittleEndianOutput.java
@@ -0,0 +1,34 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.util;
+/**
+ * Implementors of this interface allow client code to 'delay' writing to a certain section of a
+ * data output stream.<br/>
+ * A typical application is for writing BIFF records when the size is not known until well after
+ * the header has been written.  The client code can call {@link #createDelayedOutput(int)}
+ * to reserve two bytes of the output for the 'ushort size' header field.  The delayed output can
+ * be written at any stage.
+ *
+ * @author Josh Micich
+ */
+public interface DelayableLittleEndianOutput extends LittleEndianOutput {
+	/**
+	 * Creates an output stream intended for outputting a sequence of <tt>size</tt> bytes.
+	 */
+	LittleEndianOutput createDelayedOutput(int size);
+}
diff --git a/src/java/org/apache/poi/util/FontMetricsDumper.java b/src/java/org/apache/poi/util/FontMetricsDumper.java
new file mode 100644
index 0000000..c974c1e
--- /dev/null
+++ b/src/java/org/apache/poi/util/FontMetricsDumper.java
@@ -0,0 +1,84 @@
+
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+        
+package org.apache.poi.util;
+
+import java.awt.*;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Properties;
+
+@SuppressWarnings("deprecation")
+public class FontMetricsDumper
+{
+    public static void main( String[] args ) throws IOException
+    {
+
+        Properties props = new Properties();
+
+        Font[] allFonts = GraphicsEnvironment.getLocalGraphicsEnvironment().getAllFonts();
+        for ( int i = 0; i < allFonts.length; i++ )
+        {
+            String fontName = allFonts[i].getFontName();
+
+            Font font = new Font(fontName, Font.BOLD, 10);
+            FontMetrics fontMetrics = Toolkit.getDefaultToolkit().getFontMetrics(font);
+            int fontHeight = fontMetrics.getHeight();
+
+            props.setProperty("font." + fontName + ".height", fontHeight+"");
+            StringBuffer characters = new StringBuffer();
+            for (char c = 'a'; c <= 'z'; c++)
+            {
+                characters.append( c + ", " );
+            }
+            for (char c = 'A'; c <= 'Z'; c++)
+            {
+                characters.append( c + ", " );
+            }
+            for (char c = '0'; c <= '9'; c++)
+            {
+                characters.append( c + ", " );
+            }
+            StringBuffer widths = new StringBuffer();
+            for (char c = 'a'; c <= 'z'; c++)
+            {
+                widths.append( fontMetrics.getWidths()[c] + ", " );
+            }
+            for (char c = 'A'; c <= 'Z'; c++)
+            {
+                widths.append( fontMetrics.getWidths()[c] + ", " );
+            }
+            for (char c = '0'; c <= '9'; c++)
+            {
+                widths.append( fontMetrics.getWidths()[c] + ", " );
+            }
+            props.setProperty("font." + fontName + ".characters", characters.toString());
+            props.setProperty("font." + fontName + ".widths", widths.toString());
+        }
+
+        FileOutputStream fileOut = new FileOutputStream("font_metrics.properties");
+        try
+        {
+            props.store(fileOut, "Font Metrics");
+        }
+        finally
+        {
+            fileOut.close();
+        }
+    }
+}
diff --git a/src/java/org/apache/poi/util/HexDump.java b/src/java/org/apache/poi/util/HexDump.java
index c5ebab3..66c47f3 100644
--- a/src/java/org/apache/poi/util/HexDump.java
+++ b/src/java/org/apache/poi/util/HexDump.java
@@ -169,7 +169,7 @@
      *            outside the data array's bounds
      * @return output string
      */
-    
+
     public static String dump(final byte [] data, final long offset,
                             final int index) {
         StringBuffer buffer;
@@ -216,10 +216,10 @@
             }
             buffer.append(EOL);
             display_offset += chars_read;
-        }                 
+        }
         return buffer.toString();
     }
-    
+
 
     private static String dump(final long value)
     {
@@ -399,10 +399,10 @@
             while (bytesRemaining-- > 0)
             {
                 int c = in.read();
-                if (c == -1)
+                if (c == -1) {
                     break;
-                else
-                    buf.write(c);
+                }
+                buf.write(c);
             }
         }
 
@@ -417,13 +417,13 @@
         // The return type is char array because most callers will probably append the value to a
         // StringBuffer, or write it to a Stream / Writer so there is no need to create a String;
         char[] result = new char[charPos];
-        
+
         long value = pValue;
         do {
             result[--charPos] = _hexcodes[(int) (value & 0x0F)];
             value >>>= 4;
         } while (charPos > 1);
-    
+
         // Prefix added to avoid ambiguity
         result[0] = '0';
         result[1] = 'x';
@@ -456,7 +456,7 @@
 
     public static void main(String[] args) throws Exception {
         File file = new File(args[0]);
-        InputStream in = new BufferedInputStream(new FileInputStream(file)); 
+        InputStream in = new BufferedInputStream(new FileInputStream(file));
         byte[] b = new byte[(int)file.length()];
         in.read(b);
         System.out.println(HexDump.dump(b, 0, 0));
diff --git a/src/java/org/apache/poi/util/HexRead.java b/src/java/org/apache/poi/util/HexRead.java
index 91632e8..fa7ecb5 100644
--- a/src/java/org/apache/poi/util/HexRead.java
+++ b/src/java/org/apache/poi/util/HexRead.java
@@ -62,7 +62,7 @@
      * @see #readData(String)
      */
     public static byte[] readData(InputStream stream, String section ) throws IOException {
-    	
+
         try
         {
             StringBuffer sectionText = new StringBuffer();
@@ -128,7 +128,7 @@
                     characterCount++;
                     if ( characterCount == 2 )
                     {
-                        bytes.add( new Byte( b ) );
+                        bytes.add( Byte.valueOf( b ) );
                         characterCount = 0;
                         b = (byte) 0;
                     }
@@ -151,7 +151,7 @@
                     characterCount++;
                     if ( characterCount == 2 )
                     {
-                        bytes.add( new Byte( b ) );
+                        bytes.add( Byte.valueOf( b ) );
                         characterCount = 0;
                         b = (byte) 0;
                     }
diff --git a/src/java/org/apache/poi/util/IOUtils.java b/src/java/org/apache/poi/util/IOUtils.java
index c3aa869..c3c8fa1 100644
--- a/src/java/org/apache/poi/util/IOUtils.java
+++ b/src/java/org/apache/poi/util/IOUtils.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,73 +14,119 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.nio.channels.ReadableByteChannel;
 
-public class IOUtils
-{
-    private IOUtils()
-    {
-    }
+public final class IOUtils {
+	private IOUtils() {
+		// no instances of this class
+	}
 
-    /**
-     * Reads all the data from the input stream, and returns
-     *  the bytes read.
-     */
-    public static byte[] toByteArray(InputStream stream) throws IOException {
-    	ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    	
-    	byte[] buffer = new byte[4096];
-    	int read = 0;
-    	while(read != -1) {
-    		read = stream.read(buffer);
-    		if(read > 0) {
-    			baos.write(buffer, 0, read);
-    		}
-    	}
-    	
-    	return baos.toByteArray();
-    }
+	/**
+	 * Reads all the data from the input stream, and returns the bytes read.
+	 */
+	public static byte[] toByteArray(InputStream stream) throws IOException {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
 
-    /**
-     * Helper method, just calls <tt>readFully(in, b, 0, b.length)</tt>
-     */
-    public static int readFully(InputStream in, byte[] b)
-    throws IOException
-    {
-        return readFully(in, b, 0, b.length);
-    }
+		byte[] buffer = new byte[4096];
+		int read = 0;
+		while (read != -1) {
+			read = stream.read(buffer);
+			if (read > 0) {
+				baos.write(buffer, 0, read);
+			}
+		}
 
-    /**
-     * Same as the normal <tt>in.read(b, off, len)</tt>, but
-     *  tries to ensure that the entire len number of bytes
-     *  is read.
-     * <p>
-     * If the end of file is reached before any bytes
-     *  are read, returns -1.
-     * If the end of the file is reached after some bytes are
-     *  read, returns the number of bytes read.
-     * If the end of the file isn't reached before len
-     *  bytes have been read, will return len bytes.
-     */
-    public static int readFully(InputStream in, byte[] b, int off, int len)
-    throws IOException
-    {
-        int total = 0;
-        for (;;) {
-            int got = in.read(b, off + total, len - total);
-            if (got < 0) {
-                return (total == 0) ? -1 : total;
-            } else {
-                total += got;
-                if (total == len)
-                    return total;
-            }
-        }
-    }
-}
\ No newline at end of file
+		return baos.toByteArray();
+	}
+
+   /**
+    * Returns an array (that shouldn't be written to!) of the
+    *  ByteBuffer. Will be of the requested length, or possibly
+    *  longer if that's easier.
+    */
+   public static byte[] toByteArray(ByteBuffer buffer, int length) {
+      if(buffer.hasArray() && buffer.arrayOffset() == 0) {
+         // The backing array should work out fine for us
+         return buffer.array();
+      }
+      
+      byte[] data = new byte[length];
+      buffer.get(data);
+      return data;
+   }
+
+	/**
+	 * Helper method, just calls <tt>readFully(in, b, 0, b.length)</tt>
+	 */
+	public static int readFully(InputStream in, byte[] b) throws IOException {
+		return readFully(in, b, 0, b.length);
+	}
+
+	/**
+	 * Same as the normal <tt>in.read(b, off, len)</tt>, but tries to ensure
+	 * that the entire len number of bytes is read.
+	 * <p>
+	 * If the end of file is reached before any bytes are read, returns -1. If
+	 * the end of the file is reached after some bytes are read, returns the
+	 * number of bytes read. If the end of the file isn't reached before len
+	 * bytes have been read, will return len bytes.
+	 */
+	public static int readFully(InputStream in, byte[] b, int off, int len) throws IOException {
+		int total = 0;
+		while (true) {
+			int got = in.read(b, off + total, len - total);
+			if (got < 0) {
+				return (total == 0) ? -1 : total;
+			}
+			total += got;
+			if (total == len) {
+				return total;
+			}
+		}
+	}
+	
+   /**
+    * Same as the normal <tt>channel.read(b)</tt>, but tries to ensure
+    * that the entire len number of bytes is read.
+    * <p>
+    * If the end of file is reached before any bytes are read, returns -1. If
+    * the end of the file is reached after some bytes are read, returns the
+    * number of bytes read. If the end of the file isn't reached before len
+    * bytes have been read, will return len bytes.
+    */
+	public static int readFully(ReadableByteChannel channel, ByteBuffer b) throws IOException {
+      int total = 0;
+      while (true) {
+         int got = channel.read(b);
+         if (got < 0) {
+            return (total == 0) ? -1 : total;
+         }
+         total += got;
+         if (total == b.capacity()) {
+            return total;
+         }
+      }
+	}
+	
+	/**
+	 * Copies all the data from the given InputStream to the OutputStream. It
+	 * leaves both streams open, so you will still need to close them once done.
+	 */
+	public static void copy(InputStream inp, OutputStream out) throws IOException {
+		byte[] buff = new byte[4096];
+		int count;
+		while ((count = inp.read(buff)) != -1) {
+			if (count > 0) {
+				out.write(buff, 0, count);
+			}
+		}
+	}
+}
diff --git a/src/java/org/apache/poi/util/IntList.java b/src/java/org/apache/poi/util/IntList.java
index 30498cf..08f0240 100644
--- a/src/java/org/apache/poi/util/IntList.java
+++ b/src/java/org/apache/poi/util/IntList.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,12 +14,9 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
-import java.util.*;
-
 /**
  * A List of int's; as full an implementation of the java.util.List
  * interface as possible, with an eye toward minimal creation of
@@ -47,7 +43,6 @@
  *
  * @author Marc Johnson
  */
-
 public class IntList
 {
     private int[]            _array;
@@ -62,14 +57,14 @@
     public IntList()
     {
         this(_default_size);
-    }    
+    }
 
     public IntList(final int initialCapacity)
     {
         this(initialCapacity,0);
     }
-    
-    
+
+
     /**
      * create a copy of an existing IntList
      *
@@ -94,17 +89,17 @@
         _array = new int[ initialCapacity ];
         if (fillval != 0) {
             fillval = fillvalue;
-            fillArray(fillval, _array, 0);        
+            fillArray(fillval, _array, 0);
         }
         _limit = 0;
     }
 
     private void fillArray(int val, int[] array, int index) {
       for (int k = index; k < array.length; k++) {
-        array[k] = val;   
+        array[k] = val;
       }
     }
-    
+
     /**
      * add the specfied value at the specified index
      *
@@ -348,7 +343,9 @@
     {
         if (index >= _limit)
         {
-            throw new IndexOutOfBoundsException();
+            throw new IndexOutOfBoundsException(
+                  index + " not accessible in a list of length " + _limit
+            );
         }
         return _array[ index ];
     }
@@ -653,11 +650,11 @@
         int   size      = (new_size == _array.length) ? new_size + 1
                                                       : new_size;
         int[] new_array = new int[ size ];
-        
+
         if (fillval != 0) {
-          fillArray(fillval, new_array, _array.length);                
+          fillArray(fillval, new_array, _array.length);
         }
-        
+
         System.arraycopy(_array, 0, new_array, 0, _limit);
         _array = new_array;
     }
diff --git a/src/java/org/apache/poi/util/IntMapper.java b/src/java/org/apache/poi/util/IntMapper.java
index 89ae28c..d5cdc7b 100755
--- a/src/java/org/apache/poi/util/IntMapper.java
+++ b/src/java/org/apache/poi/util/IntMapper.java
@@ -34,10 +34,10 @@
  * @author Jason Height
  */
 
-public class IntMapper
+public class IntMapper<T>
 {
-  private List elements;
-  private Map valueKeyMap;
+  private List<T> elements;
+  private Map<T,Integer> valueKeyMap;
 
   private static final int _default_size = 10;
 
@@ -52,8 +52,8 @@
 
     public IntMapper(final int initialCapacity)
     {
-        elements = new ArrayList(initialCapacity);
-        valueKeyMap = new HashMap(initialCapacity);
+        elements = new ArrayList<T>(initialCapacity);
+        valueKeyMap = new HashMap<T,Integer>(initialCapacity);
     }
 
     /**
@@ -64,12 +64,11 @@
      * @return true (as per the general contract of the Collection.add
      *         method).
      */
-
-    public boolean add(final Object value)
+    public boolean add(final T value)
     {
       int index = elements.size();
       elements.add(value);
-      valueKeyMap.put(value, new Integer(index));
+      valueKeyMap.put(value, index);
       return true;
     }
 
@@ -77,18 +76,18 @@
       return elements.size();
     }
 
-    public Object get(int index) {
+    public T get(int index) {
       return elements.get(index);
     }
 
-    public int getIndex(Object o) {
-      Integer i = ((Integer)valueKeyMap.get(o));
+    public int getIndex(T o) {
+      Integer i = valueKeyMap.get(o);
       if (i == null)
         return -1;
       return i.intValue();
     }
 
-    public Iterator iterator() {
+    public Iterator<T> iterator() {
       return elements.iterator();
     }
 }   // end public class IntMapper
diff --git a/src/java/org/apache/poi/util/Internal.java b/src/java/org/apache/poi/util/Internal.java
new file mode 100644
index 0000000..2177e09
--- /dev/null
+++ b/src/java/org/apache/poi/util/Internal.java
@@ -0,0 +1,38 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.util;
+
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Documented;
+
+
+/**
+ * Program elements annotated &#64;Internal are intended for
+ * POI internal use only. Such elements are not public by design
+ * and likely to be removed in future versions of POI  or access
+ * to such elements will be changed from 'public' to 'default' or less.
+ *
+ * @author Yegor Kozlov
+ * @since POI-3.6
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Internal {
+    String value() default "";    
+}
diff --git a/src/java/org/apache/poi/util/LZWDecompresser.java b/src/java/org/apache/poi/util/LZWDecompresser.java
new file mode 100644
index 0000000..f172a01
--- /dev/null
+++ b/src/java/org/apache/poi/util/LZWDecompresser.java
@@ -0,0 +1,178 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+package org.apache.poi.util;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * This class provides common functionality for the
+ *  various LZW implementations in the different file
+ *  formats.
+ * It's currently used by HDGF and HMEF.
+ *
+ * Two good resources on LZW are:
+ *  http://en.wikipedia.org/wiki/LZW
+ *  http://marknelson.us/1989/10/01/lzw-data-compression/
+ */
+public abstract class LZWDecompresser {
+   /**
+    * Does the mask bit mean it's compressed or uncompressed?
+    */
+   private boolean maskMeansCompressed;
+   
+   protected LZWDecompresser(boolean maskMeansCompressed) {
+      this.maskMeansCompressed = maskMeansCompressed;
+   }
+   
+   /**
+    * Populates the dictionary. May not need
+    *  to do anything if all zeros is fine.
+    */
+   protected abstract void populateDictionary(byte[] dict);
+   
+   /**
+    * Adjusts the position offset if needed when looking
+    *  something up in the dictionary.
+    */
+   protected abstract int adjustDictionaryOffset(int offset); 
+   
+   /**
+    * Decompresses the given input stream, returning the array of bytes
+    *  of the decompressed input.
+    */
+   public byte[] decompress(InputStream src) throws IOException {
+      ByteArrayOutputStream res = new ByteArrayOutputStream();
+      decompress(src,res);
+      return res.toByteArray();
+   }
+   
+   /**
+    * Perform a streaming decompression of the input.
+    * Works by:
+    * 1) Reading a flag byte, the 8 bits of which tell you if the
+    *     following 8 codes are compressed our un-compressed
+    * 2) Consider the 8 bits in turn
+    * 3) If the bit is set, the next code is un-compressed, so
+    *     add it to the dictionary and output it
+    * 4) If the bit isn't set, then read in the length and start
+    *     position in the dictionary, and output the bytes there
+    * 5) Loop until we've done all 8 bits, then read in the next
+    *     flag byte
+    */
+   public void decompress(InputStream src, OutputStream res) throws IOException {
+      // We use 12 bit codes:
+      // * 0-255 are real bytes
+      // * 256-4095 are the substring codes
+      // Java handily initialises our buffer / dictionary
+      //  to all zeros
+      byte[] buffer = new byte[4096];
+      populateDictionary(buffer);
+
+      // How far through the output we've got
+      // (This is normally used &4095, so it nicely wraps)
+      int pos = 0;
+      // The flag byte is treated as its 8 individual
+      //  bits, which tell us if the following 8 codes
+      //  are compressed or un-compressed
+      int flag;
+      // The mask, between 1 and 255, which is used when
+      //  processing each bit of the flag byte in turn
+      int mask;
+
+      // These are bytes as looked up in the dictionary
+      // It needs to be signed, as it'll get passed on to
+      //  the output stream
+      byte[] dataB = new byte[19];
+      // This is an unsigned byte read from the stream
+      // It needs to be unsigned, so that bit stuff works
+      int dataI;
+      // The compressed code sequence is held over 2 bytes
+      int dataIPt1, dataIPt2;
+      // How long a code sequence is, and where in the
+      //  dictionary to start at
+      int len, pntr;
+
+      while( (flag = src.read()) != -1 ) {
+         // Compare each bit in our flag byte in turn:
+         for(mask = 1; mask < 256 ; mask <<= 1) {
+            // Is this a new code (un-compressed), or
+            //  the use of existing codes (compressed)?
+            boolean isMaskSet = (flag & mask) > 0;
+            if( isMaskSet && !maskMeansCompressed ) {
+               // Retrieve the un-compressed code
+               if( (dataI = src.read()) != -1) {
+                  // Save the byte into the dictionary
+                  buffer[(pos&4095)] = fromInt(dataI);
+                  pos++;
+                  // And output the byte
+                  res.write( new byte[] {fromInt(dataI)} );
+               }
+            } else {
+               // We have a compressed sequence
+               // Grab the next 16 bits of data
+               dataIPt1 = src.read();
+               dataIPt2 = src.read();
+               if(dataIPt1 == -1 || dataIPt2 == -1) break;
+
+               // Build up how long the code sequence is, and
+               //  what position of the code to start at
+               // (The position is the first 12 bits, the
+               //  length is the last 4 bits)
+               len = (dataIPt2 & 15) + 3;
+               pntr = (dataIPt2 & 240)*16 + dataIPt1;
+
+               // Adjust the pointer as needed
+               pntr = adjustDictionaryOffset(pntr);
+
+               // Loop over the codes, outputting what they correspond to
+               for(int i=0; i<len; i++) {
+                  dataB[i] = buffer[(pntr + i) & 4095];
+                  buffer[ (pos + i) & 4095 ] = dataB[i];
+               }
+               res.write(dataB, 0, len);
+
+               // Record how far along the stream we have moved
+               pos = pos + len;
+            }
+         }
+      }
+   }
+
+   /**
+    * Given an integer, turn it into a java byte, handling
+    *  the wrapping.
+    * This is a convenience method
+    */
+   public static byte fromInt(int b) {
+      if(b < 128) return (byte)b;
+      return (byte)(b - 256);
+   }
+   /**
+    * Given a java byte, turn it into an integer between 0
+    *  and 255 (i.e. handle the unwrapping).
+    * This is a convenience method
+    */
+   public static int fromByte(byte b) {
+      if(b >= 0) {
+         return b;
+      }
+      return b + 256;
+   }
+}
diff --git a/src/java/org/apache/poi/util/LittleEndian.java b/src/java/org/apache/poi/util/LittleEndian.java
index 373710b..abc494c 100644
--- a/src/java/org/apache/poi/util/LittleEndian.java
+++ b/src/java/org/apache/poi/util/LittleEndian.java
@@ -28,13 +28,12 @@
  *@author     Marc Johnson (mjohnson at apache dot org)
  *@author     Andrew Oliver (acoliver at apache dot org)
  */
-public final class LittleEndian implements LittleEndianConsts {
+public class LittleEndian implements LittleEndianConsts {
 
     private LittleEndian() {
-    	// no instances of this class
+        // no instances of this class
     }
 
-
     /**
      *  get a short value from a byte array
      *
@@ -42,9 +41,10 @@
      *@param  offset  a starting offset into the byte array
      *@return         the short (16-bit) value
      */
-
-    public static short getShort(final byte[] data, final int offset) {
-        return (short) getNumber(data, offset, SHORT_SIZE);
+    public static short getShort(byte[] data, int offset) {
+        int b0 = data[offset] & 0xFF;
+        int b1 = data[offset+1] & 0xFF;
+        return (short) ((b1 << 8) + (b0 << 0));
     }
 
 
@@ -55,73 +55,32 @@
      *@param  offset  a starting offset into the byte array
      *@return         the unsigned short (16-bit) value in an integer
      */
-    public static int getUShort(final byte[] data, final int offset) {
-        short num = (short) getNumber(data, offset, SHORT_SIZE);
-        int retNum;
-        if (num < 0) {
-            retNum = (Short.MAX_VALUE + 1) * 2 + num;
-        } else {
-            retNum = num;
-        }
-        return retNum;
+    public static int getUShort(byte[] data, int offset) {
+        int b0 = data[offset] & 0xFF;
+        int b1 = data[offset+1] & 0xFF;
+        return (b1 << 8) + (b0 << 0);
     }
 
-
-    /**
-     *  get a short array from a byte array.
-     *
-     *@param  data    Description of the Parameter
-     *@param  offset  Description of the Parameter
-     *@param  size    Description of the Parameter
-     *@return         The simpleShortArray value
-     */
-    public static short[] getSimpleShortArray(final byte[] data, final int offset, final int size) {
-        short[] results = new short[size];
-        for (int i = 0; i < size; i++) {
-            results[i] = getShort(data, offset + 2 + (i * 2));
-        }
-        return results;
-    }
-
-
-    /**
-     *  get a short array from a byte array. The short array is assumed to start
-     *  with a word describing the length of the array.
-     *
-     *@param  data    Description of the Parameter
-     *@param  offset  Description of the Parameter
-     *@return         The shortArray value
-     */
-    public static short[] getShortArray(final byte[] data, final int offset) {
-        int size = (int) getNumber(data, offset, SHORT_SIZE);
-        short[] results = getSimpleShortArray(data, offset, size);
-        return results;
-    }
-
-
     /**
      *  get a short value from the beginning of a byte array
      *
      *@param  data  the byte array
      *@return       the short (16-bit) value
      */
-
-    public static short getShort(final byte[] data) {
+    public static short getShort(byte[] data) {
         return getShort(data, 0);
     }
 
-
     /**
      *  get an unsigned short value from the beginning of a byte array
      *
      *@param  data  the byte array
      *@return       the unsigned short (16-bit) value in an int
      */
-    public static int getUShort(final byte[] data) {
+    public static int getUShort(byte[] data) {
         return getUShort(data, 0);
     }
 
-
     /**
      *  get an int value from a byte array
      *
@@ -129,9 +88,13 @@
      *@param  offset  a starting offset into the byte array
      *@return         the int (32-bit) value
      */
-
-    public static int getInt(final byte[] data, final int offset) {
-        return (int) getNumber(data, offset, INT_SIZE);
+    public static int getInt(byte[] data, int offset) {
+        int i=offset;
+        int b0 = data[i++] & 0xFF;
+        int b1 = data[i++] & 0xFF;
+        int b2 = data[i++] & 0xFF;
+        int b3 = data[i++] & 0xFF;
+        return (b3 << 24) + (b2 << 16) + (b1 << 8) + (b0 << 0);
     }
 
 
@@ -139,10 +102,9 @@
      *  get an int value from the beginning of a byte array
      *
      *@param  data  the byte array
-     *@return       the int (32-bit) value
+     *@return the int (32-bit) value
      */
-
-    public static int getInt(final byte[] data) {
+    public static int getInt(byte[] data) {
         return getInt(data, 0);
     }
 
@@ -154,15 +116,9 @@
      *@param  offset  a starting offset into the byte array
      *@return         the unsigned int (32-bit) value in a long
      */
-    public static long getUInt(final byte[] data, final int offset) {
-        int num = (int) getNumber(data, offset, INT_SIZE);
-        long retNum;
-        if (num < 0) {
-            retNum = ((long) Integer.MAX_VALUE + 1) * 2 + num;
-        } else {
-            retNum = num;
-        }
-        return retNum;
+    public static long getUInt(byte[] data, int offset) {
+        long retNum = getInt(data, offset);
+        return retNum & 0x00FFFFFFFF;
     }
 
     /**
@@ -171,8 +127,8 @@
      *@param  data    the byte array
      *@return         the unsigned int (32-bit) value in a long
      */
-    public static long getUInt(final byte[] data) {
-	return getUInt(data,0);
+    public static long getUInt(byte[] data) {
+        return getUInt(data,0);
     }
 
     /**
@@ -182,24 +138,16 @@
      *@param  offset  a starting offset into the byte array
      *@return         the long (64-bit) value
      */
-
-    public static long getLong(final byte[] data, final int offset) {
-        return getNumber(data, offset, LONG_SIZE);
+    public static long getLong(byte[] data, int offset) {
+        long result = 0;
+		
+		for (int j = offset + LONG_SIZE - 1; j >= offset; j--) {
+		    result <<= 8;
+		    result |= 0xff & data[j];
+		}
+		return result;
     }
 
-
-    /**
-     *  get a long value from the beginning of a byte array
-     *
-     *@param  data  the byte array
-     *@return       the long (64-bit) value
-     */
-
-    public static long getLong(final byte[] data) {
-        return getLong(data, 0);
-    }
-
-
     /**
      *  get a double value from a byte array, reads it in little endian format
      *  then converts the resulting revolting IEEE 754 (curse them) floating
@@ -209,24 +157,10 @@
      *@param  offset  a starting offset into the byte array
      *@return         the double (64-bit) value
      */
-
-    public static double getDouble(final byte[] data, final int offset) {
-        return Double.longBitsToDouble(getNumber(data, offset, DOUBLE_SIZE));
+    public static double getDouble(byte[] data, int offset) {
+        return Double.longBitsToDouble(getLong(data, offset));
     }
 
-
-    /**
-     *  get a double value from the beginning of a byte array
-     *
-     *@param  data  the byte array
-     *@return       the double (64-bit) value
-     */
-
-    public static double getDouble(final byte[] data) {
-        return getDouble(data, 0);
-    }
-
-
     /**
      *  put a short value into a byte array
      *
@@ -234,9 +168,10 @@
      *@param  offset  a starting offset into the byte array
      *@param  value   the short (16-bit) value
      */
-    public static void putShort(final byte[] data, final int offset,
-            final short value) {
-        putNumber(data, offset, value, SHORT_SIZE);
+    public static void putShort(byte[] data, int offset, short value) {
+        int i = offset;
+        data[i++] = (byte)((value >>>  0) & 0xFF);
+        data[i++] = (byte)((value >>>  8) & 0xFF);
     }
 
     /**
@@ -247,7 +182,7 @@
      * Added for consistency with other put~() methods
      */
     public static void putByte(byte[] data, int offset, int value) {
-        putNumber(data, offset, value, LittleEndianConsts.BYTE_SIZE);
+        data[offset] = (byte) value;
     }
 
     /**
@@ -259,10 +194,10 @@
      *
      * @exception ArrayIndexOutOfBoundsException may be thrown
      */
-    public static void putUShort(final byte[] data, final int offset,
-                                final int value)
-    {
-        putNumber(data, offset, value, SHORT_SIZE);
+    public static void putUShort(byte[] data, int offset, int value) {
+        int i = offset;
+        data[i++] = (byte)((value >>>  0) & 0xFF);
+        data[i++] = (byte)((value >>>  8) & 0xFF);
     }
 
     /**
@@ -271,8 +206,7 @@
      *@param  data   the byte array
      *@param  value  the short (16-bit) value
      */
-
-    public static void putShort(final byte[] data, final short value) {
+    public static void putShort(byte[] data, short value) {
         putShort(data, 0, value);
     }
 
@@ -284,10 +218,12 @@
      *@param  offset  a starting offset into the byte array
      *@param  value   the int (32-bit) value
      */
-
-    public static void putInt(final byte[] data, final int offset,
-            final int value) {
-        putNumber(data, offset, value, INT_SIZE);
+    public static void putInt(byte[] data, int offset, int value) {
+        int i = offset;
+        data[i++] = (byte)((value >>>  0) & 0xFF);
+        data[i++] = (byte)((value >>>  8) & 0xFF);
+        data[i++] = (byte)((value >>> 16) & 0xFF);
+        data[i++] = (byte)((value >>> 24) & 0xFF);
     }
 
 
@@ -297,8 +233,7 @@
      *@param  data   the byte array
      *@param  value  the int (32-bit) value
      */
-
-    public static void putInt(final byte[] data, final int value) {
+    public static void putInt(byte[] data, int value) {
         putInt(data, 0, value);
     }
 
@@ -310,22 +245,14 @@
      *@param  offset  a starting offset into the byte array
      *@param  value   the long (64-bit) value
      */
-
-    public static void putLong(final byte[] data, final int offset,
-            final long value) {
-        putNumber(data, offset, value, LONG_SIZE);
-    }
-
-
-    /**
-     *  put a long value into beginning of a byte array
-     *
-     *@param  data   the byte array
-     *@param  value  the long (64-bit) value
-     */
-
-    public static void putLong(final byte[] data, final long value) {
-        putLong(data, 0, value);
+    public static void putLong(byte[] data, int offset, long value) {
+        int limit = LONG_SIZE + offset;
+        long v = value;
+        
+        for (int j = offset; j < limit; j++) {
+            data[j] = (byte) (v & 0xFF);
+            v >>= 8;
+        }
     }
 
 
@@ -336,26 +263,8 @@
      *@param  offset  a starting offset into the byte array
      *@param  value   the double (64-bit) value
      */
-
-    public static void putDouble(final byte[] data, final int offset,
-            final double value) {
-        // Excel likes NaN to be a specific value.
-        if (Double.isNaN(value))
-            putNumber(data, offset, -276939487313920L, DOUBLE_SIZE);
-        else
-            putNumber(data, offset, Double.doubleToLongBits(value), DOUBLE_SIZE);
-    }
-
-
-    /**
-     *  put a double value into beginning of a byte array
-     *
-     *@param  data   the byte array
-     *@param  value  the double (64-bit) value
-     */
-
-    public static void putDouble(final byte[] data, final double value) {
-        putDouble(data, 0, value);
+    public static void putDouble(byte[] data, int offset, double value) {
+        putLong(data, offset, Double.doubleToLongBits(value));
     }
 
 
@@ -364,7 +273,6 @@
      *
      *@author     Marc Johnson (mjohnson at apache dot org)
      */
-
     public static final class BufferUnderrunException extends IOException {
 
         BufferUnderrunException() {
@@ -376,79 +284,72 @@
     /**
      *  get a short value from an InputStream
      *
-     *@param  stream                       the InputStream from which the short
-     *      is to be read
+     *@param  stream the InputStream from which the short is to be read
      *@return                              the short (16-bit) value
      *@exception  IOException              will be propagated back to the caller
-     *@exception  BufferUnderrunException  if the stream cannot provide enough
-     *      bytes
+     *@exception  BufferUnderrunException  if the stream cannot provide enough bytes
      */
     public static short readShort(InputStream stream) throws IOException, BufferUnderrunException {
 
-		return (short) readUShort(stream);
-	}
+        return (short) readUShort(stream);
+    }
 
-	public static int readUShort(InputStream stream) throws IOException, BufferUnderrunException {
+    public static int readUShort(InputStream stream) throws IOException, BufferUnderrunException {
 
-		int ch1 = stream.read();
-		int ch2 = stream.read();
-		if ((ch1 | ch2) < 0) {
-			throw new BufferUnderrunException();
-		}
-		return ((ch2 << 8) + (ch1 << 0));
-	}
+        int ch1 = stream.read();
+        int ch2 = stream.read();
+        if ((ch1 | ch2) < 0) {
+            throw new BufferUnderrunException();
+        }
+        return (ch2 << 8) + (ch1 << 0);
+    }
     
 
     /**
      *  get an int value from an InputStream
      *
-     *@param  stream                       the InputStream from which the int is
-     *      to be read
-     *@return                              the int (32-bit) value
-     *@exception  IOException              will be propagated back to the caller
-     *@exception  BufferUnderrunException  if the stream cannot provide enough
-     *      bytes
+     *@param  stream the InputStream from which the int is to be read
+     * @return                              the int (32-bit) value
+     * @exception  IOException              will be propagated back to the caller
+     * @exception  BufferUnderrunException  if the stream cannot provide enough bytes
      */
-    public static int readInt(final InputStream stream)
+    public static int readInt(InputStream stream)
              throws IOException, BufferUnderrunException {
-		int ch1 = stream.read();
-		int ch2 = stream.read();
-		int ch3 = stream.read();
-		int ch4 = stream.read();
-		if ((ch1 | ch2 | ch3 | ch4) < 0) {
-			throw new BufferUnderrunException();
-		}
-		return ((ch4 << 24) + (ch3<<16) + (ch2 << 8) + (ch1 << 0));
+        int ch1 = stream.read();
+        int ch2 = stream.read();
+        int ch3 = stream.read();
+        int ch4 = stream.read();
+        if ((ch1 | ch2 | ch3 | ch4) < 0) {
+            throw new BufferUnderrunException();
+        }
+        return (ch4 << 24) + (ch3<<16) + (ch2 << 8) + (ch1 << 0);
     }
 
 
     /**
      *  get a long value from an InputStream
      *
-     *@param  stream                       the InputStream from which the long
-     *      is to be read
-     *@return                              the long (64-bit) value
-     *@exception  IOException              will be propagated back to the caller
-     *@exception  BufferUnderrunException  if the stream cannot provide enough
-     *      bytes
+     * @param  stream the InputStream from which the long is to be read
+     * @return                              the long (64-bit) value
+     * @exception  IOException              will be propagated back to the caller
+     * @exception  BufferUnderrunException  if the stream cannot provide enough bytes
      */
-
-    public static long readLong(final InputStream stream)
+    public static long readLong(InputStream stream)
              throws IOException, BufferUnderrunException {
-		int ch1 = stream.read();
-		int ch2 = stream.read();
-		int ch3 = stream.read();
-		int ch4 = stream.read();
-		int ch5 = stream.read();
-		int ch6 = stream.read();
-		int ch7 = stream.read();
-		int ch8 = stream.read();
-		if ((ch1 | ch2 | ch3 | ch4 | ch5 | ch6 | ch7 | ch8) < 0) {
-			throw new BufferUnderrunException();
-		}
-		
-		return 
-			((long)ch8 << 56) +
+        int ch1 = stream.read();
+        int ch2 = stream.read();
+        int ch3 = stream.read();
+        int ch4 = stream.read();
+        int ch5 = stream.read();
+        int ch6 = stream.read();
+        int ch7 = stream.read();
+        int ch8 = stream.read();
+        if ((ch1 | ch2 | ch3 | ch4 | ch5 | ch6 | ch7 | ch8) < 0) {
+            throw new BufferUnderrunException();
+        }
+        
+        return 
+            ((long)ch8 << 56) +
             ((long)ch7 << 48) +
             ((long)ch6 << 40) +
             ((long)ch5 << 32) +
@@ -459,113 +360,43 @@
     }
 
     /**
-     *  Gets the number attribute of the LittleEndian class
-     *
-     *@param  data    Description of the Parameter
-     *@param  offset  Description of the Parameter
-     *@param  size    Description of the Parameter
-     *@return         The number value
-     */
-    private static long getNumber(final byte[] data, final int offset,
-            final int size) {
-        long result = 0;
-
-        for (int j = offset + size - 1; j >= offset; j--) {
-            result <<= 8;
-            result |= 0xff & data[j];
-        }
-        return result;
-    }
-
-
-    /**
-     *  Description of the Method
-     *
-     *@param  data    Description of the Parameter
-     *@param  offset  Description of the Parameter
-     *@param  value   Description of the Parameter
-     *@param  size    Description of the Parameter
-     */
-    private static void putNumber(final byte[] data, final int offset,
-            final long value, final int size) {
-        int limit = size + offset;
-        long v = value;
-
-        for (int j = offset; j < limit; j++) {
-            data[j] = (byte) (v & 0xFF);
-            v >>= 8;
-        }
-    }
-
-
-    /**
      *  Convert an 'unsigned' byte to an integer. ie, don't carry across the
      *  sign.
      *
-     *@param  b  Description of the Parameter
-     *@return    Description of the Return Value
+     * @param  b  Description of the Parameter
+     * @return    Description of the Return Value
      */
     public static int ubyteToInt(byte b) {
-        return ((b & 0x80) == 0 ? (int) b : (b & (byte) 0x7f) + 0x80);
+        return b & 0xFF;
     }
 
 
     /**
      *  get the unsigned value of a byte.
      *
-     *@param  data    the byte array.
-     *@param  offset  a starting offset into the byte array.
-     *@return         the unsigned value of the byte as a 32 bit integer
+     * @param  data    the byte array.
+     * @param  offset  a starting offset into the byte array.
+     * @return         the unsigned value of the byte as a 32 bit integer
      */
-    public static int getUnsignedByte(final byte[] data, final int offset) {
-        return (int) getNumber(data, offset, BYTE_SIZE);
-    }
-
-
-    /**
-     *  get the unsigned value of a byte.
-     *
-     *@param  data  the byte array
-     *@return       the unsigned value of the byte as a 32 bit integer
-     */
-    public static int getUnsignedByte(final byte[] data) {
-        return getUnsignedByte(data, 0);
+    public static int getUnsignedByte(byte[] data, int offset) {
+        return data[offset] & 0xFF;
     }
 
 
     /**
      *  Copy a portion of a byte array
      *
-     *@param  data                        the original byte array
-     *@param  offset                      Where to start copying from.
-     *@param  size                        Number of bytes to copy.
-     *@return                             The byteArray value
-     *@throws  IndexOutOfBoundsException  - if copying would cause access of
+     * @param  data                        the original byte array
+     * @param  offset                      Where to start copying from.
+     * @param  size                        Number of bytes to copy.
+     * @return                             The byteArray value
+     * @throws  IndexOutOfBoundsException  - if copying would cause access of
      *      data outside array bounds.
      */
-    public static byte[] getByteArray(final byte[] data, int offset, int size) {
+    public static byte[] getByteArray(byte[] data, int offset, int size) {
         byte[] copy = new byte[size];
         System.arraycopy(data, offset, copy, 0, size);
 
         return copy;
     }
-
-    /**
-     * <p>Gets an unsigned int value (8 bytes) from a byte array.</p>
-     * 
-     * @param data the byte array
-     * @param offset a starting offset into the byte array
-     * @return the unsigned int (32-bit) value in a long
-     */
-    public static long getULong(final byte[] data, final int offset)
-    {
-        int num = (int) getNumber(data, offset, LONG_SIZE);
-        long retNum;
-        if (num < 0)
-            retNum = ((long) Integer.MAX_VALUE + 1) * 2 + num;
-        else
-            retNum = num;
-        return retNum;
-    }
-
 }
diff --git a/src/java/org/apache/poi/util/LittleEndianByteArrayInputStream.java b/src/java/org/apache/poi/util/LittleEndianByteArrayInputStream.java
new file mode 100644
index 0000000..7f50939
--- /dev/null
+++ b/src/java/org/apache/poi/util/LittleEndianByteArrayInputStream.java
@@ -0,0 +1,119 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.util;
+
+/**
+ * Adapts a plain byte array to {@link LittleEndianInput}
+ *
+ * @author Josh Micich
+ */
+public final class LittleEndianByteArrayInputStream implements LittleEndianInput {
+	private final byte[] _buf;
+	private final int _endIndex;
+	private int _readIndex;
+
+	public LittleEndianByteArrayInputStream(byte[] buf, int startOffset, int maxReadLen) {
+		_buf = buf;
+		_readIndex = startOffset;
+		_endIndex = startOffset + maxReadLen;
+	}
+	public LittleEndianByteArrayInputStream(byte[] buf, int startOffset) {
+		this(buf, startOffset, buf.length - startOffset);
+	}
+	public LittleEndianByteArrayInputStream(byte[] buf) {
+		this(buf, 0, buf.length);
+	}
+
+	public int available() {
+		return _endIndex - _readIndex;
+	}
+	private void checkPosition(int i) {
+		if (i > _endIndex - _readIndex) {
+			throw new RuntimeException("Buffer overrun");
+		}
+	}
+
+	public int getReadIndex() {
+		return _readIndex;
+	}
+	public byte readByte() {
+		checkPosition(1);
+		return _buf[_readIndex++];
+	}
+
+	public int readInt() {
+		checkPosition(4);
+		int i = _readIndex;
+
+		int b0 = _buf[i++] & 0xFF;
+		int b1 = _buf[i++] & 0xFF;
+		int b2 = _buf[i++] & 0xFF;
+		int b3 = _buf[i++] & 0xFF;
+		_readIndex = i;
+		return (b3 << 24) + (b2 << 16) + (b1 << 8) + (b0 << 0);
+	}
+	public long readLong() {
+		checkPosition(8);
+		int i = _readIndex;
+
+		int b0 = _buf[i++] & 0xFF;
+		int b1 = _buf[i++] & 0xFF;
+		int b2 = _buf[i++] & 0xFF;
+		int b3 = _buf[i++] & 0xFF;
+		int b4 = _buf[i++] & 0xFF;
+		int b5 = _buf[i++] & 0xFF;
+		int b6 = _buf[i++] & 0xFF;
+		int b7 = _buf[i++] & 0xFF;
+		_readIndex = i;
+		return (((long)b7 << 56) +
+				((long)b6 << 48) +
+				((long)b5 << 40) +
+				((long)b4 << 32) +
+				((long)b3 << 24) +
+				(b2 << 16) +
+				(b1 <<  8) +
+				(b0 <<  0));
+	}
+	public short readShort() {
+		return (short)readUShort();
+	}
+	public int readUByte() {
+		checkPosition(1);
+		return _buf[_readIndex++] & 0xFF;
+	}
+	public int readUShort() {
+		checkPosition(2);
+		int i = _readIndex;
+
+		int b0 = _buf[i++] & 0xFF;
+		int b1 = _buf[i++] & 0xFF;
+		_readIndex = i;
+		return (b1 << 8) + (b0 << 0);
+	}
+	public void readFully(byte[] buf, int off, int len) {
+		checkPosition(len);
+		System.arraycopy(_buf, _readIndex, buf, off, len);
+		_readIndex+=len;
+	}
+	public void readFully(byte[] buf) {
+		readFully(buf, 0, buf.length);
+	}
+	public double readDouble() {
+		return Double.longBitsToDouble(readLong());
+	}
+}
diff --git a/src/java/org/apache/poi/util/LittleEndianByteArrayOutputStream.java b/src/java/org/apache/poi/util/LittleEndianByteArrayOutputStream.java
new file mode 100644
index 0000000..0320734
--- /dev/null
+++ b/src/java/org/apache/poi/util/LittleEndianByteArrayOutputStream.java
@@ -0,0 +1,106 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.util;
+
+
+/**
+ * Adapts a plain byte array to {@link LittleEndianOutput} 
+ * 
+ * 
+ * @author Josh Micich
+ */
+public final class LittleEndianByteArrayOutputStream implements LittleEndianOutput, DelayableLittleEndianOutput {
+	private final byte[] _buf;
+	private final int _endIndex;
+	private int _writeIndex;
+
+	public LittleEndianByteArrayOutputStream(byte[] buf, int startOffset, int maxWriteLen) {
+		if (startOffset < 0 || startOffset > buf.length) {
+			throw new IllegalArgumentException("Specified startOffset (" + startOffset 
+					+ ") is out of allowable range (0.." + buf.length + ")");
+		}
+		_buf = buf;
+		_writeIndex = startOffset;
+		_endIndex = startOffset + maxWriteLen;
+		if (_endIndex < startOffset ||  _endIndex > buf.length) {
+			throw new IllegalArgumentException("calculated end index (" + _endIndex 
+					+ ") is out of allowable range (" + _writeIndex + ".." + buf.length + ")");
+		}
+	}
+	public LittleEndianByteArrayOutputStream(byte[] buf, int startOffset) {
+		this(buf, startOffset, buf.length - startOffset);
+	}
+
+	private void checkPosition(int i) {
+		if (i > _endIndex - _writeIndex) {
+			throw new RuntimeException("Buffer overrun");
+		}
+	}
+
+	public void writeByte(int v) {
+		checkPosition(1);
+		_buf[_writeIndex++] = (byte)v;
+	}
+
+	public void writeDouble(double v) {
+		writeLong(Double.doubleToLongBits(v));
+	}
+
+	public void writeInt(int v) {
+		checkPosition(4);
+		int i = _writeIndex;
+		_buf[i++] = (byte)((v >>>  0) & 0xFF);
+		_buf[i++] = (byte)((v >>>  8) & 0xFF);
+		_buf[i++] = (byte)((v >>> 16) & 0xFF);
+		_buf[i++] = (byte)((v >>> 24) & 0xFF);
+		_writeIndex = i;
+	}
+
+	public void writeLong(long v) {
+		writeInt((int)(v >>  0));
+		writeInt((int)(v >> 32));
+	}
+
+	public void writeShort(int v) {
+		checkPosition(2);
+		int i = _writeIndex;
+		_buf[i++] = (byte)((v >>>  0) & 0xFF);
+		_buf[i++] = (byte)((v >>>  8) & 0xFF);
+		_writeIndex = i;
+	}
+	public void write(byte[] b) {
+		int len = b.length;
+		checkPosition(len);
+		System.arraycopy(b, 0, _buf, _writeIndex, len);
+		_writeIndex += len;
+	}
+	public void write(byte[] b, int offset, int len) {
+		checkPosition(len);
+		System.arraycopy(b, offset, _buf, _writeIndex, len);
+		_writeIndex += len;
+	}
+	public int getWriteIndex() {
+		return _writeIndex;
+	}
+	public LittleEndianOutput createDelayedOutput(int size) {
+		checkPosition(size);
+		LittleEndianOutput result = new LittleEndianByteArrayOutputStream(_buf, _writeIndex, size);
+		_writeIndex += size;
+		return result;
+	}
+}
diff --git a/src/java/org/apache/poi/util/LittleEndianInput.java b/src/java/org/apache/poi/util/LittleEndianInput.java
new file mode 100644
index 0000000..d8db247
--- /dev/null
+++ b/src/java/org/apache/poi/util/LittleEndianInput.java
@@ -0,0 +1,34 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.util;
+/**
+ *
+ * @author Josh Micich
+ */
+public interface LittleEndianInput {
+	int available();
+	byte readByte();
+	int readUByte();
+	short readShort();
+	int readUShort();
+	int readInt();
+	long readLong();
+	double readDouble();
+	void readFully(byte[] buf);
+	void readFully(byte[] buf, int off, int len);
+}
diff --git a/src/java/org/apache/poi/util/LittleEndianInputStream.java b/src/java/org/apache/poi/util/LittleEndianInputStream.java
new file mode 100644
index 0000000..1a37964
--- /dev/null
+++ b/src/java/org/apache/poi/util/LittleEndianInputStream.java
@@ -0,0 +1,144 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.util;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Wraps an {@link InputStream} providing {@link LittleEndianInput}<p/>
+ *
+ * This class does not buffer any input, so the stream read position maintained
+ * by this class is consistent with that of the inner stream.
+ *
+ * @author Josh Micich
+ */
+public class LittleEndianInputStream extends FilterInputStream implements LittleEndianInput {
+	public LittleEndianInputStream(InputStream is) {
+		super(is);
+	}
+	public int available() {
+		try {
+			return super.available();
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+	public byte readByte() {
+		return (byte)readUByte();
+	}
+	public int readUByte() {
+		int ch;
+		try {
+			ch = in.read();
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+		checkEOF(ch);
+		return ch;
+	}
+	public double readDouble() {
+		return Double.longBitsToDouble(readLong());
+	}
+	public int readInt() {
+		int ch1;
+		int ch2;
+		int ch3;
+		int ch4;
+		try {
+			ch1 = in.read();
+			ch2 = in.read();
+			ch3 = in.read();
+			ch4 = in.read();
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+		checkEOF(ch1 | ch2 | ch3 | ch4);
+		return (ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 << 0);
+	}
+	public long readLong() {
+		int b0;
+		int b1;
+		int b2;
+		int b3;
+		int b4;
+		int b5;
+		int b6;
+		int b7;
+		try {
+			b0 = in.read();
+			b1 = in.read();
+			b2 = in.read();
+			b3 = in.read();
+			b4 = in.read();
+			b5 = in.read();
+			b6 = in.read();
+			b7 = in.read();
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+		checkEOF(b0 | b1 | b2 | b3 | b4 | b5 | b6 | b7);
+		return (((long)b7 << 56) +
+				((long)b6 << 48) +
+				((long)b5 << 40) +
+				((long)b4 << 32) +
+				((long)b3 << 24) +
+				(b2 << 16) +
+				(b1 <<  8) +
+				(b0 <<  0));
+	}
+	public short readShort() {
+		return (short)readUShort();
+	}
+	public int readUShort() {
+		int ch1;
+		int ch2;
+		try {
+			ch1 = in.read();
+			ch2 = in.read();
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+		checkEOF(ch1 | ch2);
+		return (ch2 << 8) + (ch1 << 0);
+	}
+	private static void checkEOF(int value) {
+		if (value <0) {
+			throw new RuntimeException("Unexpected end-of-file");
+		}
+	}
+
+	public void readFully(byte[] buf) {
+		readFully(buf, 0, buf.length);
+	}
+
+	public void readFully(byte[] buf, int off, int len) {
+		int max = off+len;
+		for(int i=off; i<max; i++) {
+			int ch;
+			try {
+				ch = in.read();
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+			checkEOF(ch);
+			buf[i] = (byte) ch;
+		}
+	}
+}
diff --git a/src/java/org/apache/poi/util/LittleEndianOutput.java b/src/java/org/apache/poi/util/LittleEndianOutput.java
new file mode 100644
index 0000000..708d97b
--- /dev/null
+++ b/src/java/org/apache/poi/util/LittleEndianOutput.java
@@ -0,0 +1,31 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.util;
+/**
+ *
+ * @author Josh Micich
+ */
+public interface LittleEndianOutput {
+	void writeByte(int v);
+	void writeShort(int v);
+	void writeInt(int v);
+	void writeLong(long v);
+	void writeDouble(double v);
+	void write(byte[] b);
+	void write(byte[] b, int offset, int len);
+}
diff --git a/src/java/org/apache/poi/util/LittleEndianOutputStream.java b/src/java/org/apache/poi/util/LittleEndianOutputStream.java
new file mode 100644
index 0000000..c8bb9d4
--- /dev/null
+++ b/src/java/org/apache/poi/util/LittleEndianOutputStream.java
@@ -0,0 +1,91 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.util;
+
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ *
+ * @author Josh Micich
+ */
+public final class LittleEndianOutputStream extends FilterOutputStream implements LittleEndianOutput {
+	public LittleEndianOutputStream(OutputStream out) {
+		super(out);
+	}
+
+	public void writeByte(int v) {
+		try {
+			out.write(v);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	public void writeDouble(double v) {
+		writeLong(Double.doubleToLongBits(v));
+	}
+
+	public void writeInt(int v) {
+		int b3 = (v >>> 24) & 0xFF;
+		int b2 = (v >>> 16) & 0xFF;
+		int b1 = (v >>>  8) & 0xFF;
+		int b0 = (v >>>  0) & 0xFF;
+		try {
+			out.write(b0);
+			out.write(b1);
+			out.write(b2);
+			out.write(b3);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	public void writeLong(long v) {
+		writeInt((int)(v >>  0));
+		writeInt((int)(v >> 32));
+	}
+
+	public void writeShort(int v) {
+		int b1 = (v >>>  8) & 0xFF;
+		int b0 = (v >>>  0) & 0xFF;
+		try {
+			out.write(b0);
+			out.write(b1);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+	public void write(byte[] b) {
+		// suppress IOException for interface method
+		try {
+			super.write(b);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+	public void write(byte[] b, int off, int len) {
+		// suppress IOException for interface method
+		try {
+			super.write(b, off, len);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+}
diff --git a/src/java/org/apache/poi/util/NullLogger.java b/src/java/org/apache/poi/util/NullLogger.java
index d58c978..a2cdbf7 100644
--- a/src/java/org/apache/poi/util/NullLogger.java
+++ b/src/java/org/apache/poi/util/NullLogger.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,12 +14,9 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
-import java.util.*;
-
 /**
  * A logger class that strives to make it as easy as possible for
  * developers to write log calls, while simultaneously making those
@@ -31,14 +27,13 @@
  * @author Glen Stampoultzis (glens at apache.org)
  * @author Nicola Ken Barozzi (nicolaken at apache.org)
  */
-
 public class NullLogger extends POILogger
 {
     public void initialize(final String cat)
     {
-       //do nothing    
+       //do nothing
     }
-    
+
     /**
      * Log a message
      *
@@ -462,5 +457,5 @@
        //do nothing
     }
 
-} 
+}
 
diff --git a/src/java/org/apache/poi/util/POILogFactory.java b/src/java/org/apache/poi/util/POILogFactory.java
index a9ce66f..3d446c8 100644
--- a/src/java/org/apache/poi/util/POILogFactory.java
+++ b/src/java/org/apache/poi/util/POILogFactory.java
@@ -36,7 +36,7 @@
     /**
      * Map of POILogger instances, with classes as keys
      */
-    private static Map _loggers = new HashMap();;
+    private static Map<String,POILogger> _loggers = new HashMap<String,POILogger>();;
 
     /**
      * A common instance of NullLogger, as it does nothing
@@ -108,11 +108,12 @@
         // Fetch the right logger for them, creating
         //  it if that's required 
         if (_loggers.containsKey(cat)) {
-            logger = ( POILogger ) _loggers.get(cat);
+            logger = _loggers.get(cat);
         } else {
             try {
-              Class loggerClass = Class.forName(_loggerClassName);
-              logger = ( POILogger ) loggerClass.newInstance();
+              Class<? extends POILogger> loggerClass = 
+                 (Class<? extends POILogger>)Class.forName(_loggerClassName);
+              logger = loggerClass.newInstance();
               logger.initialize(cat);
             } catch(Exception e) {
               // Give up and use the null logger
diff --git a/src/java/org/apache/poi/util/POILogger.java b/src/java/org/apache/poi/util/POILogger.java
index 514edf9..cf722c4 100644
--- a/src/java/org/apache/poi/util/POILogger.java
+++ b/src/java/org/apache/poi/util/POILogger.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +14,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
@@ -31,34 +29,32 @@
  * @author Glen Stampoultzis (glens at apache.org)
  * @author Nicola Ken Barozzi (nicolaken at apache.org)
  */
+public abstract class POILogger {
 
-public abstract class POILogger
-{
-
-    public static final int DEBUG = 1;
-    public static final int INFO  = 3;
-    public static final int WARN  = 5;
-    public static final int ERROR = 7;
-    public static final int FATAL = 9;
+    public static int DEBUG = 1;
+    public static int INFO  = 3;
+    public static int WARN  = 5;
+    public static int ERROR = 7;
+    public static int FATAL = 9;
 
     /**
      * package scope so it cannot be instantiated outside of the util
      * package. You need a POILogger? Go to the POILogFactory for one
-     *
      */
-    POILogger()
-    {}
-    
-    abstract public void initialize(final String cat);
-    
+    POILogger() {
+        // no fields to initialise
+    }
+
+    abstract public void initialize(String cat);
+
     /**
      * Log a message
      *
      * @param level One of DEBUG, INFO, WARN, ERROR, FATAL
      * @param obj1 The object to log.  This is converted to a string.
      */
-    abstract public void log(final int level, final Object obj1);
-    
+    abstract public void log(int level, Object obj1);
+
     /**
      * Log a message
      *
@@ -66,7 +62,7 @@
      * @param obj1 The object to log.  This is converted to a string.
      * @param exception An exception to be logged
      */
-    abstract public void log(final int level, final Object obj1,
+    abstract public void log(int level, Object obj1,
                     final Throwable exception);
 
 
@@ -75,15 +71,7 @@
      *
      * @param level One of DEBUG, INFO, WARN, ERROR, FATAL
      */
-    abstract public boolean check(final int level);
-
-    /**
-     * Log a message. Lazily appends Object parameters together.
-     *
-     * @param level One of DEBUG, INFO, WARN, ERROR, FATAL
-     * @param obj1 first object to place in the message
-     * @param obj2 second object to place in the message
-     */
+    abstract public boolean check(int level);
 
    /**
      * Log a message. Lazily appends Object parameters together.
@@ -92,8 +80,7 @@
      * @param obj1 first object to place in the message
      * @param obj2 second object to place in the message
      */
-
-    public void log(final int level, final Object obj1, final Object obj2)
+    public void log(int level, Object obj1, Object obj2)
     {
         if (check(level))
         {
@@ -109,11 +96,10 @@
      * @param obj2 second Object to place in the message
      * @param obj3 third Object to place in the message
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3)
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3)
     {
-        
+
 
         if (check(level))
         {
@@ -132,11 +118,10 @@
      * @param obj3 third Object to place in the message
      * @param obj4 fourth Object to place in the message
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Object obj4)
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, Object obj4)
     {
-        
+
 
         if (check(level))
         {
@@ -156,11 +141,10 @@
      * @param obj4 fourth Object to place in the message
      * @param obj5 fifth Object to place in the message
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Object obj4, final Object obj5)
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, Object obj4, Object obj5)
     {
-        
+
 
         if (check(level))
         {
@@ -181,12 +165,11 @@
      * @param obj5 fifth Object to place in the message
      * @param obj6 sixth Object to place in the message
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Object obj4, final Object obj5,
-                    final Object obj6)
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, Object obj4, Object obj5,
+                    Object obj6)
     {
-        
+
 
         if (check(level))
         {
@@ -208,12 +191,11 @@
      * @param obj6 sixth Object to place in the message
      * @param obj7 seventh Object to place in the message
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Object obj4, final Object obj5,
-                    final Object obj6, final Object obj7)
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, Object obj4, Object obj5,
+                    Object obj6, Object obj7)
     {
-        
+
 
         if (check(level))
         {
@@ -237,12 +219,11 @@
      * @param obj7 seventh Object to place in the message
      * @param obj8 eighth Object to place in the message
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Object obj4, final Object obj5,
-                    final Object obj6, final Object obj7, final Object obj8)
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, Object obj4, Object obj5,
+                    Object obj6, Object obj7, Object obj8)
     {
-        
+
 
         if (check(level))
         {
@@ -259,8 +240,7 @@
      * @param level One of DEBUG, INFO, WARN, ERROR, FATAL
      * @param exception An exception to be logged
      */
-
-    public void log(final int level, final Throwable exception)
+    public void log(int level, final Throwable exception)
     {
         log(level, null, exception);
     }
@@ -273,11 +253,10 @@
      * @param obj2 second Object to place in the message
      * @param exception An exception to be logged
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
+    public void log(int level, Object obj1, Object obj2,
                     final Throwable exception)
     {
-        
+
 
         if (check(level))
         {
@@ -295,11 +274,10 @@
      * @param obj3 third object to place in the message
      * @param exception An error message to be logged
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Throwable exception)
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, final Throwable exception)
     {
-        
+
 
         if (check(level))
         {
@@ -318,12 +296,11 @@
      * @param obj4 fourth object to place in the message
      * @param exception An exception to be logged
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Object obj4,
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, Object obj4,
                     final Throwable exception)
     {
-        
+
 
         if (check(level))
         {
@@ -343,12 +320,11 @@
      * @param obj5 fifth object to place in the message
      * @param exception An exception to be logged
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Object obj4, final Object obj5,
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, Object obj4, Object obj5,
                     final Throwable exception)
     {
-        
+
 
         if (check(level))
         {
@@ -369,12 +345,11 @@
      * @param obj6 sixth object to place in the message
      * @param exception An exception to be logged
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Object obj4, final Object obj5,
-                    final Object obj6, final Throwable exception)
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, Object obj4, Object obj5,
+                    Object obj6, final Throwable exception)
     {
-        
+
 
         if (check(level))
         {
@@ -397,13 +372,12 @@
      * @param obj7 seventh object to place in the message
      * @param exception An exception to be logged
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Object obj4, final Object obj5,
-                    final Object obj6, final Object obj7,
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, Object obj4, Object obj5,
+                    Object obj6, Object obj7,
                     final Throwable exception)
     {
-        
+
 
         if (check(level))
         {
@@ -427,13 +401,12 @@
      * @param obj8 eighth object to place in the message
      * @param exception An exception to be logged
      */
-
-    public void log(final int level, final Object obj1, final Object obj2,
-                    final Object obj3, final Object obj4, final Object obj5,
-                    final Object obj6, final Object obj7, final Object obj8,
+    public void log(int level, Object obj1, Object obj2,
+                    Object obj3, Object obj4, Object obj5,
+                    Object obj6, Object obj7, Object obj8,
                     final Throwable exception)
     {
-        
+
 
         if (check(level))
         {
@@ -467,9 +440,8 @@
      * @param message The message to log.
      * @param obj1 The first object to match against.
      */
-
-    public void logFormatted(final int level, final String message,
-                             final Object obj1)
+    public void logFormatted(int level, String message,
+                             Object obj1)
     {
         commonLogFormatted(level, message, new Object[]
         {
@@ -502,9 +474,8 @@
      * @param obj1 The first object to match against.
      * @param obj2 The second object to match against.
      */
-
-    public void logFormatted(final int level, final String message,
-                             final Object obj1, final Object obj2)
+    public void logFormatted(int level, String message,
+                             Object obj1, Object obj2)
     {
         commonLogFormatted(level, message, new Object[]
         {
@@ -538,10 +509,9 @@
      * @param obj2 The second object to match against.
      * @param obj3 The third object to match against.
      */
-
-    public void logFormatted(final int level, final String message,
-                             final Object obj1, final Object obj2,
-                             final Object obj3)
+    public void logFormatted(int level, String message,
+                             Object obj1, Object obj2,
+                             Object obj3)
     {
         commonLogFormatted(level, message, new Object[]
         {
@@ -576,21 +546,20 @@
      * @param obj3 The third object to match against.
      * @param obj4 The forth object to match against.
      */
-
-    public void logFormatted(final int level, final String message,
-                             final Object obj1, final Object obj2,
-                             final Object obj3, final Object obj4)
+    public void logFormatted(int level, String message,
+                             Object obj1, Object obj2,
+                             Object obj3, Object obj4)
     {
         commonLogFormatted(level, message, new Object[]
         {
             obj1, obj2, obj3, obj4
         });
-    }                             
+    }
 
-    private void commonLogFormatted(final int level, final String message,
-                                    final Object [] unflatParams)
+    private void commonLogFormatted(int level, String message,
+                                    Object [] unflatParams)
     {
-        
+
 
         if (check(level))
         {
@@ -611,21 +580,20 @@
     /**
      * Flattens any contained objects. Only tranverses one level deep.
      */
-
-    private Object [] flattenArrays(final Object [] objects)
+    private Object [] flattenArrays(Object [] objects)
     {
-        List results = new ArrayList();
+        List<Object> results = new ArrayList<Object>();
 
         for (int i = 0; i < objects.length; i++)
         {
             results.addAll(objectToObjectArray(objects[ i ]));
         }
-        return ( Object [] ) results.toArray(new Object[ results.size() ]);
+        return results.toArray(new Object[ results.size() ]);
     }
 
-    private List objectToObjectArray(Object object)
+    private List<Object> objectToObjectArray(Object object)
     {
-        List results = new ArrayList();
+        List<Object> results = new ArrayList<Object>();
 
         if (object instanceof byte [])
         {
@@ -633,7 +601,7 @@
 
             for (int j = 0; j < array.length; j++)
             {
-                results.add(new Byte(array[ j ]));
+                results.add(Byte.valueOf(array[ j ]));
             }
         }
         if (object instanceof char [])
@@ -642,7 +610,7 @@
 
             for (int j = 0; j < array.length; j++)
             {
-                results.add(new Character(array[ j ]));
+                results.add(Character.valueOf(array[ j ]));
             }
         }
         else if (object instanceof short [])
@@ -651,7 +619,7 @@
 
             for (int j = 0; j < array.length; j++)
             {
-                results.add(new Short(array[ j ]));
+                results.add(Short.valueOf(array[ j ]));
             }
         }
         else if (object instanceof int [])
@@ -660,7 +628,7 @@
 
             for (int j = 0; j < array.length; j++)
             {
-                results.add(new Integer(array[ j ]));
+                results.add(Integer.valueOf(array[ j ]));
             }
         }
         else if (object instanceof long [])
@@ -669,7 +637,7 @@
 
             for (int j = 0; j < array.length; j++)
             {
-                results.add(new Long(array[ j ]));
+                results.add(Long.valueOf(array[ j ]));
             }
         }
         else if (object instanceof float [])
@@ -705,6 +673,4 @@
         }
         return results;
     }
-                                 
-}   // end package scope abstract class POILogger
-
+}
diff --git a/src/java/org/apache/poi/util/RecordFormatException.java b/src/java/org/apache/poi/util/RecordFormatException.java
new file mode 100644
index 0000000..d1643b8
--- /dev/null
+++ b/src/java/org/apache/poi/util/RecordFormatException.java
@@ -0,0 +1,42 @@
+
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+        
+
+package org.apache.poi.util;
+
+/**
+ * A common exception thrown by our binary format parsers
+ *  (especially HSSF and DDF), when they hit invalid
+ *  format or data when processing a record.
+ */
+public class RecordFormatException
+    extends RuntimeException
+{
+    public RecordFormatException(String exception)
+    {
+        super(exception);
+    }
+    
+    public RecordFormatException(String exception, Throwable thr) {
+      super(exception, thr);
+    }
+    
+    public RecordFormatException(Throwable thr) {
+      super(thr);
+    }
+}
diff --git a/src/java/org/apache/poi/util/ShortList.java b/src/java/org/apache/poi/util/ShortList.java
index c06a9c7..3a6cfb8 100644
--- a/src/java/org/apache/poi/util/ShortList.java
+++ b/src/java/org/apache/poi/util/ShortList.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,12 +14,9 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
-import java.util.*;
-
 /**
  * A List of short's; as full an implementation of the java.util.List
  * interface as possible, with an eye toward minimal creation of
diff --git a/src/java/org/apache/poi/util/StringUtil.java b/src/java/org/apache/poi/util/StringUtil.java
index 957068a..81568fe 100644
--- a/src/java/org/apache/poi/util/StringUtil.java
+++ b/src/java/org/apache/poi/util/StringUtil.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,49 +14,52 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.util;
 
 import java.io.UnsupportedEncodingException;
 import java.text.FieldPosition;
 import java.text.NumberFormat;
-/** 
- *  Title: String Utility Description: Collection of string handling utilities 
- *  
- * 
- *@author     Andrew C. Oliver 
- *@author     Sergei Kozello (sergeikozello at mail.ru) 
- *@author     Toshiaki Kamoshida (kamoshida.toshiaki at future dot co dot jp) 
- *@since      May 10, 2002 
- *@version    1.0 
+import java.util.Iterator;
+
+import org.apache.poi.hssf.record.RecordInputStream;
+/**
+ *  Title: String Utility Description: Collection of string handling utilities<p/>
+ *
+ * Note - none of the methods in this class deals with {@link org.apache.poi.hssf.record.ContinueRecord}s.  For such
+ * functionality, consider using {@link RecordInputStream
+} *
+ *
+ *@author     Andrew C. Oliver
+ *@author     Sergei Kozello (sergeikozello at mail.ru)
+ *@author     Toshiaki Kamoshida (kamoshida.toshiaki at future dot co dot jp)
  */
 public class StringUtil {
-	private final static String ENCODING = "ISO-8859-1";
-	/**     
-	 *  Constructor for the StringUtil object     
-	 */
+	private static final String ENCODING_ISO_8859_1 = "ISO-8859-1";
+
 	private StringUtil() {
+		// no instances of this class
 	}
 
-	/**     
+	/**
 	 *  Given a byte array of 16-bit unicode characters in Little Endian
 	 *  format (most important byte last), return a Java String representation
-	 *  of it. 
-	 *     
-	 * { 0x16, 0x00 } -0x16     
-	 *      
+	 *  of it.
+	 *
+	 * { 0x16, 0x00 } -0x16
+	 *
 	 * @param  string  the byte array to be converted
 	 * @param  offset  the initial offset into the
 	 *                 byte array. it is assumed that string[ offset ] and string[ offset +
 	 *                 1 ] contain the first 16-bit unicode character
      * @param len the length of the final string
-	 * @return                                     the converted string
+	 * @return the converted string, never <code>null</code>.
 	 * @exception  ArrayIndexOutOfBoundsException  if offset is out of bounds for
-	 *      the byte array (i.e., is negative or is greater than or equal to     
-	 *      string.length)     
+	 *      the byte array (i.e., is negative or is greater than or equal to
+	 *      string.length)
 	 * @exception  IllegalArgumentException        if len is too large (i.e.,
-	 *      there is not enough data in string to create a String of that     
-	 *      length)     
+	 *      there is not enough data in string to create a String of that
+	 *      length)
 	 */
 	public static String getFromUnicodeLE(
 		final byte[] string,
@@ -65,7 +67,7 @@
 		final int len)
 		throws ArrayIndexOutOfBoundsException, IllegalArgumentException {
 		if ((offset < 0) || (offset >= string.length)) {
-			throw new ArrayIndexOutOfBoundsException("Illegal offset");
+			throw new ArrayIndexOutOfBoundsException("Illegal offset " + offset + " (String data is of length " + string.length + ")");
 		}
 		if ((len < 0) || (((string.length - offset) / 2) < len)) {
 			throw new IllegalArgumentException("Illegal length " + len);
@@ -74,87 +76,34 @@
 		try {
 			return new String(string, offset, len * 2, "UTF-16LE");
 		} catch (UnsupportedEncodingException e) {
-			throw new InternalError(); /*unreachable*/
+			throw new RuntimeException(e);
 		}
 	}
 
-	/**     
+	/**
 	 *  Given a byte array of 16-bit unicode characters in little endian
 	 *  format (most important byte last), return a Java String representation
-	 *  of it. 
-	 *      
-	 * { 0x16, 0x00 } -0x16     
-	 *     
-	 *@param  string  the byte array to be converted     
-	 *@return         the converted string    
+	 *  of it.
+	 *
+	 * { 0x16, 0x00 } -0x16
+	 *
+	 * @param  string  the byte array to be converted
+	 * @return the converted string, never <code>null</code>
 	 */
-	public static String getFromUnicodeLE(final byte[] string) {
+	public static String getFromUnicodeLE(byte[] string) {
 		if(string.length == 0) { return ""; }
 		return getFromUnicodeLE(string, 0, string.length / 2);
 	}
 
-	/**     
-	 *  Given a byte array of 16-bit unicode characters in big endian
-	 *  format (most important byte first), return a Java String representation
-	 *  of it. 
-	 *      
-	 * { 0x00, 0x16 } -0x16     
-	 *     
-	 *@param  string                              the byte array to be converted     
-	 **@param  offset                              the initial offset into the     
-	 *      byte array. it is assumed that string[ offset ] and string[ offset +     
-	 *      1 ] contain the first 16-bit unicode character     
-         *@param len the length of the final string     
-	 *@return                                     the converted string     
-	 *@exception  ArrayIndexOutOfBoundsException  if offset is out of bounds for     
-	 *      the byte array (i.e., is negative or is greater than or equal to     
-	 *      string.length)     
-	 *@exception  IllegalArgumentException        if len is too large (i.e.,     
-	 *      there is not enough data in string to create a String of that     
-	 *      length)     
-	 */
-	public static String getFromUnicodeBE(
-		final byte[] string,
-		final int offset,
-		final int len)
-		throws ArrayIndexOutOfBoundsException, IllegalArgumentException {
-		if ((offset < 0) || (offset >= string.length)) {
-			throw new ArrayIndexOutOfBoundsException("Illegal offset");
-		}
-		if ((len < 0) || (((string.length - offset) / 2) < len)) {
-			throw new IllegalArgumentException("Illegal length");
-		}
-		try {
-			return new String(string, offset, len * 2, "UTF-16BE");
-		} catch (UnsupportedEncodingException e) {
-			throw new InternalError(); /*unreachable*/
-		}
-	}
-
-	/**     
-	 *  Given a byte array of 16-bit unicode characters in big endian
-	 *  format (most important byte first), return a Java String representation
-	 *  of it.
-	 *      
-	 * { 0x00, 0x16 } -0x16     
-	 *     
-	 *@param  string  the byte array to be converted     
-	 *@return         the converted string     
-	 */
-	public static String getFromUnicodeBE(final byte[] string) {
-		if(string.length == 0) { return ""; }
-		return getFromUnicodeBE(string, 0, string.length / 2);
-	}
-
-	/**      
+	/**
 	 * Read 8 bit data (in ISO-8859-1 codepage) into a (unicode) Java
 	 * String and return.
 	 * (In Excel terms, read compressed 8 bit unicode as a string)
-	 *       
-	 * @param string byte array to read      
-	 * @param offset offset to read byte array      
-	 * @param len    length to read byte array      
-	 * @return String generated String instance by reading byte array      
+	 *
+	 * @param string byte array to read
+	 * @param offset offset to read byte array
+	 * @param len    length to read byte array
+	 * @return String generated String instance by reading byte array
 	 */
 	public static String getFromCompressedUnicode(
 		final byte[] string,
@@ -162,83 +111,181 @@
 		final int len) {
 		try {
 			int len_to_use = Math.min(len, string.length - offset);
-			return new String(string, offset, len_to_use, "ISO-8859-1");
+			return new String(string, offset, len_to_use, ENCODING_ISO_8859_1);
 		} catch (UnsupportedEncodingException e) {
-			throw new InternalError(); /* unreachable */
+			throw new RuntimeException(e);
+		}
+	}
+	public static String readCompressedUnicode(LittleEndianInput in, int nChars) {
+		char[] buf = new char[nChars];
+		for (int i = 0; i < buf.length; i++) {
+			buf[i] = (char) in.readUByte();
+		}
+		return new String(buf);
+	}
+	/**
+	 * InputStream <tt>in</tt> is expected to contain:
+	 * <ol>
+	 * <li>ushort nChars</li>
+	 * <li>byte is16BitFlag</li>
+	 * <li>byte[]/char[] characterData</li>
+	 * </ol>
+	 * For this encoding, the is16BitFlag is always present even if nChars==0.
+	 * 
+	 * This structure is also known as a XLUnicodeString.
+	 */
+	public static String readUnicodeString(LittleEndianInput in) {
+
+		int nChars = in.readUShort();
+		byte flag = in.readByte();
+		if ((flag & 0x01) == 0) {
+			return readCompressedUnicode(in, nChars);
+		}
+		return readUnicodeLE(in, nChars);
+	}
+	/**
+	 * InputStream <tt>in</tt> is expected to contain:
+	 * <ol>
+	 * <li>byte is16BitFlag</li>
+	 * <li>byte[]/char[] characterData</li>
+	 * </ol>
+	 * For this encoding, the is16BitFlag is always present even if nChars==0.
+	 * <br/>
+	 * This method should be used when the nChars field is <em>not</em> stored
+	 * as a ushort immediately before the is16BitFlag. Otherwise, {@link
+	 * #readUnicodeString(LittleEndianInput)} can be used.
+	 */
+	public static String readUnicodeString(LittleEndianInput in, int nChars) {
+		byte is16Bit = in.readByte();
+		if ((is16Bit & 0x01) == 0) {
+			return readCompressedUnicode(in, nChars);
+		}
+		return readUnicodeLE(in, nChars);
+	}
+	/**
+	 * OutputStream <tt>out</tt> will get:
+	 * <ol>
+	 * <li>ushort nChars</li>
+	 * <li>byte is16BitFlag</li>
+	 * <li>byte[]/char[] characterData</li>
+	 * </ol>
+	 * For this encoding, the is16BitFlag is always present even if nChars==0.
+	 */
+	public static void writeUnicodeString(LittleEndianOutput out, String value) {
+
+		int nChars = value.length();
+		out.writeShort(nChars);
+		boolean is16Bit = hasMultibyte(value);
+		out.writeByte(is16Bit ? 0x01 : 0x00);
+		if (is16Bit) {
+			putUnicodeLE(value, out);
+		} else {
+			putCompressedUnicode(value, out);
+		}
+	}
+	/**
+	 * OutputStream <tt>out</tt> will get:
+	 * <ol>
+	 * <li>byte is16BitFlag</li>
+	 * <li>byte[]/char[] characterData</li>
+	 * </ol>
+	 * For this encoding, the is16BitFlag is always present even if nChars==0.
+	 * <br/>
+	 * This method should be used when the nChars field is <em>not</em> stored
+	 * as a ushort immediately before the is16BitFlag. Otherwise, {@link
+	 * #writeUnicodeString(LittleEndianOutput, String)} can be used.
+	 */
+	public static void writeUnicodeStringFlagAndData(LittleEndianOutput out, String value) {
+		boolean is16Bit = hasMultibyte(value);
+		out.writeByte(is16Bit ? 0x01 : 0x00);
+		if (is16Bit) {
+			putUnicodeLE(value, out);
+		} else {
+			putCompressedUnicode(value, out);
 		}
 	}
 
-	/**      
-	 * Takes a unicode (java) string, and returns it as 8 bit data (in ISO-8859-1 
+	/**
+	 * @return the number of bytes that would be written by {@link #writeUnicodeString(LittleEndianOutput, String)}
+	 */
+	public static int getEncodedSize(String value) {
+		int result = 2 + 1;
+		result += value.length() * (StringUtil.hasMultibyte(value) ? 2 : 1);
+		return result;
+	}
+
+	/**
+	 * Takes a unicode (java) string, and returns it as 8 bit data (in ISO-8859-1
 	 * codepage).
 	 * (In Excel terms, write compressed 8 bit unicode)
-	 *     
-	 *@param  input   the String containing the data to be written     
-	 *@param  output  the byte array to which the data is to be written     
-	 *@param  offset  an offset into the byte arrat at which the data is start     
-	 *      when written     
+	 *
+	 * @param  input   the String containing the data to be written
+	 * @param  output  the byte array to which the data is to be written
+	 * @param  offset  an offset into the byte arrat at which the data is start
+	 *      when written
 	 */
-	public static void putCompressedUnicode(
-		final String input,
-		final byte[] output,
-		final int offset) {
+	public static void putCompressedUnicode(String input, byte[] output, int offset) {
+		byte[] bytes;
 		try {
-			byte[] bytes = input.getBytes("ISO-8859-1");
-			System.arraycopy(bytes, 0, output, offset, bytes.length);
+			bytes = input.getBytes(ENCODING_ISO_8859_1);
 		} catch (UnsupportedEncodingException e) {
-			throw new InternalError(); /*unreachable*/
+			throw new RuntimeException(e);
 		}
+		System.arraycopy(bytes, 0, output, offset, bytes.length);
+	}
+	public static void putCompressedUnicode(String input, LittleEndianOutput out) {
+		byte[] bytes;
+		try {
+			bytes = input.getBytes(ENCODING_ISO_8859_1);
+		} catch (UnsupportedEncodingException e) {
+			throw new RuntimeException(e);
+		}
+		out.write(bytes);
 	}
 
-	/**     
-	 * Takes a unicode string, and returns it as little endian (most 
+	/**
+	 * Takes a unicode string, and returns it as little endian (most
 	 * important byte last) bytes in the supplied byte array.
 	 * (In Excel terms, write uncompressed unicode)
-	 *     
-	 *@param  input   the String containing the unicode data to be written     
-	 *@param  output  the byte array to hold the uncompressed unicode, should be twice the length of the String
-	 *@param  offset  the offset to start writing into the byte array     
+	 *
+	 * @param  input   the String containing the unicode data to be written
+	 * @param  output  the byte array to hold the uncompressed unicode, should be twice the length of the String
+	 * @param  offset  the offset to start writing into the byte array
 	 */
-	public static void putUnicodeLE(
-		final String input,
-		final byte[] output,
-		final int offset) {
+	public static void putUnicodeLE(String input, byte[] output, int offset) {
+		byte[] bytes;
 		try {
-			byte[] bytes = input.getBytes("UTF-16LE");
-			System.arraycopy(bytes, 0, output, offset, bytes.length);
+			bytes = input.getBytes("UTF-16LE");
 		} catch (UnsupportedEncodingException e) {
-			throw new InternalError(); /*unreachable*/
+			throw new RuntimeException(e);
 		}
+		System.arraycopy(bytes, 0, output, offset, bytes.length);
+	}
+	public static void putUnicodeLE(String input, LittleEndianOutput out) {
+		byte[] bytes;
+		try {
+			bytes = input.getBytes("UTF-16LE");
+		} catch (UnsupportedEncodingException e) {
+			throw new RuntimeException(e);
+		}
+		out.write(bytes);
 	}
 
-	/**     
-	 * Takes a unicode string, and returns it as big endian (most 
-	 * important byte first) bytes in the supplied byte array.
-	 * (In Excel terms, write uncompressed unicode)
-	 *     
-	 *@param  input   the String containing the unicode data to be written     
-	 *@param  output  the byte array to hold the uncompressed unicode, should be twice the length of the String
-	 *@param  offset  the offset to start writing into the byte array     
-	 */
-	public static void putUnicodeBE(
-		final String input,
-		final byte[] output,
-		final int offset) {
-		try {
-			byte[] bytes = input.getBytes("UTF-16BE");
-			System.arraycopy(bytes, 0, output, offset, bytes.length);
-		} catch (UnsupportedEncodingException e) {
-			throw new InternalError(); /*unreachable*/
+	public static String readUnicodeLE(LittleEndianInput in, int nChars) {
+		char[] buf = new char[nChars];
+		for (int i = 0; i < buf.length; i++) {
+			buf[i] = (char) in.readUShort();
 		}
+		return new String(buf);
 	}
 
-	/**     
-	 *  Apply printf() like formatting to a string.      
-	 *  Primarily used for logging.    
-	 *@param  message  the string with embedded formatting info 
-	 *                 eg. "This is a test %2.2"     
-	 *@param  params   array of values to format into the string     
-	 *@return          The formatted string     
+	/**
+	 *  Apply printf() like formatting to a string.
+	 *  Primarily used for logging.
+	 * @param  message  the string with embedded formatting info
+	 *                 eg. "This is a test %2.2"
+	 * @param  params   array of values to format into the string
+	 * @return          The formatted string
 	 */
 	public static String format(String message, Object[] params) {
 		int currentParamNumber = 0;
@@ -307,39 +354,69 @@
 		return 1;
 	}
 
-	/**     
-	 * @return the encoding we want to use, currently hardcoded to ISO-8859-1     
+	/**
+	 * @return the encoding we want to use, currently hardcoded to ISO-8859-1
 	 */
 	public static String getPreferredEncoding() {
-		return ENCODING;
+		return ENCODING_ISO_8859_1;
 	}
 
 	/**
 	 * check the parameter has multibyte character
 	 *
-	 * @param value  string to check
-	 * @return  boolean result
-	 *  true:string has at least one multibyte character
+	 * @param value string to check
+	 * @return boolean result true:string has at least one multibyte character
 	 */
-	public static boolean hasMultibyte(String value){
-	    if( value == null )return false;
-	    for(int i = 0 ; i < value.length() ; i++ ){
-	        char c = value.charAt(i);
-	        if(c > 0xFF )return true;
-	    }
-	    return false;
+	public static boolean hasMultibyte(String value) {
+		if (value == null)
+			return false;
+		for (int i = 0; i < value.length(); i++) {
+			char c = value.charAt(i);
+			if (c > 0xFF) {
+				return true;
+			}
+		}
+		return false;
 	}
-	
+
 	/**
 	 * Checks to see if a given String needs to be represented as Unicode
-	 * @param value 
+	 *
+	 * @param value
 	 * @return true if string needs Unicode to be represented.
 	 */
-	  public static boolean isUnicodeString(final String value) {
-	    try {
-	      return !value.equals(new String(value.getBytes("ISO-8859-1"), "ISO-8859-1"));
-	    } catch (UnsupportedEncodingException e) {
-	      return true;
-	    }
-	  }
+	public static boolean isUnicodeString(final String value) {
+		try {
+			return !value.equals(new String(value.getBytes(ENCODING_ISO_8859_1),
+					ENCODING_ISO_8859_1));
+		} catch (UnsupportedEncodingException e) {
+			return true;
+		}
+	}
+	
+   /**
+    * An Iterator over an array of Strings.
+    */
+   public static class StringsIterator implements Iterator<String> {
+      private String[] strings;
+      private int position = 0;
+      public StringsIterator(String[] strings) {
+         if(strings != null) {
+            this.strings = strings;
+         } else {
+            this.strings = new String[0];
+         }
+      }
+
+      public boolean hasNext() {
+         return position < strings.length;
+      }
+      public String next() {
+         int ourPos = position++;
+         if(ourPos >= strings.length)
+            throw new ArrayIndexOutOfBoundsException(ourPos);
+         return strings[ourPos];
+      }
+      public void remove() {}
+   }
 }
diff --git a/src/java/org/apache/poi/util/SystemOutLogger.java b/src/java/org/apache/poi/util/SystemOutLogger.java
index af678e1..bf88036 100644
--- a/src/java/org/apache/poi/util/SystemOutLogger.java
+++ b/src/java/org/apache/poi/util/SystemOutLogger.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +14,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
@@ -33,11 +31,11 @@
  */
 public class SystemOutLogger extends POILogger
 {
-    private String cat;
+    private String _cat;
 
     public void initialize(final String cat)
     {
-       this.cat=cat;
+       this._cat=cat;
     }
 
     /**
@@ -51,7 +49,7 @@
     {
     	log(level, obj1, null);
     }
-    
+
     /**
      * Log a message
      *
@@ -62,7 +60,7 @@
     public void log(final int level, final Object obj1,
                     final Throwable exception) {
         if (check(level)) {
-            System.out.println("["+cat+"] "+obj1);
+            System.out.println("["+_cat+"] "+obj1);
             if(exception != null) {
             	exception.printStackTrace(System.out);
             }
@@ -88,10 +86,10 @@
             currentLevel = POILogger.DEBUG;
         }
 
-        if (level >= currentLevel)
+        if (level >= currentLevel) {
             return true;
-        else
-            return false;
+        }
+        return false;
     }
 
 
diff --git a/src/java/org/apache/poi/util/TempFile.java b/src/java/org/apache/poi/util/TempFile.java
index 751847c..d9489fb 100644
--- a/src/java/org/apache/poi/util/TempFile.java
+++ b/src/java/org/apache/poi/util/TempFile.java
@@ -14,10 +14,10 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
+
 package org.apache.poi.util;
 
 import java.io.File;
-import java.io.IOException;
 import java.util.Random;
 
 /**
@@ -25,20 +25,18 @@
  *
  * @author Glen Stampoultzis
  */
-public class TempFile
-{
-    static File dir;
-    static Random rnd = new Random();
+public final class TempFile {
+    private static File dir;
+    private static final Random rnd = new Random();
 
     /**
      * Creates a temporary file.  Files are collected into one directory and by default are
      * deleted on exit from the VM.  Files can be kept by defining the system property
      * <code>poi.keep.tmp.files</code>.
      * <p>
-     * Dont forget to close all files or it might not be possible to delete them.
+     * Don't forget to close all files or it might not be possible to delete them.
      */
-    public static File createTempFile(String prefix, String suffix) throws IOException
-    {
+    public static File createTempFile(String prefix, String suffix) {
         if (dir == null)
         {
             dir = new File(System.getProperty("java.io.tmpdir"), "poifiles");
@@ -52,7 +50,4 @@
             newFile.deleteOnExit();
         return newFile;
     }
-
-
-
 }
diff --git a/src/scratchpad/src/org/apache/poi/hslf/HSLFSlideShow.java b/src/scratchpad/src/org/apache/poi/hslf/HSLFSlideShow.java
index 217ab7b..c024b47 100644
--- a/src/scratchpad/src/org/apache/poi/hslf/HSLFSlideShow.java
+++ b/src/scratchpad/src/org/apache/poi/hslf/HSLFSlideShow.java
@@ -76,7 +76,7 @@
 	 *  that is open.
 	 */
 	protected POIFSFileSystem getPOIFSFileSystem() {
-		return filesystem;
+		return directory.getFileSystem();
 	}
 
 	/**
@@ -467,7 +467,7 @@
         
         // If requested, write out any other streams we spot
         if(preserveNodes) {
-        	copyNodes(filesystem, outFS, writtenEntries);
+        	copyNodes(directory.getFileSystem(), outFS, writtenEntries);
         }
 
         // Send the POIFSFileSystem object out to the underlying stream
diff --git a/src/scratchpad/src/org/apache/poi/hwpf/HWPFDocument.java b/src/scratchpad/src/org/apache/poi/hwpf/HWPFDocument.java
index f1898c0..4186071 100644
--- a/src/scratchpad/src/org/apache/poi/hwpf/HWPFDocument.java
+++ b/src/scratchpad/src/org/apache/poi/hwpf/HWPFDocument.java
@@ -215,7 +215,7 @@
       DocumentEntry dataProps =
           (DocumentEntry)directory.getEntry("Data");
       _dataStream = new byte[dataProps.getSize()];
-      filesystem.createDocumentInputStream("Data").read(_dataStream);
+      directory.createDocumentInputStream("Data").read(_dataStream);
     }
     catch(java.io.FileNotFoundException e)
     {
diff --git a/src/scratchpad/testcases/org/apache/poi/TestPOIDocumentScratchpad.java b/src/scratchpad/testcases/org/apache/poi/TestPOIDocumentScratchpad.java
index 520409f..8629fa8 100644
--- a/src/scratchpad/testcases/org/apache/poi/TestPOIDocumentScratchpad.java
+++ b/src/scratchpad/testcases/org/apache/poi/TestPOIDocumentScratchpad.java
@@ -113,7 +113,7 @@
     	POIFSFileSystem inFS = new POIFSFileSystem(bais);
     	
     	// Check they're still there
-    	doc.filesystem = inFS;
+    	doc.directory = inFS.getRoot();
     	doc.readProperties();
     	
     	// Delegate test
diff --git a/src/testcases/org/apache/poi/POIDataSamples.java b/src/testcases/org/apache/poi/POIDataSamples.java
new file mode 100644
index 0000000..4bac559
--- /dev/null
+++ b/src/testcases/org/apache/poi/POIDataSamples.java
@@ -0,0 +1,245 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+package org.apache.poi;
+
+import java.io.*;
+
+/**
+ * Centralises logic for finding/opening sample files
+ */
+public final class POIDataSamples {
+
+    private static POIDataSamples _instSlideshow;
+    private static POIDataSamples _instSpreadsheet;
+    private static POIDataSamples _instDocument;
+    private static POIDataSamples _instDiagram;
+    private static POIDataSamples _instOpenxml4j;
+    private static POIDataSamples _instPOIFS;
+    private static POIDataSamples _instDDF;
+    private static POIDataSamples _instHPSF;
+    private static POIDataSamples _instHPBF;
+    private static POIDataSamples _instHSMF;
+
+    private File _resolvedDataDir;
+    /** <code>true</code> if standard system propery is not set,
+     * but the data is available on the test runtime classpath */
+    private boolean _sampleDataIsAvaliableOnClassPath;
+    private String _moduleName;
+
+    /**
+     *
+     * @param moduleDir   the name of the directory containing the test files
+     */
+    private POIDataSamples(String moduleName){
+        _moduleName = moduleName;
+        initialise();
+    }
+
+    public static POIDataSamples getSpreadSheetInstance(){
+        if(_instSpreadsheet == null) _instSpreadsheet = new POIDataSamples("HSSF");
+        return _instSpreadsheet;
+    }
+
+    public static POIDataSamples getDocumentInstance(){
+        if(_instDocument == null) _instDocument = new POIDataSamples("HWPF");
+        return _instDocument;
+    }
+
+    public static POIDataSamples getSlideShowInstance(){
+        if(_instSlideshow == null) _instSlideshow = new POIDataSamples("slideshow");
+        return _instSlideshow;
+    }
+
+    public static POIDataSamples getDiagramInstance(){
+        if(_instOpenxml4j == null) _instOpenxml4j = new POIDataSamples("diagram");
+        return _instOpenxml4j;
+    }
+
+    public static POIDataSamples getOpenXML4JInstance(){
+        if(_instDiagram == null) _instDiagram = new POIDataSamples("openxml4j");
+        return _instDiagram;
+    }
+
+    public static POIDataSamples getPOIFSInstance(){
+        if(_instPOIFS == null) _instPOIFS = new POIDataSamples("POIFS");
+        return _instPOIFS;
+    }
+
+    public static POIDataSamples getDDFInstance(){
+        if(_instDDF == null) _instDDF = new POIDataSamples("ddf");
+        return _instDDF;
+    }
+
+    public static POIDataSamples getHPSFInstance(){
+        if(_instHPSF == null) _instHPSF = new POIDataSamples("hpsf");
+        return _instHPSF;
+    }
+
+    public static POIDataSamples getPublisherInstance(){
+        if(_instHPBF == null) _instHPBF = new POIDataSamples("publisher");
+        return _instHPBF;
+    }
+
+    public static POIDataSamples getHSMFInstance(){
+        if(_instHSMF == null) _instHSMF = new POIDataSamples("hsmf");
+        return _instHSMF;
+    }
+    /**
+     * Opens a sample file from the test data directory
+     *
+     * @param  sampleFileName the file to open
+     * @return an open <tt>InputStream</tt> for the specified sample file
+     */
+    public InputStream openResourceAsStream(String sampleFileName) {
+
+        if (_sampleDataIsAvaliableOnClassPath) {
+            InputStream result = sampleFileName == null ? null :
+                    openClasspathResource(sampleFileName);
+            if(result == null) {
+                throw new RuntimeException("specified test sample file '" + sampleFileName
+                        + "' not found on the classpath");
+            }
+            // wrap to avoid temp warning method about auto-closing input stream
+            return new NonSeekableInputStream(result);
+        }
+        if (_resolvedDataDir == null) {
+            throw new RuntimeException("Must set system property for '"
+                    + _moduleName
+                    + "' properly before running tests");
+        }
+
+        File f = getFile(sampleFileName);
+        try {
+            return new FileInputStream(f);
+        } catch (FileNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     *
+     * @param sampleFileName    the name of the test file
+     * @return
+     * @throws RuntimeException if the file was not found
+     */
+    public File getFile(String sampleFileName) {
+        File f = new File(_resolvedDataDir, sampleFileName);
+        if (!f.exists()) {
+            throw new RuntimeException("Sample file '" + sampleFileName
+                    + "' not found in data dir '" + _resolvedDataDir.getAbsolutePath() + "'");
+        }
+        try {
+            if(sampleFileName.length() > 0 && !sampleFileName.equals(f.getCanonicalFile().getName())){
+                throw new RuntimeException("File name is case-sensitive: requested '" + sampleFileName
+                        + "' but actual file is '" + f.getCanonicalFile().getName() + "'");
+            }
+        } catch (IOException e){
+            throw new RuntimeException(e);
+        }
+        return f;
+    }
+
+    private void initialise() {
+        String TEST_PROPERTY = _moduleName+".testdata.path";
+        String dataDirName = System.getProperty(TEST_PROPERTY);
+        if (dataDirName == null) {
+            // check to see if we can just get the resources from the classpath
+            InputStream is = openClasspathResource("");
+            if (is != null) {
+                try {
+                    is.close(); // be nice
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                _sampleDataIsAvaliableOnClassPath = true;
+                return;
+            }
+
+            throw new RuntimeException("Must set system property '" +
+                    TEST_PROPERTY + "' before running tests");
+        }
+        File dataDir = new File(dataDirName);
+        if (!dataDir.exists()) {
+            throw new RuntimeException("Data dir '" + _moduleName + " does not exist");
+        }
+        // convert to canonical file, to make any subsequent error messages
+        // clearer.
+        try {
+            _resolvedDataDir = dataDir.getCanonicalFile();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Opens a test sample file from the 'data' sub-package of this class's package.
+     *
+     * @param  sampleFileName the file to open
+     * @return <code>null</code> if the sample file is not deployed on the classpath.
+     */
+    private InputStream openClasspathResource(String sampleFileName) {
+        return getClass().getResourceAsStream("/" + sampleFileName);
+    }
+
+    private static final class NonSeekableInputStream extends InputStream {
+
+        private final InputStream _is;
+
+        public NonSeekableInputStream(InputStream is) {
+            _is = is;
+        }
+
+        public int read() throws IOException {
+            return _is.read();
+        }
+        public int read(byte[] b, int off, int len) throws IOException {
+            return _is.read(b, off, len);
+        }
+        public boolean markSupported() {
+            return false;
+        }
+        public void close() throws IOException {
+            _is.close();
+        }
+    }
+
+    /**
+     * @param  fileName the file to open
+     * @return byte array of sample file content from file found in standard hssf test data dir
+     */
+    public byte[] readFile(String fileName) {
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+
+        try {
+            InputStream fis = openResourceAsStream(fileName);
+
+            byte[] buf = new byte[512];
+            while (true) {
+                int bytesRead = fis.read(buf);
+                if (bytesRead < 1) {
+                    break;
+                }
+                bos.write(buf, 0, bytesRead);
+            }
+            fis.close();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        return bos.toByteArray();
+    }
+
+}
diff --git a/src/testcases/org/apache/poi/TestPOIDocumentMain.java b/src/testcases/org/apache/poi/TestPOIDocumentMain.java
index 2e877ac..ef4d891 100644
--- a/src/testcases/org/apache/poi/TestPOIDocumentMain.java
+++ b/src/testcases/org/apache/poi/TestPOIDocumentMain.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -21,16 +20,18 @@
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 
 import junit.framework.TestCase;
 
 import org.apache.poi.hssf.HSSFTestDataSamples;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.poifs.filesystem.POIFSFileSystem;
 
 /**
  * Tests that POIDocument correctly loads and saves the common
  *  (hspf) Document Properties.
- * 
+ *
  * This is part 1 of 2 of the tests - it only does the POIDocuments
  *  which are part of the Main (not scratchpad)
  *
@@ -45,26 +46,26 @@
 	 * Set things up, two spreadsheets for our testing
 	 */
 	public void setUp() {
-		
+
 		doc = HSSFTestDataSamples.openSampleWorkbook("DateFormats.xls");
 		doc2 = HSSFTestDataSamples.openSampleWorkbook("StringFormulas.xls");
 	}
-	
-	public void testReadProperties() throws Exception {
+
+	public void testReadProperties() {
 		// We should have both sets
 		assertNotNull(doc.getDocumentSummaryInformation());
 		assertNotNull(doc.getSummaryInformation());
-		
+
 		// Check they are as expected for the test doc
 		assertEquals("Administrator", doc.getSummaryInformation().getAuthor());
 		assertEquals(0, doc.getDocumentSummaryInformation().getByteCount());
 	}
-		
-	public void testReadProperties2() throws Exception {	
+
+	public void testReadProperties2() {
 		// Check again on the word one
 		assertNotNull(doc2.getDocumentSummaryInformation());
 		assertNotNull(doc2.getSummaryInformation());
-		
+
 		assertEquals("Avik Sengupta", doc2.getSummaryInformation().getAuthor());
 		assertEquals(null, doc2.getSummaryInformation().getKeywords());
 		assertEquals(0, doc2.getDocumentSummaryInformation().getByteCount());
@@ -75,7 +76,7 @@
 		POIFSFileSystem outFS = new POIFSFileSystem();
 		doc.readProperties();
 		doc.writeProperties(outFS);
-		
+
 		// Should now hold them
 		assertNotNull(
 				outFS.createDocumentInputStream("\005SummaryInformation")
@@ -87,22 +88,86 @@
 
 	public void testWriteReadProperties() throws Exception {
 		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		
+
 		// Write them out
 		POIFSFileSystem outFS = new POIFSFileSystem();
 		doc.readProperties();
 		doc.writeProperties(outFS);
 		outFS.writeFilesystem(baos);
-		
+
 		// Create a new version
 		ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
 		POIFSFileSystem inFS = new POIFSFileSystem(bais);
-		
+
 		// Check they're still there
-		doc.filesystem = inFS;
+		doc.directory = inFS.getRoot();
 		doc.readProperties();
-		
+
 		// Delegate test
 		testReadProperties();
 	}
+	
+	public void testCreateNewProperties() throws IOException {
+		POIDocument doc = new HSSFWorkbook();
+		
+		// New document won't have them
+		assertNull(doc.getSummaryInformation());
+		assertNull(doc.getDocumentSummaryInformation());
+		
+		// Add them in
+		doc.createInformationProperties();
+		assertNotNull(doc.getSummaryInformation());
+		assertNotNull(doc.getDocumentSummaryInformation());
+
+		// Write out and back in again, no change
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		doc.write(baos);
+		ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+
+		doc = new HSSFWorkbook(bais);
+		
+		assertNotNull(doc.getSummaryInformation());
+		assertNotNull(doc.getDocumentSummaryInformation());
+	}
+	
+	public void testCreateNewPropertiesOnExistingFile() throws IOException {
+		POIDocument doc = new HSSFWorkbook();
+		
+		// New document won't have them
+		assertNull(doc.getSummaryInformation());
+		assertNull(doc.getDocumentSummaryInformation());
+
+		// Write out and back in again, no change
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		doc.write(baos);
+		ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+		doc = new HSSFWorkbook(bais);
+		
+		assertNull(doc.getSummaryInformation());
+		assertNull(doc.getDocumentSummaryInformation());
+		
+		// Create, and change
+		doc.createInformationProperties();
+		doc.getSummaryInformation().setAuthor("POI Testing");
+		doc.getDocumentSummaryInformation().setCompany("ASF");
+		
+		// Save and re-load
+		baos = new ByteArrayOutputStream();
+		doc.write(baos);
+		bais = new ByteArrayInputStream(baos.toByteArray());
+		doc = new HSSFWorkbook(bais);
+		
+		// Check
+		assertNotNull(doc.getSummaryInformation());
+		assertNotNull(doc.getDocumentSummaryInformation());
+		assertEquals("POI Testing", doc.getSummaryInformation().getAuthor());
+		assertEquals("ASF", doc.getDocumentSummaryInformation().getCompany());
+		
+		// Asking to re-create will make no difference now
+		doc.createInformationProperties();
+		assertNotNull(doc.getSummaryInformation());
+		assertNotNull(doc.getDocumentSummaryInformation());
+		assertEquals("POI Testing", doc.getSummaryInformation().getAuthor());
+		assertEquals("ASF", doc.getDocumentSummaryInformation().getCompany());
+	}
 }
diff --git a/src/testcases/org/apache/poi/poifs/data/BlockSize4096.zvi b/src/testcases/org/apache/poi/poifs/data/BlockSize4096.zvi
new file mode 100644
index 0000000..6379a04
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/data/BlockSize4096.zvi
Binary files differ
diff --git a/src/testcases/org/apache/poi/poifs/data/BlockSize512.zvi b/src/testcases/org/apache/poi/poifs/data/BlockSize512.zvi
new file mode 100644
index 0000000..3a6be2f
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/data/BlockSize512.zvi
Binary files differ
diff --git a/src/testcases/org/apache/poi/poifs/data/Notes.ole2 b/src/testcases/org/apache/poi/poifs/data/Notes.ole2
new file mode 100644
index 0000000..9aaed99
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/data/Notes.ole2
Binary files differ
diff --git a/src/testcases/org/apache/poi/poifs/data/ReferencesInvalidSectors.mpp b/src/testcases/org/apache/poi/poifs/data/ReferencesInvalidSectors.mpp
new file mode 100644
index 0000000..583a0a1
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/data/ReferencesInvalidSectors.mpp
Binary files differ
diff --git a/src/testcases/org/apache/poi/poifs/data/oleObject1.bin b/src/testcases/org/apache/poi/poifs/data/oleObject1.bin
new file mode 100644
index 0000000..fc46302
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/data/oleObject1.bin
Binary files differ
diff --git a/src/testcases/org/apache/poi/poifs/data/protect.xlsx b/src/testcases/org/apache/poi/poifs/data/protect.xlsx
new file mode 100644
index 0000000..1767b14
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/data/protect.xlsx
Binary files differ
diff --git a/src/testcases/org/apache/poi/poifs/eventfilesystem/TestPOIFSReaderRegistry.java b/src/testcases/org/apache/poi/poifs/eventfilesystem/TestPOIFSReaderRegistry.java
index c045391..858032e 100644
--- a/src/testcases/org/apache/poi/poifs/eventfilesystem/TestPOIFSReaderRegistry.java
+++ b/src/testcases/org/apache/poi/poifs/eventfilesystem/TestPOIFSReaderRegistry.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,13 +14,14 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.eventfilesystem;
 
-import junit.framework.*;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
 
-import java.util.*;
+import junit.framework.TestCase;
 
 import org.apache.poi.poifs.filesystem.POIFSDocumentPath;
 
@@ -30,10 +30,7 @@
  *
  * @author Marc Johnson
  */
-
-public class TestPOIFSReaderRegistry
-    extends TestCase
-{
+public final class TestPOIFSReaderRegistry extends TestCase {
     private POIFSReaderListener[] listeners =
     {
         new Listener(), new Listener(), new Listener(), new Listener()
@@ -57,22 +54,9 @@
     };
 
     /**
-     * Constructor TestPOIFSReaderRegistry
-     *
-     * @param name
-     */
-
-    public TestPOIFSReaderRegistry(String name)
-    {
-        super(name);
-    }
-
-    /**
      * Test empty registry
      */
-
-    public void testEmptyRegistry()
-    {
+    public void testEmptyRegistry() {
         POIFSReaderRegistry registry = new POIFSReaderRegistry();
 
         for (int j = 0; j < paths.length; j++)
@@ -90,9 +74,7 @@
     /**
      * Test mixed registration operations
      */
-
-    public void testMixedRegistrationOperations()
-    {
+    public void testMixedRegistrationOperations() {
         POIFSReaderRegistry registry = new POIFSReaderRegistry();
 
         for (int j = 0; j < listeners.length; j++)
@@ -172,17 +154,4 @@
             }
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.eventfilesystem.POIFSReaderRegistry");
-        junit.textui.TestRunner.run(TestPOIFSReaderRegistry.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/AllPOIFSFileSystemTests.java b/src/testcases/org/apache/poi/poifs/filesystem/AllPOIFSFileSystemTests.java
index 2a0319a..bc46e17 100755
--- a/src/testcases/org/apache/poi/poifs/filesystem/AllPOIFSFileSystemTests.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/AllPOIFSFileSystemTests.java
@@ -22,7 +22,7 @@
 
 /**
  * Tests for org.apache.poi.poifs.filesystem<br/>
- * 
+ *
  * @author Josh Micich
  */
 public final class AllPOIFSFileSystemTests {
@@ -38,7 +38,10 @@
         result.addTestSuite(TestEmptyDocument.class);
         result.addTestSuite(TestOffice2007XMLException.class);
         result.addTestSuite(TestPOIFSDocumentPath.class);
+        result.addTestSuite(TestPOIFSFileSystem.class);
+        result.addTestSuite(TestNPOIFSFileSystem.class);
         result.addTestSuite(TestPropertySorter.class);
+        result.addTestSuite(TestOle10Native.class);
         return result;
     }
 }
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestDirectoryNode.java b/src/testcases/org/apache/poi/poifs/filesystem/TestDirectoryNode.java
index 8af6033..78e6bee 100644
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestDirectoryNode.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestDirectoryNode.java
@@ -15,7 +15,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.filesystem;
 
@@ -33,31 +32,12 @@
  *
  * @author Marc Johnson
  */
-
-public class TestDirectoryNode
-    extends TestCase
-{
-
-    /**
-     * Constructor TestDirectoryNode
-     *
-     * @param name
-     */
-
-    public TestDirectoryNode(String name)
-    {
-        super(name);
-    }
+public final class TestDirectoryNode extends TestCase {
 
     /**
      * test trivial constructor (a DirectoryNode with no children)
-     *
-     * @exception IOException
      */
-
-    public void testEmptyConstructor()
-        throws IOException
-    {
+    public void testEmptyConstructor() {
         POIFSFileSystem   fs        = new POIFSFileSystem();
         DirectoryProperty property1 = new DirectoryProperty("parent");
         DirectoryProperty property2 = new DirectoryProperty("child");
@@ -113,13 +93,8 @@
 
     /**
      * test non-trivial constructor (a DirectoryNode with children)
-     *
-     * @exception IOException
      */
-
-    public void testNonEmptyConstructor()
-        throws IOException
-    {
+    public void testNonEmptyConstructor() throws IOException {
         DirectoryProperty property1 = new DirectoryProperty("parent");
         DirectoryProperty property2 = new DirectoryProperty("child1");
 
@@ -177,49 +152,49 @@
 
     /**
      * test deletion methods
-     *
-     * @exception IOException
      */
-
-    public void testDeletion()
-        throws IOException
-    {
+    public void testDeletion() throws IOException {
         POIFSFileSystem fs   = new POIFSFileSystem();
         DirectoryEntry  root = fs.getRoot();
 
         // verify cannot delete the root directory
-        assertTrue(!root.delete());
+        assertFalse(root.delete());
+        assertTrue(root.isEmpty());
+        
         DirectoryEntry dir = fs.createDirectory("myDir");
 
-        assertTrue(!root.isEmpty());
+        assertFalse(root.isEmpty());
+        assertTrue(dir.isEmpty());
 
         // verify can delete empty directory
+        assertFalse(root.delete());
         assertTrue(dir.delete());
+        
+        // Now look at a non-empty one
         dir = fs.createDirectory("NextDir");
         DocumentEntry doc =
             dir.createDocument("foo",
                                new ByteArrayInputStream(new byte[ 1 ]));
 
-        assertTrue(!dir.isEmpty());
+        assertFalse(root.isEmpty());
+        assertFalse(dir.isEmpty());
 
-        // verify cannot delete empty directory
-        assertTrue(!dir.delete());
+        // verify cannot delete non-empty directory
+        assertFalse(dir.delete());
+        
+        // but we can delete it if we remove the document
         assertTrue(doc.delete());
-
-        // verify now we can delete it
+        assertTrue(dir.isEmpty());
         assertTrue(dir.delete());
+        
+        // It's really gone!
         assertTrue(root.isEmpty());
     }
 
     /**
      * test change name methods
-     *
-     * @exception IOException
      */
-
-    public void testRename()
-        throws IOException
-    {
+    public void testRename() throws IOException {
         POIFSFileSystem fs   = new POIFSFileSystem();
         DirectoryEntry  root = fs.getRoot();
 
@@ -237,17 +212,4 @@
         assertTrue(dir2.renameTo("foo"));
         assertEquals("foo", dir2.getName());
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.filesystem.DirectoryNode");
-        junit.textui.TestRunner.run(TestDirectoryNode.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestDocument.java b/src/testcases/org/apache/poi/poifs/filesystem/TestDocument.java
index 82dabc7..e216ed9 100644
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestDocument.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestDocument.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,18 +14,15 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.filesystem;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 
-import java.util.*;
+import junit.framework.TestCase;
 
-import junit.framework.*;
-
-import org.apache.poi.util.LittleEndian;
-import org.apache.poi.util.LittleEndianConsts;
 import org.apache.poi.poifs.property.DocumentProperty;
 import org.apache.poi.poifs.storage.RawDataBlock;
 import org.apache.poi.poifs.storage.SmallDocumentBlock;
@@ -36,31 +32,12 @@
  *
  * @author Marc Johnson
  */
-
-public class TestDocument
-    extends TestCase
-{
-
-    /**
-     * Constructor TestDocument
-     *
-     * @param name
-     */
-
-    public TestDocument(String name)
-    {
-        super(name);
-    }
+public final class TestDocument extends TestCase {
 
     /**
      * Integration test -- really about all we can do
-     *
-     * @exception IOException
      */
-
-    public void testPOIFSDocument()
-        throws IOException
-    {
+    public void testPOIFSDocument() throws IOException {
 
         // verify correct number of blocks get created for document
         // that is exact multituple of block size
@@ -158,10 +135,8 @@
         }
     }
 
-    private POIFSDocument makeCopy(POIFSDocument document, byte [] input,
-                                   byte [] data)
-        throws IOException
-    {
+    private static POIFSDocument makeCopy(POIFSDocument document, byte[] input, byte[] data)
+            throws IOException {
         POIFSDocument copy = null;
 
         if (input.length >= 4096)
@@ -194,10 +169,8 @@
         return copy;
     }
 
-    private void checkDocument(final POIFSDocument document,
-                               final byte [] input)
-        throws IOException
-    {
+    private static void checkDocument(final POIFSDocument document, final byte[] input)
+            throws IOException {
         int big_blocks   = 0;
         int small_blocks = 0;
         int total_output = 0;
@@ -221,11 +194,8 @@
                 input)), input);
     }
 
-    private byte [] checkValues(int big_blocks, int small_blocks,
-                                int total_output, POIFSDocument document,
-                                byte [] input)
-        throws IOException
-    {
+    private static byte[] checkValues(int big_blocks, int small_blocks, int total_output,
+            POIFSDocument document, byte[] input) throws IOException {
         assertEquals(document, document.getDocumentProperty().getDocument());
         int increment = ( int ) Math.sqrt(input.length);
 
@@ -267,17 +237,4 @@
         }
         return output;
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.filesystem.POIFSDocument");
-        junit.textui.TestRunner.run(TestDocument.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentDescriptor.java b/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentDescriptor.java
index 7272e42..9b69b1a 100644
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentDescriptor.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentDescriptor.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,53 +14,30 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.filesystem;
 
-import junit.framework.*;
+import junit.framework.TestCase;
 
 /**
  * Class to test DocumentDescriptor functionality
  *
  * @author Marc Johnson
  */
-
-public class TestDocumentDescriptor
-    extends TestCase
-{
-
-    /**
-     * Constructor TestDocumentDescriptor
-     *
-     * @param name
-     */
-
-    public TestDocumentDescriptor(String name)
-    {
-        super(name);
-    }
+public final class TestDocumentDescriptor extends TestCase {
 
     /**
      * test equality
      */
-
-    public void testEquality()
-    {
-        String[]            names =
-        {
-            "c1", "c2", "c3", "c4", "c5"
-        };
+    public void testEquality() {
+        String[] names = { "c1", "c2", "c3", "c4", "c5" };
         POIFSDocumentPath   a1    = new POIFSDocumentPath();
         POIFSDocumentPath   a2    = new POIFSDocumentPath(null);
         POIFSDocumentPath   a3    = new POIFSDocumentPath(new String[ 0 ]);
         POIFSDocumentPath   a4    = new POIFSDocumentPath(a1, null);
         POIFSDocumentPath   a5    = new POIFSDocumentPath(a1,
                                         new String[ 0 ]);
-        POIFSDocumentPath[] paths =
-        {
-            a1, a2, a3, a4, a5
-        };
+        POIFSDocumentPath[] paths = { a1, a2, a3, a4, a5 };
 
         for (int j = 0; j < paths.length; j++)
         {
@@ -196,17 +172,4 @@
             }
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.eventfilesystem.DocumentDescriptor");
-        junit.textui.TestRunner.run(TestDocumentDescriptor.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentInputStream.java b/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentInputStream.java
index b42f7ef..0b1b6b0 100644
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentInputStream.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentInputStream.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,18 +14,16 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.filesystem;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.Arrays;
 
-import java.util.*;
-
-import junit.framework.*;
+import junit.framework.TestCase;
 
 import org.apache.poi.poifs.property.DirectoryProperty;
-import org.apache.poi.poifs.property.DocumentProperty;
 import org.apache.poi.poifs.storage.RawDataBlock;
 
 /**
@@ -35,22 +32,9 @@
  * @author Marc Johnson
  */
 
-public class TestDocumentInputStream
-    extends TestCase
-{
+public final class TestDocumentInputStream extends TestCase {
 
-    /**
-     * Constructor TestDocumentInputStream
-     *
-     * @param name
-     *
-     * @exception IOException
-     */
-
-    public TestDocumentInputStream(String name)
-        throws IOException
-    {
-        super(name);
+	protected void setUp() throws Exception {
         int blocks = (_workbook_size + 511) / 512;
 
         _workbook_data = new byte[ 512 * blocks ];
@@ -73,7 +57,7 @@
         _workbook = new DocumentNode(
             document.getDocumentProperty(),
             new DirectoryNode(
-                new DirectoryProperty("Root Entry"), null, null));
+                new DirectoryProperty("Root Entry"), (POIFSFileSystem)null, null));
     }
 
     private DocumentNode     _workbook;
@@ -86,13 +70,8 @@
 
     /**
      * test constructor
-     *
-     * @exception IOException
      */
-
-    public void testConstructor()
-        throws IOException
-    {
+    public void testConstructor() throws IOException {
         DocumentInputStream stream = new DocumentInputStream(_workbook);
 
         assertEquals(_workbook_size, stream.available());
@@ -100,13 +79,8 @@
 
     /**
      * test available() behavior
-     *
-     * @exception IOException
      */
-
-    public void testAvailable()
-        throws IOException
-    {
+    public void testAvailable() throws IOException {
         DocumentInputStream stream = new DocumentInputStream(_workbook);
 
         assertEquals(_workbook_size, stream.available());
@@ -115,9 +89,7 @@
         {
             stream.available();
             fail("Should have caught IOException");
-        }
-        catch (IOException ignored)
-        {
+        } catch (IllegalStateException ignored) {
 
             // as expected
         }
@@ -125,13 +97,8 @@
 
     /**
      * test mark/reset/markSupported.
-     *
-     * @exception IOException
      */
-
-    public void testMarkFunctions()
-        throws IOException
-    {
+    public void testMarkFunctions() throws IOException {
         DocumentInputStream stream = new DocumentInputStream(_workbook);
         byte[]              buffer = new byte[ _workbook_size / 5 ];
 
@@ -169,13 +136,8 @@
 
     /**
      * test simple read method
-     *
-     * @exception IOException
      */
-
-    public void testReadSingleByte()
-        throws IOException
-    {
+    public void testReadSingleByte() throws IOException {
         DocumentInputStream stream    = new DocumentInputStream(_workbook);
         int                 remaining = _workbook_size;
 
@@ -205,13 +167,8 @@
 
     /**
      * Test buffered read
-     *
-     * @exception IOException
      */
-
-    public void testBufferRead()
-        throws IOException
-    {
+    public void testBufferRead() throws IOException {
         DocumentInputStream stream = new DocumentInputStream(_workbook);
 
         try
@@ -275,23 +232,14 @@
 
     /**
      * Test complex buffered read
-     *
-     * @exception IOException
      */
-
-    public void testComplexBufferRead()
-        throws IOException
-    {
+    public void testComplexBufferRead() throws IOException {
         DocumentInputStream stream = new DocumentInputStream(_workbook);
 
-        try
-        {
+        try {
             stream.read(null, 0, 1);
             fail("Should have caught NullPointerException");
-        }
-        catch (NullPointerException ignored)
-        {
-
+        } catch (IllegalArgumentException ignored) {
             // as expected
         }
 
@@ -391,13 +339,8 @@
 
     /**
      * test skip
-     *
-     * @exception IOException
      */
-
-    public void testSkip()
-        throws IOException
-    {
+    public void testSkip() throws IOException {
         DocumentInputStream stream = new DocumentInputStream(_workbook);
 
         assertEquals(_workbook_size, stream.available());
@@ -422,17 +365,4 @@
                      stream.skip(2 + ( long ) Integer.MAX_VALUE));
         assertEquals(0, stream.available());
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.filesystem.DocumentInputStream");
-        junit.textui.TestRunner.run(TestDocumentInputStream.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentNode.java b/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentNode.java
index 211c300..6101494 100644
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentNode.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentNode.java
@@ -15,7 +15,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.filesystem;
 
@@ -32,31 +31,12 @@
  *
  * @author Marc Johnson
  */
-
-public class TestDocumentNode
-    extends TestCase
-{
-
-    /**
-     * Constructor TestDocumentNode
-     *
-     * @param name
-     */
-
-    public TestDocumentNode(String name)
-    {
-        super(name);
-    }
+public final class TestDocumentNode extends TestCase {
 
     /**
      * test constructor
-     *
-     * @exception IOException
      */
-
-    public void testConstructor()
-        throws IOException
-    {
+    public void testConstructor() throws IOException {
         DirectoryProperty    property1 = new DirectoryProperty("directory");
         RawDataBlock[]       rawBlocks = new RawDataBlock[ 4 ];
         ByteArrayInputStream stream    =
@@ -69,7 +49,7 @@
         POIFSDocument    document  = new POIFSDocument("document", rawBlocks,
                                          2000);
         DocumentProperty property2 = document.getDocumentProperty();
-        DirectoryNode    parent    = new DirectoryNode(property1, null, null);
+        DirectoryNode    parent    = new DirectoryNode(property1, (POIFSFileSystem)null, null);
         DocumentNode     node      = new DocumentNode(property2, parent);
 
         // verify we can retrieve the document
@@ -90,17 +70,4 @@
         // verify getParent behaves correctly
         assertEquals(parent, node.getParent());
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.filesystem.DocumentNode");
-        junit.textui.TestRunner.run(TestDocumentNode.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentOutputStream.java b/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentOutputStream.java
index 7fa9471..4218367 100644
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentOutputStream.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestDocumentOutputStream.java
@@ -15,53 +15,26 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.filesystem;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
 
-import java.util.*;
-
-import junit.framework.*;
-
-import org.apache.poi.poifs.property.DirectoryProperty;
-import org.apache.poi.poifs.property.DocumentProperty;
-import org.apache.poi.poifs.storage.RawDataBlock;
+import junit.framework.TestCase;
 
 /**
  * Class to test DocumentOutputStream functionality
  *
  * @author Marc Johnson
  */
-
-public class TestDocumentOutputStream
-    extends TestCase
-{
-
-    /**
-     * Constructor TestDocumentOutputStream
-     *
-     * @param name
-     *
-     * @exception IOException
-     */
-
-    public TestDocumentOutputStream(String name)
-        throws IOException
-    {
-        super(name);
-    }
+public final class TestDocumentOutputStream extends TestCase {
 
     /**
      * test write(int) behavior
-     *
-     * @exception IOException
      */
-
-    public void testWrite1()
-        throws IOException
-    {
+    public void testWrite1() throws IOException {
         ByteArrayOutputStream stream  = new ByteArrayOutputStream();
         DocumentOutputStream  dstream = new DocumentOutputStream(stream, 25);
 
@@ -89,13 +62,8 @@
 
     /**
      * test write(byte[]) behavior
-     *
-     * @exception IOException
      */
-
-    public void testWrite2()
-        throws IOException
-    {
+    public void testWrite2() throws IOException {
         ByteArrayOutputStream stream  = new ByteArrayOutputStream();
         DocumentOutputStream  dstream = new DocumentOutputStream(stream, 25);
 
@@ -133,13 +101,8 @@
 
     /**
      * test write(byte[], int, int) behavior
-     *
-     * @exception IOException
      */
-
-    public void testWrite3()
-        throws IOException
-    {
+    public void testWrite3() throws IOException {
         ByteArrayOutputStream stream  = new ByteArrayOutputStream();
         DocumentOutputStream  dstream = new DocumentOutputStream(stream, 25);
         byte[]                array   = new byte[ 50 ];
@@ -169,13 +132,8 @@
 
     /**
      * test writeFiller()
-     *
-     * @exception IOException
      */
-
-    public void testWriteFiller()
-        throws IOException
-    {
+    public void testWriteFiller() throws IOException {
         ByteArrayOutputStream stream  = new ByteArrayOutputStream();
         DocumentOutputStream  dstream = new DocumentOutputStream(stream, 25);
 
@@ -205,17 +163,4 @@
         }
         stream.close();
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.filesystem.DocumentOutputStream");
-        junit.textui.TestRunner.run(TestDocumentOutputStream.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestEmptyDocument.java b/src/testcases/org/apache/poi/poifs/filesystem/TestEmptyDocument.java
index 870d752..36886af 100644
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestEmptyDocument.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestEmptyDocument.java
@@ -30,143 +30,88 @@
 import org.apache.poi.poifs.filesystem.POIFSWriterListener;
 import org.apache.poi.poifs.filesystem.DirectoryEntry;
 
-public class TestEmptyDocument extends TestCase {
+public final class TestEmptyDocument extends TestCase {
 
-  public static void main(String[] args) {
-    TestEmptyDocument driver = new TestEmptyDocument();
+	public void testSingleEmptyDocument() throws IOException {
+		POIFSFileSystem fs = new POIFSFileSystem();
+		DirectoryEntry dir = fs.getRoot();
+		dir.createDocument("Foo", new ByteArrayInputStream(new byte[] {}));
 
-    System.out.println();
-    System.out.println("As only file...");
-    System.out.println();
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		fs.writeFilesystem(out);
+		new POIFSFileSystem(new ByteArrayInputStream(out.toByteArray()));
+	}
 
-    System.out.print("Trying using createDocument(String,InputStream): ");
-    try {
-      driver.testSingleEmptyDocument();
-      System.out.println("Worked!");
-    } catch (IOException exception) {
-      System.out.println("failed! ");
-      System.out.println(exception.toString());
-    }
-    System.out.println();
+	public void testSingleEmptyDocumentEvent() throws IOException {
+		POIFSFileSystem fs = new POIFSFileSystem();
+		DirectoryEntry dir = fs.getRoot();
+		dir.createDocument("Foo", 0, new POIFSWriterListener() {
+			public void processPOIFSWriterEvent(POIFSWriterEvent event) {
+				System.out.println("written");
+			}
+		});
 
-    System.out.print
-      ("Trying using createDocument(String,int,POIFSWriterListener): ");
-    try {
-      driver.testSingleEmptyDocumentEvent();
-      System.out.println("Worked!");
-    } catch (IOException exception) {
-      System.out.println("failed!");
-      System.out.println(exception.toString());
-    }
-    System.out.println();
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		fs.writeFilesystem(out);
+		new POIFSFileSystem(new ByteArrayInputStream(out.toByteArray()));
+	}
 
-    System.out.println();
-    System.out.println("After another file...");
-    System.out.println();
+	public void testEmptyDocumentWithFriend() throws IOException {
+		POIFSFileSystem fs = new POIFSFileSystem();
+		DirectoryEntry dir = fs.getRoot();
+		dir.createDocument("Bar", new ByteArrayInputStream(new byte[] { 0 }));
+		dir.createDocument("Foo", new ByteArrayInputStream(new byte[] {}));
 
-    System.out.print("Trying using createDocument(String,InputStream): ");
-    try {
-      driver.testEmptyDocumentWithFriend();
-      System.out.println("Worked!");
-    } catch (IOException exception) {
-      System.out.println("failed! ");
-      System.out.println(exception.toString());
-    }
-    System.out.println();
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		fs.writeFilesystem(out);
+		new POIFSFileSystem(new ByteArrayInputStream(out.toByteArray()));
+	}
 
-    System.out.print
-      ("Trying using createDocument(String,int,POIFSWriterListener): ");
-    try {
-      driver.testEmptyDocumentWithFriend();
-      System.out.println("Worked!");
-    } catch (IOException exception) {
-      System.out.println("failed!");
-      System.out.println(exception.toString());
-    }
-    System.out.println();
-  }
+	public void testEmptyDocumentEventWithFriend() throws IOException {
+		POIFSFileSystem fs = new POIFSFileSystem();
+		DirectoryEntry dir = fs.getRoot();
+		dir.createDocument("Bar", 1, new POIFSWriterListener() {
+			public void processPOIFSWriterEvent(POIFSWriterEvent event) {
+				try {
+					event.getStream().write(0);
+				} catch (IOException exception) {
+					throw new RuntimeException("exception on write: " + exception);
+				}
+			}
+		});
+		dir.createDocument("Foo", 0, new POIFSWriterListener() {
+			public void processPOIFSWriterEvent(POIFSWriterEvent event) {
+			}
+		});
 
-  public void testSingleEmptyDocument() throws IOException {
-    POIFSFileSystem fs = new POIFSFileSystem();
-    DirectoryEntry dir = fs.getRoot();
-    dir.createDocument("Foo", new ByteArrayInputStream(new byte[] { }));
-    
-    ByteArrayOutputStream out = new ByteArrayOutputStream();
-    fs.writeFilesystem(out);
-    new POIFSFileSystem(new ByteArrayInputStream(out.toByteArray()));
-  }
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		fs.writeFilesystem(out);
+		new POIFSFileSystem(new ByteArrayInputStream(out.toByteArray()));
+	}
 
-  public void testSingleEmptyDocumentEvent() throws IOException {
-    POIFSFileSystem fs = new POIFSFileSystem();
-    DirectoryEntry dir = fs.getRoot();
-    dir.createDocument("Foo", 0, new POIFSWriterListener() {
-      public void processPOIFSWriterEvent(POIFSWriterEvent event) {
-      	System.out.println("written");
-      }
-    });
-    
-    ByteArrayOutputStream out = new ByteArrayOutputStream();
-    fs.writeFilesystem(out);
-    new POIFSFileSystem(new ByteArrayInputStream(out.toByteArray()));
-  }
+	public void testEmptyDocumentBug11744() throws Exception {
+		byte[] testData = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-  public void testEmptyDocumentWithFriend() throws IOException {
-    POIFSFileSystem fs = new POIFSFileSystem();
-    DirectoryEntry dir = fs.getRoot();
-    dir.createDocument("Bar", new ByteArrayInputStream(new byte[] { 0 }));
-    dir.createDocument("Foo", new ByteArrayInputStream(new byte[] { }));
-    
-    ByteArrayOutputStream out = new ByteArrayOutputStream();
-    fs.writeFilesystem(out);
-    new POIFSFileSystem(new ByteArrayInputStream(out.toByteArray()));
-  }
+		POIFSFileSystem fs = new POIFSFileSystem();
+		fs.createDocument(new ByteArrayInputStream(new byte[0]), "Empty");
+		fs.createDocument(new ByteArrayInputStream(testData), "NotEmpty");
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		fs.writeFilesystem(out);
+		out.toByteArray();
 
-  public void testEmptyDocumentEventWithFriend() throws IOException {
-    POIFSFileSystem fs = new POIFSFileSystem();
-    DirectoryEntry dir = fs.getRoot();
-    dir.createDocument("Bar", 1, new POIFSWriterListener() {
-      public void processPOIFSWriterEvent(POIFSWriterEvent event) {
-        try {
-          event.getStream().write(0);
-        } catch (IOException exception) {
-          throw new RuntimeException("exception on write: " + exception);
-        }
-      }
-    });
-    dir.createDocument("Foo", 0, new POIFSWriterListener() {
-      public void processPOIFSWriterEvent(POIFSWriterEvent event) {
-      }
-    });
-    
-    ByteArrayOutputStream out = new ByteArrayOutputStream();
-    fs.writeFilesystem(out);
-    new POIFSFileSystem(new ByteArrayInputStream(out.toByteArray()));
-  }
+		// This line caused the error.
+		fs = new POIFSFileSystem(new ByteArrayInputStream(out.toByteArray()));
 
-  public void testEmptyDocumentBug11744() throws Exception {
-        byte[] testData = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+		DocumentEntry entry = (DocumentEntry) fs.getRoot().getEntry("Empty");
+		assertEquals("Expected zero size", 0, entry.getSize());
+		byte[] actualReadbackData;
+		actualReadbackData = IOUtils.toByteArray(new DocumentInputStream(entry));
+		assertEquals("Expected zero read from stream", 0, actualReadbackData.length);
 
-        POIFSFileSystem fs = new POIFSFileSystem();
-        fs.createDocument(new ByteArrayInputStream(new byte[0]), "Empty");
-        fs.createDocument(new ByteArrayInputStream(testData), "NotEmpty");
-        ByteArrayOutputStream out = new ByteArrayOutputStream();
-        fs.writeFilesystem(out);
-        out.toByteArray();
-
-        // This line caused the error.
-        fs = new POIFSFileSystem(new ByteArrayInputStream(out.toByteArray()));
-
-        DocumentEntry entry = (DocumentEntry) fs.getRoot().getEntry("Empty");
-        assertEquals("Expected zero size", 0, entry.getSize());
-        byte[] actualReadbackData;
-        actualReadbackData = IOUtils.toByteArray(new DocumentInputStream(entry));
-        assertEquals("Expected zero read from stream", 0,
-                     actualReadbackData.length);
-
-        entry = (DocumentEntry) fs.getRoot().getEntry("NotEmpty");
-        actualReadbackData = IOUtils.toByteArray(new DocumentInputStream(entry));
-        assertEquals("Expected size was wrong", testData.length, entry.getSize());
-        assertTrue("Expected different data read from stream", 
-                Arrays.equals(testData, actualReadbackData));
-    }
+		entry = (DocumentEntry) fs.getRoot().getEntry("NotEmpty");
+		actualReadbackData = IOUtils.toByteArray(new DocumentInputStream(entry));
+		assertEquals("Expected size was wrong", testData.length, entry.getSize());
+		assertTrue("Expected different data read from stream", Arrays.equals(testData,
+				actualReadbackData));
+	}
 }
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestNPOIFSFileSystem.java b/src/testcases/org/apache/poi/poifs/filesystem/TestNPOIFSFileSystem.java
new file mode 100644
index 0000000..a375be1
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestNPOIFSFileSystem.java
@@ -0,0 +1,475 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.filesystem;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+import junit.framework.TestCase;
+
+import org.apache.poi.POIDataSamples;
+import org.apache.poi.hpsf.PropertySet;
+import org.apache.poi.hpsf.PropertySetFactory;
+import org.apache.poi.hpsf.SummaryInformation;
+import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.property.NPropertyTable;
+import org.apache.poi.poifs.property.Property;
+import org.apache.poi.poifs.property.RootProperty;
+
+/**
+ * Tests for the new NIO POIFSFileSystem implementation
+ */
+public final class TestNPOIFSFileSystem extends TestCase {
+   private static final POIDataSamples _inst = POIDataSamples.getPOIFSInstance();
+
+   public void testBasicOpen() throws Exception {
+      NPOIFSFileSystem fsA, fsB;
+      
+      // With a simple 512 block file
+      fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB}) {
+         assertEquals(512, fs.getBigBlockSize());
+      }
+      
+      // Now with a simple 4096 block file
+      fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize4096.zvi"));
+      fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize4096.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB}) {
+         assertEquals(4096, fs.getBigBlockSize());
+      }
+   }
+
+   public void testPropertiesAndFatOnRead() throws Exception {
+      NPOIFSFileSystem fsA, fsB;
+      
+      // With a simple 512 block file
+      fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB}) {
+         // Check the FAT was properly processed:
+         // Verify we only got one block
+         fs.getBATBlockAndIndex(0);
+         fs.getBATBlockAndIndex(1);
+         try {
+            fs.getBATBlockAndIndex(140);
+            fail("Should only be one BAT, but a 2nd was found");
+         } catch(IndexOutOfBoundsException e) {}
+         
+         // Verify a few next offsets
+         // 97 -> 98 -> END
+         assertEquals(98, fs.getNextBlock(97));
+         assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(98));
+         
+         
+         // Check the properties
+         NPropertyTable props = fs._get_property_table();
+         assertEquals(90, props.getStartBlock());
+         assertEquals(7, props.countBlocks());
+         
+         // Root property tells us about the Mini Stream
+         RootProperty root = props.getRoot();
+         assertEquals("Root Entry", root.getName());
+         assertEquals(11564, root.getSize());
+         assertEquals(0, root.getStartBlock());
+         
+         // Check its children too
+         Property prop;
+         Iterator<Property> pi = root.getChildren();
+         prop = pi.next();
+         assertEquals("Thumbnail", prop.getName());
+         prop = pi.next();
+         assertEquals("\u0005DocumentSummaryInformation", prop.getName());
+         prop = pi.next();
+         assertEquals("\u0005SummaryInformation", prop.getName());
+         prop = pi.next();
+         assertEquals("Image", prop.getName());
+         prop = pi.next();
+         assertEquals("Tags", prop.getName());
+         assertEquals(false, pi.hasNext());
+         
+         
+         // Check the SBAT (Small Blocks FAT) was properly processed
+         NPOIFSMiniStore ministore = fs.getMiniStore();
+         
+         // Verify we only got two SBAT blocks
+         ministore.getBATBlockAndIndex(0);
+         ministore.getBATBlockAndIndex(128);
+         try {
+            ministore.getBATBlockAndIndex(256);
+            fail("Should only be two SBATs, but a 3rd was found");
+         } catch(IndexOutOfBoundsException e) {}
+         
+         // Verify a few offsets: 0->50 is a stream
+         for(int i=0; i<50; i++) {
+            assertEquals(i+1, ministore.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(50));
+      }
+      
+      // Now with a simple 4096 block file
+      fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize4096.zvi"));
+      fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize4096.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB}) {
+         // Check the FAT was properly processed
+         // Verify we only got one block
+         fs.getBATBlockAndIndex(0);
+         fs.getBATBlockAndIndex(1);
+         try {
+            fs.getBATBlockAndIndex(1040);
+            fail("Should only be one BAT, but a 2nd was found");
+         } catch(IndexOutOfBoundsException e) {}
+         
+         // Verify a few next offsets
+         // 0 -> 1 -> 2 -> END
+         assertEquals(1, fs.getNextBlock(0));
+         assertEquals(2, fs.getNextBlock(1));
+         assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(2));
+
+         
+         // Check the properties
+         NPropertyTable props = fs._get_property_table();
+         assertEquals(12, props.getStartBlock());
+         assertEquals(1, props.countBlocks());
+         
+         // Root property tells us about the Mini Stream
+         RootProperty root = props.getRoot();
+         assertEquals("Root Entry", root.getName());
+         assertEquals(11564, root.getSize());
+         assertEquals(0, root.getStartBlock());
+         
+         // Check its children too
+         Property prop;
+         Iterator<Property> pi = root.getChildren();
+         prop = pi.next();
+         assertEquals("Thumbnail", prop.getName());
+         prop = pi.next();
+         assertEquals("\u0005DocumentSummaryInformation", prop.getName());
+         prop = pi.next();
+         assertEquals("\u0005SummaryInformation", prop.getName());
+         prop = pi.next();
+         assertEquals("Image", prop.getName());
+         prop = pi.next();
+         assertEquals("Tags", prop.getName());
+         assertEquals(false, pi.hasNext());
+         
+         
+         // Check the SBAT (Small Blocks FAT) was properly processed
+         NPOIFSMiniStore ministore = fs.getMiniStore();
+         
+         // Verify we only got one SBAT block
+         ministore.getBATBlockAndIndex(0);
+         ministore.getBATBlockAndIndex(128);
+         ministore.getBATBlockAndIndex(1023);
+         try {
+            ministore.getBATBlockAndIndex(1024);
+            fail("Should only be one SBAT, but a 2nd was found");
+         } catch(IndexOutOfBoundsException e) {}
+         
+         // Verify a few offsets: 0->50 is a stream
+         for(int i=0; i<50; i++) {
+            assertEquals(i+1, ministore.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(50));
+      }
+   }
+   
+   /**
+    * Check that for a given block, we can correctly figure
+    *  out what the next one is
+    */
+   public void testNextBlock() throws Exception {
+      NPOIFSFileSystem fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      NPOIFSFileSystem fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB}) {
+         // 0 -> 21 are simple
+         for(int i=0; i<21; i++) {
+            assertEquals(i+1, fs.getNextBlock(i));
+         }
+         // 21 jumps to 89, then ends
+         assertEquals(89, fs.getNextBlock(21));
+         assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(89));
+         
+         // 22 -> 88 simple sequential stream
+         for(int i=22; i<88; i++) {
+            assertEquals(i+1, fs.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(88));
+         
+         // 90 -> 96 is another stream
+         for(int i=90; i<96; i++) {
+            assertEquals(i+1, fs.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(96));
+         
+         // 97+98 is another
+         assertEquals(98, fs.getNextBlock(97));
+         assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(98));
+         
+         // 99 is our FAT block
+         assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(99));
+         
+         // 100 onwards is free
+         for(int i=100; i<fs.getBigBlockSizeDetails().getBATEntriesPerBlock(); i++) {
+            assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(i));
+         }
+      }
+      
+      // Quick check on 4096 byte blocks too
+      fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize4096.zvi"));
+      fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize4096.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB}) {
+         // 0 -> 1 -> 2 -> end
+         assertEquals(1, fs.getNextBlock(0));
+         assertEquals(2, fs.getNextBlock(1));
+         assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(2));
+         
+         // 4 -> 11 then end
+         for(int i=4; i<11; i++) {
+            assertEquals(i+1, fs.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(11));
+      }
+   }
+
+   /**
+    * Check we get the right data back for each block
+    */
+   public void testGetBlock() throws Exception {
+      NPOIFSFileSystem fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      NPOIFSFileSystem fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB}) {
+         ByteBuffer b;
+         
+         // The 0th block is the first data block
+         b = fs.getBlockAt(0);
+         assertEquals((byte)0x9e, b.get());
+         assertEquals((byte)0x75, b.get());
+         assertEquals((byte)0x97, b.get());
+         assertEquals((byte)0xf6, b.get());
+         
+         // And the next block
+         b = fs.getBlockAt(1);
+         assertEquals((byte)0x86, b.get());
+         assertEquals((byte)0x09, b.get());
+         assertEquals((byte)0x22, b.get());
+         assertEquals((byte)0xfb, b.get());
+         
+         // Check the final block too
+         b = fs.getBlockAt(99);
+         assertEquals((byte)0x01, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x02, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+      }
+      
+      // Quick check on 4096 byte blocks too
+      fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize4096.zvi"));
+      fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize4096.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB}) {
+         ByteBuffer b;
+         
+         // The 0th block is the first data block
+         b = fs.getBlockAt(0);
+         assertEquals((byte)0x9e, b.get());
+         assertEquals((byte)0x75, b.get());
+         assertEquals((byte)0x97, b.get());
+         assertEquals((byte)0xf6, b.get());
+         
+         // And the next block
+         b = fs.getBlockAt(1);
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x03, b.get());
+         assertEquals((byte)0x00, b.get());
+
+         // The 14th block is the FAT
+         b = fs.getBlockAt(14);
+         assertEquals((byte)0x01, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x02, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+      }
+   }
+   
+   /**
+    * Ask for free blocks where there are some already
+    *  to be had from the FAT
+    */
+   public void testGetFreeBlockWithSpare() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      
+      // Our first BAT block has spares
+      assertEquals(true, fs.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
+      
+      // First free one is 100
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(100));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(101));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(102));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(103));
+      
+      // Ask, will get 100
+      assertEquals(100, fs.getFreeBlock());
+      
+      // Ask again, will still get 100 as not written to
+      assertEquals(100, fs.getFreeBlock());
+      
+      // Allocate it, then ask again
+      fs.setNextBlock(100, POIFSConstants.END_OF_CHAIN);
+      assertEquals(101, fs.getFreeBlock());
+   }
+
+   /**
+    * Ask for free blocks where no free ones exist, and so the
+    *  file needs to be extended and another BAT/XBAT added
+    */
+   public void testGetFreeBlockWithNoneSpare() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+
+      // We have one BAT at block 99
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(99));
+      
+      // We've spare ones from 100 to 128
+      for(int i=100; i<128; i++) {
+         assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(i));
+      }
+      
+      // Check our BAT knows it's free
+      assertEquals(true, fs.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
+      
+      // Allocate all the spare ones
+      for(int i=100; i<128; i++) {
+         fs.setNextBlock(i, POIFSConstants.END_OF_CHAIN);
+      }
+      
+      // BAT is now full, but there's only the one
+      assertEquals(false, fs.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
+      try {
+         assertEquals(false, fs.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
+         fail("Should only be one BAT");
+      } catch(IndexOutOfBoundsException e) {}
+      
+      // Now ask for a free one, will need to extend the file
+      assertEquals(129, fs.getFreeBlock());
+      
+      assertEquals(false, fs.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
+      assertEquals(true, fs.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(128));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(129));
+      
+      
+      // Fill up to hold 109 BAT blocks
+      // TODO
+      
+      // Ask for another, will get our first XBAT
+      // TODO
+      
+      // Fill the XBAT
+      // TODO
+      
+      // Ask for another, will get our 2nd XBAT
+      // TODO
+      
+      // Write it out and read it back in again
+      // Ensure it's correct
+      // TODO
+   }
+   
+   /**
+    * Test that we can correctly get the list of directory
+    *  entries, and the details on the files in them
+    */
+   public void testListEntries() throws Exception {
+      NPOIFSFileSystem fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      NPOIFSFileSystem fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      NPOIFSFileSystem fsC = new NPOIFSFileSystem(_inst.getFile("BlockSize4096.zvi"));
+      NPOIFSFileSystem fsD = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize4096.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB,fsC,fsD}) {
+         DirectoryEntry root = fs.getRoot();
+         assertEquals(5, root.getEntryCount());
+         
+         // Check by the names
+         Entry thumbnail = root.getEntry("Thumbnail");
+         Entry dsi = root.getEntry("\u0005DocumentSummaryInformation");
+         Entry si = root.getEntry("\u0005SummaryInformation");
+         Entry image = root.getEntry("Image");
+         Entry tags = root.getEntry("Tags");
+         
+         assertEquals(false, thumbnail.isDirectoryEntry());
+         assertEquals(false, dsi.isDirectoryEntry());
+         assertEquals(false, si.isDirectoryEntry());
+         assertEquals(true, image.isDirectoryEntry());
+         assertEquals(false, tags.isDirectoryEntry());
+         
+         // Check via the iterator
+         Iterator<Entry> it = root.getEntries();
+         assertEquals(thumbnail.getName(), it.next().getName());
+         assertEquals(dsi.getName(), it.next().getName());
+         assertEquals(si.getName(), it.next().getName());
+         assertEquals(image.getName(), it.next().getName());
+         assertEquals(tags.getName(), it.next().getName());
+         
+         // Look inside another
+         DirectoryEntry imageD = (DirectoryEntry)image;
+         assertEquals(7, imageD.getEntryCount());
+      }
+   }
+   
+   /**
+    * Tests that we can get the correct contents for
+    *  a document in the filesystem 
+    */
+   public void testGetDocumentEntry() throws Exception {
+      NPOIFSFileSystem fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      NPOIFSFileSystem fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      NPOIFSFileSystem fsC = new NPOIFSFileSystem(_inst.getFile("BlockSize4096.zvi"));
+      NPOIFSFileSystem fsD = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize4096.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB,fsC,fsD}) {
+         DirectoryEntry root = fs.getRoot();
+         Entry si = root.getEntry("\u0005SummaryInformation");
+         
+         assertEquals(true, si.isDocumentEntry());
+         DocumentNode doc = (DocumentNode)si;
+         
+         // Check we can read it
+         NDocumentInputStream inp = new NDocumentInputStream(doc);
+         byte[] contents = new byte[doc.getSize()];
+         assertEquals(doc.getSize(), inp.read(contents));
+         
+         // Now try to build the property set
+         inp = new NDocumentInputStream(doc);
+         PropertySet ps = PropertySetFactory.create(inp);
+         SummaryInformation inf = (SummaryInformation)ps;
+         
+         // Check some bits in it
+         assertEquals(null, inf.getApplicationName());
+         assertEquals(null, inf.getAuthor());
+         assertEquals(null, inf.getSubject());
+      }
+   }
+   
+   // TODO Directory/Document write tests
+}
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestNPOIFSMiniStore.java b/src/testcases/org/apache/poi/poifs/filesystem/TestNPOIFSMiniStore.java
new file mode 100644
index 0000000..8f49590
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestNPOIFSMiniStore.java
@@ -0,0 +1,251 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.filesystem;
+
+import java.nio.ByteBuffer;
+
+import junit.framework.TestCase;
+
+import org.apache.poi.POIDataSamples;
+import org.apache.poi.poifs.common.POIFSConstants;
+
+/**
+ * Tests for the Mini Store in the NIO POIFS
+ */
+public final class TestNPOIFSMiniStore extends TestCase {
+   private static final POIDataSamples _inst = POIDataSamples.getPOIFSInstance();
+   
+   /**
+    * Check that for a given mini block, we can correctly figure
+    *  out what the next one is
+    */
+   public void testNextBlock() throws Exception {
+      // It's the same on 512 byte and 4096 byte block files!
+      NPOIFSFileSystem fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      NPOIFSFileSystem fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      NPOIFSFileSystem fsC = new NPOIFSFileSystem(_inst.getFile("BlockSize4096.zvi"));
+      NPOIFSFileSystem fsD = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize4096.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB,fsC,fsD}) {
+         NPOIFSMiniStore ministore = fs.getMiniStore();
+         
+         // 0 -> 51 is one stream
+         for(int i=0; i<50; i++) {
+            assertEquals(i+1, ministore.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(50));
+         
+         // 51 -> 103 is the next
+         for(int i=51; i<103; i++) {
+            assertEquals(i+1, ministore.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(103));
+         
+         // Then there are 3 one block ones
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(104));
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(105));
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(106));
+         
+         // 107 -> 154 is the next
+         for(int i=107; i<154; i++) {
+            assertEquals(i+1, ministore.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(154));
+
+         // 155 -> 160 is the next
+         for(int i=155; i<160; i++) {
+            assertEquals(i+1, ministore.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(160));
+         
+         // 161 -> 166 is the next
+         for(int i=161; i<166; i++) {
+            assertEquals(i+1, ministore.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(166));
+         
+         // 167 -> 172 is the next
+         for(int i=167; i<172; i++) {
+            assertEquals(i+1, ministore.getNextBlock(i));
+         }
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(172));
+         
+         // Now some short ones
+         assertEquals(174                        , ministore.getNextBlock(173));
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(174));
+         
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(175));
+         
+         assertEquals(177                        , ministore.getNextBlock(176));
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(177));
+         
+         assertEquals(179                        , ministore.getNextBlock(178));
+         assertEquals(180                        , ministore.getNextBlock(179));
+         assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(180));
+         
+         // 181 onwards is free
+         for(int i=181; i<fs.getBigBlockSizeDetails().getBATEntriesPerBlock(); i++) {
+            assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(i));
+         }
+      }
+   }
+
+   /**
+    * Check we get the right data back for each block
+    */
+   public void testGetBlock() throws Exception {
+      // It's the same on 512 byte and 4096 byte block files!
+      NPOIFSFileSystem fsA = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      NPOIFSFileSystem fsB = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      NPOIFSFileSystem fsC = new NPOIFSFileSystem(_inst.getFile("BlockSize4096.zvi"));
+      NPOIFSFileSystem fsD = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize4096.zvi"));
+      for(NPOIFSFileSystem fs : new NPOIFSFileSystem[] {fsA,fsB,fsC,fsD}) {
+         // Mini stream should be at big block zero
+         assertEquals(0, fs._get_property_table().getRoot().getStartBlock());
+         
+         // Grab the ministore
+         NPOIFSMiniStore ministore = fs.getMiniStore();
+         ByteBuffer b;
+         
+         // Runs from the start of the data section in 64 byte chungs
+         b = ministore.getBlockAt(0);
+         assertEquals((byte)0x9e, b.get());
+         assertEquals((byte)0x75, b.get());
+         assertEquals((byte)0x97, b.get());
+         assertEquals((byte)0xf6, b.get());
+         assertEquals((byte)0xff, b.get());
+         assertEquals((byte)0x21, b.get());
+         assertEquals((byte)0xd2, b.get());
+         assertEquals((byte)0x11, b.get());
+         
+         // And the next block
+         b = ministore.getBlockAt(1);
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x03, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x12, b.get());
+         assertEquals((byte)0x02, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         
+         // Check the last data block
+         b = ministore.getBlockAt(180);
+         assertEquals((byte)0x30, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x00, b.get());
+         assertEquals((byte)0x80, b.get());
+         
+         // And the rest until the end of the big block is zeros
+         for(int i=181; i<184; i++) {
+            b = ministore.getBlockAt(i);
+            assertEquals((byte)0, b.get());
+            assertEquals((byte)0, b.get());
+            assertEquals((byte)0, b.get());
+            assertEquals((byte)0, b.get());
+            assertEquals((byte)0, b.get());
+            assertEquals((byte)0, b.get());
+            assertEquals((byte)0, b.get());
+            assertEquals((byte)0, b.get());
+         }
+      }
+   }
+   
+   /**
+    * Ask for free blocks where there are some already
+    *  to be had from the SFAT
+    */
+   public void testGetFreeBlockWithSpare() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      NPOIFSMiniStore ministore = fs.getMiniStore();
+      
+      // Our 2nd SBAT block has spares
+      assertEquals(false, ministore.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
+      assertEquals(true,  ministore.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
+      
+      // First free one at 181
+      assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(181));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(182));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(183));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(184));
+      
+      // Ask, will get 181
+      assertEquals(181, ministore.getFreeBlock());
+      
+      // Ask again, will still get 181 as not written to
+      assertEquals(181, ministore.getFreeBlock());
+      
+      // Allocate it, then ask again
+      ministore.setNextBlock(181, POIFSConstants.END_OF_CHAIN);
+      assertEquals(182, ministore.getFreeBlock());
+   }
+
+   /**
+    * Ask for free blocks where no free ones exist, and so the
+    *  stream needs to be extended and another SBAT added
+    */
+   public void testGetFreeBlockWithNoneSpare() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      NPOIFSMiniStore ministore = fs.getMiniStore();
+      
+      // We've spare ones from 181 to 255
+      for(int i=181; i<256; i++) {
+         assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(i));
+      }
+      
+      // Check our SBAT free stuff is correct
+      assertEquals(false, ministore.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
+      assertEquals(true,  ministore.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
+      
+      // Allocate all the spare ones
+      for(int i=181; i<256; i++) {
+         ministore.setNextBlock(i, POIFSConstants.END_OF_CHAIN);
+      }
+      
+      // SBAT are now full, but there's only the two
+      assertEquals(false, ministore.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
+      assertEquals(false, ministore.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
+      try {
+         assertEquals(false, ministore.getBATBlockAndIndex(256).getBlock().hasFreeSectors());
+         fail("Should only be two SBATs");
+      } catch(IndexOutOfBoundsException e) {}
+      
+      // Now ask for a free one, will need to extend the SBAT chain
+      assertEquals(256, ministore.getFreeBlock());
+      
+      assertEquals(false, ministore.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
+      assertEquals(false, ministore.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
+      assertEquals(true, ministore.getBATBlockAndIndex(256).getBlock().hasFreeSectors());
+      assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(254)); // 2nd SBAT 
+      assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(255)); // 2nd SBAT
+      assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(256)); // 3rd SBAT
+      assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(257)); // 3rd SBAT
+   }
+   
+   /**
+    * Test that we will extend the underlying chain of 
+    *  big blocks that make up the ministream as needed
+    */
+   public void testCreateBlockIfNeeded() throws Exception {
+      // TODO Add underlying implementation
+      // TODO Add unit test
+   }
+}
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestNPOIFSStream.java b/src/testcases/org/apache/poi/poifs/filesystem/TestNPOIFSStream.java
new file mode 100644
index 0000000..c8b38d9
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestNPOIFSStream.java
@@ -0,0 +1,641 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.filesystem;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+import junit.framework.TestCase;
+
+import org.apache.poi.POIDataSamples;
+import org.apache.poi.poifs.common.POIFSConstants;
+
+/**
+ * Tests {@link NPOIFSStream}
+ */
+public final class TestNPOIFSStream extends TestCase {
+   private static final POIDataSamples _inst = POIDataSamples.getPOIFSInstance();
+
+   /**
+    * Read a single block stream
+    */
+   public void testReadTinyStream() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+
+      // 98 is actually the last block in a two block stream...
+      NPOIFSStream stream = new NPOIFSStream(fs, 98);
+      Iterator<ByteBuffer> i = stream.getBlockIterator();
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      ByteBuffer b = i.next();
+      assertEquals(false, i.hasNext());
+      assertEquals(false, i.hasNext());
+      assertEquals(false, i.hasNext());
+      
+      // Check the contents
+      assertEquals((byte)0x81, b.get());
+      assertEquals((byte)0x00, b.get());
+      assertEquals((byte)0x00, b.get());
+      assertEquals((byte)0x00, b.get());
+      assertEquals((byte)0x82, b.get());
+      assertEquals((byte)0x00, b.get());
+      assertEquals((byte)0x00, b.get());
+      assertEquals((byte)0x00, b.get());
+   }
+
+   /**
+    * Read a stream with only two blocks in it 
+    */
+   public void testReadShortStream() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      
+      // 97 -> 98 -> end
+      NPOIFSStream stream = new NPOIFSStream(fs, 97);
+      Iterator<ByteBuffer> i = stream.getBlockIterator();
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      ByteBuffer b97 = i.next();
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      ByteBuffer b98 = i.next();
+      assertEquals(false, i.hasNext());
+      assertEquals(false, i.hasNext());
+      assertEquals(false, i.hasNext());
+      
+      // Check the contents of the 1st block
+      assertEquals((byte)0x01, b97.get());
+      assertEquals((byte)0x00, b97.get());
+      assertEquals((byte)0x00, b97.get());
+      assertEquals((byte)0x00, b97.get());
+      assertEquals((byte)0x02, b97.get());
+      assertEquals((byte)0x00, b97.get());
+      assertEquals((byte)0x00, b97.get());
+      assertEquals((byte)0x00, b97.get());
+      
+      // Check the contents of the 2nd block
+      assertEquals((byte)0x81, b98.get());
+      assertEquals((byte)0x00, b98.get());
+      assertEquals((byte)0x00, b98.get());
+      assertEquals((byte)0x00, b98.get());
+      assertEquals((byte)0x82, b98.get());
+      assertEquals((byte)0x00, b98.get());
+      assertEquals((byte)0x00, b98.get());
+      assertEquals((byte)0x00, b98.get());
+   }
+   
+   /**
+    * Read a stream with many blocks 
+    */
+   public void testReadLongerStream() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      
+      ByteBuffer b0 = null;
+      ByteBuffer b1 = null;
+      ByteBuffer b22 = null;
+      
+      // The stream at 0 has 23 blocks in it
+      NPOIFSStream stream = new NPOIFSStream(fs, 0);
+      Iterator<ByteBuffer> i = stream.getBlockIterator();
+      int count = 0;
+      while(i.hasNext()) {
+         ByteBuffer b = i.next();
+         if(count == 0) {
+            b0 = b;
+         }
+         if(count == 1) {
+            b1 = b;
+         }
+         if(count == 22) {
+            b22 = b;
+         }
+         
+         count++;
+      }
+      assertEquals(23, count);
+      
+      // Check the contents
+      //  1st block is at 0
+      assertEquals((byte)0x9e, b0.get());
+      assertEquals((byte)0x75, b0.get());
+      assertEquals((byte)0x97, b0.get());
+      assertEquals((byte)0xf6, b0.get());
+            
+      //  2nd block is at 1
+      assertEquals((byte)0x86, b1.get());
+      assertEquals((byte)0x09, b1.get());
+      assertEquals((byte)0x22, b1.get());
+      assertEquals((byte)0xfb, b1.get());
+      
+      //  last block is at 89
+      assertEquals((byte)0xfe, b22.get());
+      assertEquals((byte)0xff, b22.get());
+      assertEquals((byte)0x00, b22.get());
+      assertEquals((byte)0x00, b22.get());
+      assertEquals((byte)0x05, b22.get());
+      assertEquals((byte)0x01, b22.get());
+      assertEquals((byte)0x02, b22.get());
+      assertEquals((byte)0x00, b22.get());
+   }
+
+   /**
+    * Read a stream with several blocks in a 4096 byte block file 
+    */
+   public void testReadStream4096() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.getFile("BlockSize4096.zvi"));
+      
+      // 0 -> 1 -> 2 -> end
+      NPOIFSStream stream = new NPOIFSStream(fs, 0);
+      Iterator<ByteBuffer> i = stream.getBlockIterator();
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      ByteBuffer b0 = i.next();
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      ByteBuffer b1 = i.next();
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      ByteBuffer b2 = i.next();
+      assertEquals(false, i.hasNext());
+      assertEquals(false, i.hasNext());
+      assertEquals(false, i.hasNext());
+      
+      // Check the contents of the 1st block
+      assertEquals((byte)0x9E, b0.get());
+      assertEquals((byte)0x75, b0.get());
+      assertEquals((byte)0x97, b0.get());
+      assertEquals((byte)0xF6, b0.get());
+      assertEquals((byte)0xFF, b0.get());
+      assertEquals((byte)0x21, b0.get());
+      assertEquals((byte)0xD2, b0.get());
+      assertEquals((byte)0x11, b0.get());
+      
+      // Check the contents of the 2nd block
+      assertEquals((byte)0x00, b1.get());
+      assertEquals((byte)0x00, b1.get());
+      assertEquals((byte)0x03, b1.get());
+      assertEquals((byte)0x00, b1.get());
+      assertEquals((byte)0x00, b1.get());
+      assertEquals((byte)0x00, b1.get());
+      assertEquals((byte)0x00, b1.get());
+      assertEquals((byte)0x00, b1.get());
+      
+      // Check the contents of the 3rd block
+      assertEquals((byte)0x6D, b2.get());
+      assertEquals((byte)0x00, b2.get());
+      assertEquals((byte)0x00, b2.get());
+      assertEquals((byte)0x00, b2.get());
+      assertEquals((byte)0x03, b2.get());
+      assertEquals((byte)0x00, b2.get());
+      assertEquals((byte)0x46, b2.get());
+      assertEquals((byte)0x00, b2.get());
+   }
+   
+   /**
+    * Craft a nasty file with a loop, and ensure we don't get stuck
+    */
+   public void testReadFailsOnLoop() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      
+      // Hack the FAT so that it goes 0->1->2->0
+      fs.setNextBlock(0, 1);
+      fs.setNextBlock(1, 2);
+      fs.setNextBlock(2, 0);
+      
+      // Now try to read
+      NPOIFSStream stream = new NPOIFSStream(fs, 0);
+      Iterator<ByteBuffer> i = stream.getBlockIterator();
+      assertEquals(true, i.hasNext());
+      
+      // 1st read works
+      i.next();
+      assertEquals(true, i.hasNext());
+      
+      // 2nd read works
+      i.next();
+      assertEquals(true, i.hasNext());
+      
+      // 3rd read works
+      i.next();
+      assertEquals(true, i.hasNext());
+      
+      // 4th read blows up as it loops back to 0
+      try {
+         i.next();
+         fail("Loop should have been detected but wasn't!");
+      } catch(RuntimeException e) {
+         // Good, it was detected
+      }
+      assertEquals(true, i.hasNext());
+   }
+
+   /**
+    * Tests that we can load some streams that are
+    *  stored in the mini stream.
+    */
+   public void testReadMiniStreams() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      NPOIFSMiniStore ministore = fs.getMiniStore();
+      
+      // 178 -> 179 -> 180 -> end
+      NPOIFSStream stream = new NPOIFSStream(ministore, 178);
+      Iterator<ByteBuffer> i = stream.getBlockIterator();
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      ByteBuffer b178 = i.next();
+      assertEquals(true, i.hasNext());
+      assertEquals(true, i.hasNext());
+      ByteBuffer b179 = i.next();
+      assertEquals(true, i.hasNext());
+      ByteBuffer b180 = i.next();
+      assertEquals(false, i.hasNext());
+      assertEquals(false, i.hasNext());
+      assertEquals(false, i.hasNext());
+      
+      // Check the contents of the 1st block
+      assertEquals((byte)0xfe, b178.get());
+      assertEquals((byte)0xff, b178.get());
+      assertEquals((byte)0x00, b178.get());
+      assertEquals((byte)0x00, b178.get());
+      assertEquals((byte)0x05, b178.get());
+      assertEquals((byte)0x01, b178.get());
+      assertEquals((byte)0x02, b178.get());
+      assertEquals((byte)0x00, b178.get());
+      
+      // And the 2nd
+      assertEquals((byte)0x6c, b179.get());
+      assertEquals((byte)0x00, b179.get());
+      assertEquals((byte)0x00, b179.get());
+      assertEquals((byte)0x00, b179.get());
+      assertEquals((byte)0x28, b179.get());
+      assertEquals((byte)0x00, b179.get());
+      assertEquals((byte)0x00, b179.get());
+      assertEquals((byte)0x00, b179.get());
+      
+      // And the 3rd
+      assertEquals((byte)0x30, b180.get());
+      assertEquals((byte)0x00, b180.get());
+      assertEquals((byte)0x00, b180.get());
+      assertEquals((byte)0x00, b180.get());
+      assertEquals((byte)0x00, b180.get());
+      assertEquals((byte)0x00, b180.get());
+      assertEquals((byte)0x00, b180.get());
+      assertEquals((byte)0x80, b180.get());
+   }
+
+   /**
+    * Writing the same amount of data as before
+    */
+   public void testReplaceStream() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      
+      byte[] data = new byte[512];
+      for(int i=0; i<data.length; i++) {
+         data[i] = (byte)(i%256);
+      }
+      
+      // 98 is actually the last block in a two block stream...
+      NPOIFSStream stream = new NPOIFSStream(fs, 98);
+      stream.updateContents(data);
+      
+      // Check the reading of blocks
+      Iterator<ByteBuffer> it = stream.getBlockIterator();
+      assertEquals(true, it.hasNext());
+      ByteBuffer b = it.next();
+      assertEquals(false, it.hasNext());
+      
+      // Now check the contents
+      data = new byte[512];
+      b.get(data);
+      for(int i=0; i<data.length; i++) {
+         byte exp = (byte)(i%256);
+         assertEquals(exp, data[i]);
+      }
+   }
+   
+   /**
+    * Writes less data than before, some blocks will need
+    *  to be freed
+    */
+   public void testReplaceStreamWithLess() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      
+      byte[] data = new byte[512];
+      for(int i=0; i<data.length; i++) {
+         data[i] = (byte)(i%256);
+      }
+      
+      // 97 -> 98 -> end
+      assertEquals(98, fs.getNextBlock(97));
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(98));
+      
+      // Create a 2 block stream, will become a 1 block one
+      NPOIFSStream stream = new NPOIFSStream(fs, 97);
+      stream.updateContents(data);
+      
+      // 97 should now be the end, and 98 free
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(97));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(98));
+      
+      // Check the reading of blocks
+      Iterator<ByteBuffer> it = stream.getBlockIterator();
+      assertEquals(true, it.hasNext());
+      ByteBuffer b = it.next();
+      assertEquals(false, it.hasNext());
+      
+      // Now check the contents
+      data = new byte[512];
+      b.get(data);
+      for(int i=0; i<data.length; i++) {
+         byte exp = (byte)(i%256);
+         assertEquals(exp, data[i]);
+      }
+   }
+   
+   /**
+    * Writes more data than before, new blocks will be needed
+    */
+   public void testReplaceStreamWithMore() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      
+      byte[] data = new byte[512*3];
+      for(int i=0; i<data.length; i++) {
+         data[i] = (byte)(i%256);
+      }
+      
+      // 97 -> 98 -> end
+      assertEquals(98, fs.getNextBlock(97));
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(98));
+      
+      // 100 is our first free one
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(99));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(100));
+      
+      // Create a 2 block stream, will become a 3 block one
+      NPOIFSStream stream = new NPOIFSStream(fs, 97);
+      stream.updateContents(data);
+      
+      // 97 -> 98 -> 100 -> end
+      assertEquals(98, fs.getNextBlock(97));
+      assertEquals(100, fs.getNextBlock(98));
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(100));
+      
+      // Check the reading of blocks
+      Iterator<ByteBuffer> it = stream.getBlockIterator();
+      int count = 0;
+      while(it.hasNext()) {
+         ByteBuffer b = it.next();
+         data = new byte[512];
+         b.get(data);
+         for(int i=0; i<data.length; i++) {
+            byte exp = (byte)(i%256);
+            assertEquals(exp, data[i]);
+         }
+         count++;
+      }
+      assertEquals(3, count);
+   }
+   
+   /**
+    * Writes to a new stream in the file
+    */
+   public void testWriteNewStream() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      
+      // 100 is our first free one
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(99));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(100));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(101));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(102));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(103));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(104));
+      
+      
+      // Add a single block one
+      byte[] data = new byte[512];
+      for(int i=0; i<data.length; i++) {
+         data[i] = (byte)(i%256);
+      }
+      
+      NPOIFSStream stream = new NPOIFSStream(fs);
+      stream.updateContents(data);
+      
+      // Check it was allocated properly
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(99));
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(100));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(101));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(102));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(103));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(104));
+      
+      // And check the contents
+      Iterator<ByteBuffer> it = stream.getBlockIterator();
+      int count = 0;
+      while(it.hasNext()) {
+         ByteBuffer b = it.next();
+         data = new byte[512];
+         b.get(data);
+         for(int i=0; i<data.length; i++) {
+            byte exp = (byte)(i%256);
+            assertEquals(exp, data[i]);
+         }
+         count++;
+      }
+      assertEquals(1, count);
+      
+      
+      // And a multi block one
+      data = new byte[512*3];
+      for(int i=0; i<data.length; i++) {
+         data[i] = (byte)(i%256);
+      }
+      
+      stream = new NPOIFSStream(fs);
+      stream.updateContents(data);
+      
+      // Check it was allocated properly
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(99));
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(100));
+      assertEquals(102,                         fs.getNextBlock(101));
+      assertEquals(103,                         fs.getNextBlock(102));
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(103));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(104));
+      
+      // And check the contents
+      it = stream.getBlockIterator();
+      count = 0;
+      while(it.hasNext()) {
+         ByteBuffer b = it.next();
+         data = new byte[512];
+         b.get(data);
+         for(int i=0; i<data.length; i++) {
+            byte exp = (byte)(i%256);
+            assertEquals(exp, data[i]);
+         }
+         count++;
+      }
+      assertEquals(3, count);
+      
+      // Free it
+      stream.free();
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(99));
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(100));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(101));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(102));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(103));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(104));
+   }
+   
+   /**
+    * Writes to a new stream in the file, where we've not enough
+    *  free blocks so new FAT segments will need to be allocated
+    *  to support this
+    */
+   public void testWriteNewStreamExtraFATs() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      
+      // Allocate almost all the blocks
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(99));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(100));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(127));
+      for(int i=100; i<127; i++) {
+         fs.setNextBlock(i, POIFSConstants.END_OF_CHAIN);
+      }
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(127));
+      assertEquals(true, fs.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
+
+      
+      // Write a 3 block stream
+      byte[] data = new byte[512*3];
+      for(int i=0; i<data.length; i++) {
+         data[i] = (byte)(i%256);
+      }
+      NPOIFSStream stream = new NPOIFSStream(fs);
+      stream.updateContents(data);
+      
+      // Check we got another BAT
+      assertEquals(false, fs.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
+      assertEquals(true,  fs.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
+      
+      // the BAT will be in the first spot of the new block
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(126));
+      assertEquals(129,                         fs.getNextBlock(127));
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(128));
+      assertEquals(130,                         fs.getNextBlock(129));
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(130));
+      assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(131));
+   }
+   
+   /**
+    * Replaces data in an existing stream, with a bit
+    *  more data than before, in a 4096 byte block file
+    */
+   public void testWriteStream4096() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize4096.zvi"));
+      
+      // 0 -> 1 -> 2 -> end
+      assertEquals(1, fs.getNextBlock(0));
+      assertEquals(2, fs.getNextBlock(1));
+      assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(2));
+      assertEquals(4, fs.getNextBlock(3));
+      
+      // First free one is at 15
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(14));
+      assertEquals(POIFSConstants.UNUSED_BLOCK,     fs.getNextBlock(15));
+      
+      
+      // Write a 5 block file 
+      byte[] data = new byte[4096*5];
+      for(int i=0; i<data.length; i++) {
+         data[i] = (byte)(i%256);
+      }
+      NPOIFSStream stream = new NPOIFSStream(fs, 0);
+      stream.updateContents(data);
+      
+      
+      // Check it
+      assertEquals(1, fs.getNextBlock(0));
+      assertEquals(2, fs.getNextBlock(1));
+      assertEquals(15, fs.getNextBlock(2)); // Jumps
+      assertEquals(4, fs.getNextBlock(3));  // Next stream
+      assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(14));
+      assertEquals(16,                              fs.getNextBlock(15)); // Continues
+      assertEquals(POIFSConstants.END_OF_CHAIN,     fs.getNextBlock(16)); // Ends
+      assertEquals(POIFSConstants.UNUSED_BLOCK,     fs.getNextBlock(17)); // Free
+
+      // Check the contents too
+      Iterator<ByteBuffer> it = stream.getBlockIterator();
+      int count = 0;
+      while(it.hasNext()) {
+         ByteBuffer b = it.next();
+         data = new byte[512];
+         b.get(data);
+         for(int i=0; i<data.length; i++) {
+            byte exp = (byte)(i%256);
+            assertEquals(exp, data[i]);
+         }
+         count++;
+      }
+      assertEquals(5, count);
+   }
+   
+   /**
+    * Tests that we can write into the mini stream
+    */
+   public void testWriteMiniStreams() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
+      
+      // TODO
+   }
+
+   /**
+    * Craft a nasty file with a loop, and ensure we don't get stuck
+    */
+   public void testWriteFailsOnLoop() throws Exception {
+      NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
+      
+      // Hack the FAT so that it goes 0->1->2->0
+      fs.setNextBlock(0, 1);
+      fs.setNextBlock(1, 2);
+      fs.setNextBlock(2, 0);
+      
+      // Try to write a large amount, should fail on the write
+      byte[] data = new byte[512*4];
+      NPOIFSStream stream = new NPOIFSStream(fs, 0);
+      try {
+         stream.updateContents(data);
+         fail("Loop should have been detected but wasn't!");
+      } catch(IllegalStateException e) {}
+      
+      // Now reset, and try on a small bit
+      // Should fail during the freeing set
+      fs.setNextBlock(0, 1);
+      fs.setNextBlock(1, 2);
+      fs.setNextBlock(2, 0);
+      
+      data = new byte[512];
+      stream = new NPOIFSStream(fs, 0);
+      try {
+         stream.updateContents(data);
+         fail("Loop should have been detected but wasn't!");
+      } catch(IllegalStateException e) {}
+   }
+}
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestOffice2007XMLException.java b/src/testcases/org/apache/poi/poifs/filesystem/TestOffice2007XMLException.java
index 8080b3e..7de2841 100644
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestOffice2007XMLException.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestOffice2007XMLException.java
@@ -41,7 +41,8 @@
 			fail("expected exception was not thrown");
 		} catch(OfficeXmlFileException e) {
 			// expected during successful test
-			assertTrue(e.getMessage().indexOf("POI only supports OLE2 Office documents") > 0);
+			assertTrue(e.getMessage().indexOf("The supplied data appears to be in the Office 2007+ XML") > -1);
+			assertTrue(e.getMessage().indexOf("You are calling the part of POI that deals with OLE2 Office Documents") > -1);
 		}
 	}
 	
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestOle10Native.java b/src/testcases/org/apache/poi/poifs/filesystem/TestOle10Native.java
new file mode 100644
index 0000000..1ff45be
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestOle10Native.java
@@ -0,0 +1,36 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.filesystem;
+
+import junit.framework.TestCase;
+import org.apache.poi.POIDataSamples;
+
+import java.io.IOException;
+
+public class TestOle10Native extends TestCase {
+    private static final POIDataSamples dataSamples = POIDataSamples.getPOIFSInstance();
+
+    public void testOleNative() throws IOException, Ole10NativeException {
+        POIFSFileSystem fs = new POIFSFileSystem(dataSamples.openResourceAsStream("oleObject1.bin"));
+
+        Ole10Native ole = Ole10Native.createFromEmbeddedOleObject(fs);
+
+        assertEquals("File1.svg", ole.getLabel());
+        assertEquals("D:\\Documents and Settings\\rsc\\My Documents\\file1.svg", ole.getCommand());
+    }
+}
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestPOIFSDocumentPath.java b/src/testcases/org/apache/poi/poifs/filesystem/TestPOIFSDocumentPath.java
index 5c8ea88..fef200f 100644
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestPOIFSDocumentPath.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestPOIFSDocumentPath.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,39 +14,23 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.filesystem;
 
-import junit.framework.*;
+import junit.framework.TestCase;
 
 /**
  * Class to test POIFSDocumentPath functionality
  *
  * @author Marc Johnson
  */
+public final class TestPOIFSDocumentPath extends TestCase {
 
-public class TestPOIFSDocumentPath
-    extends TestCase
-{
-
-    /**
-     * Constructor TestPOIFSDocumentPath
-     *
-     * @param name
-     */
-
-    public TestPOIFSDocumentPath(String name)
-    {
-        super(name);
-    }
 
     /**
      * Test default constructor
      */
-
-    public void testDefaultConstructor()
-    {
+    public void testDefaultConstructor() {
         POIFSDocumentPath path = new POIFSDocumentPath();
 
         assertEquals(0, path.length());
@@ -56,9 +39,7 @@
     /**
      * Test full path constructor
      */
-
-    public void testFullPathConstructor()
-    {
+    public void testFullPathConstructor() {
         String[] components =
         {
             "foo", "bar", "foobar", "fubar"
@@ -125,9 +106,7 @@
     /**
      * Test relative path constructor
      */
-
-    public void testRelativePathConstructor()
-    {
+    public void testRelativePathConstructor() {
         String[] initialComponents =
         {
             "a", "b", "c"
@@ -186,24 +165,40 @@
                 }
             }
 
-            // test weird variants
+            // Test weird variants
+            
+            // This one is allowed, even if it's really odd
             assertEquals(n, new POIFSDocumentPath(base, null).length());
+            new POIFSDocumentPath(base, new String[]
+            {
+                 "fu", ""
+            });
+            
+            // This one is allowed too
+            new POIFSDocumentPath(base, new String[]
+            {
+                 "", "fu"
+            });
+            
+            // This one shouldn't be allowed
             try
             {
                 new POIFSDocumentPath(base, new String[]
                 {
-                    "fu", ""
+                    "fu", null
                 });
                 fail("should have caught IllegalArgumentException");
             }
             catch (IllegalArgumentException ignored)
             {
             }
+            
+            // Ditto
             try
             {
                 new POIFSDocumentPath(base, new String[]
                 {
-                    "fu", null
+                    null, "fu"
                 });
                 fail("should have caught IllegalArgumentException");
             }
@@ -216,9 +211,7 @@
     /**
      * test equality
      */
-
-    public void testEquality()
-    {
+    public void testEquality() {
         POIFSDocumentPath   a1    = new POIFSDocumentPath();
         POIFSDocumentPath   a2    = new POIFSDocumentPath(null);
         POIFSDocumentPath   a3    = new POIFSDocumentPath(new String[ 0 ]);
@@ -318,17 +311,4 @@
             }
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.eventfilesystem.POIFSDocumentPath");
-        junit.textui.TestRunner.run(TestPOIFSDocumentPath.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestPOIFSFileSystem.java b/src/testcases/org/apache/poi/poifs/filesystem/TestPOIFSFileSystem.java
index 4a948ba..aa610bc 100755
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestPOIFSFileSystem.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestPOIFSFileSystem.java
@@ -17,22 +17,32 @@
 
 package org.apache.poi.poifs.filesystem;
 
+import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.Iterator;
 
 import junit.framework.TestCase;
 
+import org.apache.poi.POIDataSamples;
 import org.apache.poi.hssf.HSSFTestDataSamples;
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
+import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.storage.BATBlock;
+import org.apache.poi.poifs.storage.BlockAllocationTableReader;
+import org.apache.poi.poifs.storage.HeaderBlock;
+import org.apache.poi.poifs.storage.RawDataBlockList;
 
 /**
  * Tests for POIFSFileSystem
- * 
+ *
  * @author Josh Micich
  */
 public final class TestPOIFSFileSystem extends TestCase {
+   private POIDataSamples _samples = POIDataSamples.getPOIFSInstance();
+   
 
 	/**
 	 * Mock exception used to ensure correct error handling
@@ -44,7 +54,7 @@
 	}
 	/**
 	 * Helps facilitate testing. Keeps track of whether close() was called.
-	 * Also can throw an exception at a specific point in the stream. 
+	 * Also can throw an exception at a specific point in the stream.
 	 */
 	private static final class TestIS extends InputStream {
 
@@ -87,15 +97,14 @@
 			return _isClosed;
 		}
 	}
-	
+
 	/**
 	 * Test for undesired behaviour observable as of svn revision 618865 (5-Feb-2008).
 	 * POIFSFileSystem was not closing the input stream.
 	 */
 	public void testAlwaysClose() {
-		
 		TestIS testIS;
-	
+
 		// Normal case - read until EOF and close
 		testIS = new TestIS(openSampleStream("13224.xls"), -1);
 		try {
@@ -104,7 +113,7 @@
 			throw new RuntimeException(e);
 		}
 		assertTrue("input stream was not closed", testIS.isClosed());
-		
+
 		// intended to crash after reading 10000 bytes
 		testIS = new TestIS(openSampleStream("13224.xls"), 10000);
 		try {
@@ -116,14 +125,13 @@
 			// expected
 		}
 		assertTrue("input stream was not closed", testIS.isClosed()); // but still should close
-		
 	}
-	
+
 	/**
 	 * Test for bug # 48898 - problem opening an OLE2
 	 *  file where the last block is short (i.e. not a full
 	 *  multiple of 512 bytes)
-	 *  
+	 *
 	 * As yet, this problem remains. One school of thought is
 	 *  not not issue an EOF when we discover the last block
 	 *  is short, but this seems a bit wrong.
@@ -132,26 +140,192 @@
 	 */
 	public void testShortLastBlock() throws Exception {
 		String[] files = new String[] {
-			"ShortLastBlock.qwp", "ShortLastBlock.wps"	
+			"ShortLastBlock.qwp", "ShortLastBlock.wps"
 		};
-		String pdirname = System.getProperty("POIFS.testdata.path");
 
 		for(int i=0; i<files.length; i++) {
-			File f = new File(pdirname, files[i]);
-			assertTrue(f.exists());
-			
 			// Open the file up
 			POIFSFileSystem fs = new POIFSFileSystem(
-					new FileInputStream(f)
+			    _samples.openResourceAsStream(files[i])
 			);
-			
+
 			// Write it into a temp output array
 			ByteArrayOutputStream baos = new ByteArrayOutputStream();
 			fs.writeFilesystem(baos);
-			
+
 			// Check sizes
 		}
 	}
+	
+	/**
+	 * Check that we do the right thing when the list of which
+	 *  sectors are BAT blocks points off the list of
+	 *  sectors that exist in the file.
+	 */
+	public void testFATandDIFATsectors() throws Exception {
+      // Open the file up
+      try {
+         POIFSFileSystem fs = new POIFSFileSystem(
+             _samples.openResourceAsStream("ReferencesInvalidSectors.mpp")
+         );
+         fail("File is corrupt and shouldn't have been opened");
+      } catch(IOException e) {
+         String msg = e.getMessage();
+         assertTrue(msg.startsWith("Your file contains 695 sectors"));
+      }
+	}
+	
+	/**
+	 * Tests that we can write and read a file that contains XBATs
+	 *  as well as regular BATs.
+	 * However, because a file needs to be at least 6.875mb big
+	 *  to have an XBAT in it, we don't have a test one. So, generate it.
+	 */
+	public void testBATandXBAT() throws Exception {
+	   byte[] hugeStream = new byte[8*1024*1024];
+	   POIFSFileSystem fs = new POIFSFileSystem();
+	   fs.getRoot().createDocument(
+	         "BIG", new ByteArrayInputStream(hugeStream)
+	   );
+	   
+	   ByteArrayOutputStream baos = new ByteArrayOutputStream();
+	   fs.writeFilesystem(baos);
+	   byte[] fsData = baos.toByteArray();
+	   
+	   
+	   // Check the header was written properly
+	   InputStream inp = new ByteArrayInputStream(fsData); 
+	   HeaderBlock header = new HeaderBlock(inp);
+	   assertEquals(109+21, header.getBATCount());
+	   assertEquals(1, header.getXBATCount());
+	   
+	   
+	   // We should have 21 BATs in the XBAT
+	   ByteBuffer xbatData = ByteBuffer.allocate(512);
+	   xbatData.put(fsData, (1+header.getXBATIndex())*512, 512);
+	   xbatData.position(0);
+	   BATBlock xbat = BATBlock.createBATBlock(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, xbatData);
+	   for(int i=0; i<21; i++) {
+	      assertTrue(xbat.getValueAt(i) != POIFSConstants.UNUSED_BLOCK);
+	   }
+	   for(int i=21; i<127; i++) {
+	      assertEquals(POIFSConstants.UNUSED_BLOCK, xbat.getValueAt(i));
+	   }
+	   assertEquals(POIFSConstants.END_OF_CHAIN, xbat.getValueAt(127));
+	   
+	   
+	   // Load the blocks and check with that
+	   RawDataBlockList blockList = new RawDataBlockList(inp, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+	   assertEquals(fsData.length / 512, blockList.blockCount() + 1); // Header not counted
+	   new BlockAllocationTableReader(header.getBigBlockSize(),
+            header.getBATCount(),
+            header.getBATArray(),
+            header.getXBATCount(),
+            header.getXBATIndex(),
+            blockList);
+      assertEquals(fsData.length / 512, blockList.blockCount() + 1); // Header not counted
+      
+	   // Now load it and check
+	   fs = null;
+	   fs = new POIFSFileSystem(
+	         new ByteArrayInputStream(fsData)
+	   );
+	   
+	   DirectoryNode root = fs.getRoot();
+	   assertEquals(1, root.getEntryCount());
+	   DocumentNode big = (DocumentNode)root.getEntry("BIG");
+	   assertEquals(hugeStream.length, big.getSize());
+	}
+	
+	/**
+	 * Most OLE2 files use 512byte blocks. However, a small number
+	 *  use 4k blocks. Check that we can open these.
+	 */
+	public void test4KBlocks() throws Exception {
+      POIDataSamples _samples = POIDataSamples.getPOIFSInstance();
+	   InputStream inp = _samples.openResourceAsStream("BlockSize4096.zvi");
+	   
+	   // First up, check that we can process the header properly
+      HeaderBlock header_block = new HeaderBlock(inp);
+      POIFSBigBlockSize bigBlockSize = header_block.getBigBlockSize();
+      assertEquals(4096, bigBlockSize.getBigBlockSize());
+      
+      // Check the fat info looks sane
+      assertEquals(1, header_block.getBATArray().length);
+      assertEquals(1, header_block.getBATCount());
+      assertEquals(0, header_block.getXBATCount());
+      
+      // Now check we can get the basic fat
+      RawDataBlockList data_blocks = new RawDataBlockList(inp, bigBlockSize);
+
+	   
+	   // Now try and open properly
+	   POIFSFileSystem fs = new POIFSFileSystem(
+	         _samples.openResourceAsStream("BlockSize4096.zvi")
+	   );
+	   assertTrue(fs.getRoot().getEntryCount() > 3);
+	   
+	   // Check we can get at all the contents
+	   checkAllDirectoryContents(fs.getRoot());
+	   
+	   
+	   // Finally, check we can do a similar 512byte one too
+	   fs = new POIFSFileSystem(
+            _samples.openResourceAsStream("BlockSize512.zvi")
+      );
+      assertTrue(fs.getRoot().getEntryCount() > 3);
+      checkAllDirectoryContents(fs.getRoot());
+	}
+	private void checkAllDirectoryContents(DirectoryEntry dir) throws IOException {
+	   for(Entry entry : dir) {
+	      if(entry instanceof DirectoryEntry) {
+	         checkAllDirectoryContents((DirectoryEntry)entry);
+	      } else {
+	         DocumentNode doc = (DocumentNode) entry;
+	         DocumentInputStream dis = new DocumentInputStream(doc);
+	         int numBytes = dis.available();
+	         byte[] data = new byte [numBytes];
+            dis.read(data);
+	      }
+	   }
+	}
+	
+	/**
+	 * Test that we can open files that come via Lotus notes.
+	 * These have a top level directory without a name....
+	 */
+	public void testNotesOLE2Files() throws Exception {
+      POIDataSamples _samples = POIDataSamples.getPOIFSInstance();
+      
+      // Open the file up
+      POIFSFileSystem fs = new POIFSFileSystem(
+          _samples.openResourceAsStream("Notes.ole2")
+      );
+      
+      // Check the contents
+      assertEquals(1, fs.getRoot().getEntryCount());
+      
+      Entry entry = fs.getRoot().getEntries().next();
+      assertTrue(entry.isDirectoryEntry());
+      assertTrue(entry instanceof DirectoryEntry);
+      
+      // The directory lacks a name!
+      DirectoryEntry dir = (DirectoryEntry)entry;
+      assertEquals("", dir.getName());
+      
+      // Has two children
+      assertEquals(2, dir.getEntryCount());
+      
+      // Check them
+      Iterator<Entry> it = dir.getEntries();
+      entry = it.next();
+      assertEquals(true, entry.isDocumentEntry());
+      assertEquals("\u0001Ole10Native", entry.getName());
+      
+      entry = it.next();
+      assertEquals(true, entry.isDocumentEntry());
+      assertEquals("\u0001CompObj", entry.getName());
+	}
 
 	private static InputStream openSampleStream(String sampleFileName) {
 		return HSSFTestDataSamples.openSampleFileStream(sampleFileName);
diff --git a/src/testcases/org/apache/poi/poifs/filesystem/TestPropertySorter.java b/src/testcases/org/apache/poi/poifs/filesystem/TestPropertySorter.java
index ecff677..2c30d1b 100644
--- a/src/testcases/org/apache/poi/poifs/filesystem/TestPropertySorter.java
+++ b/src/testcases/org/apache/poi/poifs/filesystem/TestPropertySorter.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -20,14 +19,13 @@
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Iterator;
+import java.util.List;
 
 import junit.framework.ComparisonFailure;
 import junit.framework.TestCase;
@@ -62,7 +60,7 @@
             throw new RuntimeException(e);
         }
     }
-    
+
     /**
      * Test sorting of properties in <code>DirectoryProperty</code>
      */
@@ -125,22 +123,22 @@
         DirectoryNode vba = (DirectoryNode)vba_project.getEntry(VBA);
         DirectoryProperty  p = (DirectoryProperty)vba.getProperty();
 
-        ArrayList lst = new ArrayList();
-        for (Iterator it = p.getChildren(); it.hasNext();){
-            Property ch = (Property)it.next();
+        List<Property> lst = new ArrayList<Property>();
+        for (Iterator<Property> it = p.getChildren(); it.hasNext();){
+            Property ch = it.next();
             lst.add(ch);
         }
-        return (Property [])lst.toArray(new Property[ 0 ]);
+        return lst.toArray(new Property[ 0 ]);
     }
 
     /**
      * Old version of case-sensitive PropertyComparator to demonstrate the problem
      */
-    private static final Comparator OldCaseSensitivePropertyComparator = new Comparator() {
+    private static final Comparator<Property> OldCaseSensitivePropertyComparator = new Comparator<Property>() {
 
-        public int compare(Object o1, Object o2) {
-            String name1  = (( Property ) o1).getName();
-            String name2  = (( Property ) o2).getName();
+        public int compare(Property o1, Property o2) {
+            String name1  = o1.getName();
+            String name2  = o2.getName();
             int result = name1.length() - name2.length();
 
             if (result == 0) {
diff --git a/src/testcases/org/apache/poi/poifs/property/AllPOIFSPropertyTests.java b/src/testcases/org/apache/poi/poifs/property/AllPOIFSPropertyTests.java
index a5459ed..99d4c99 100755
--- a/src/testcases/org/apache/poi/poifs/property/AllPOIFSPropertyTests.java
+++ b/src/testcases/org/apache/poi/poifs/property/AllPOIFSPropertyTests.java
@@ -1,3 +1,20 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
 package org.apache.poi.poifs.property;
 
 import junit.framework.Test;
@@ -11,7 +28,7 @@
 public final class AllPOIFSPropertyTests {
 
     public static Test suite() {
-        TestSuite result = new TestSuite("Tests for org.apache.poi.poifs.property");
+        TestSuite result = new TestSuite(AllPOIFSPropertyTests.class.getName());
         result.addTestSuite(TestDirectoryProperty.class);
         result.addTestSuite(TestDocumentProperty.class);
         result.addTestSuite(TestPropertyFactory.class);
diff --git a/src/testcases/org/apache/poi/poifs/property/TestDirectoryProperty.java b/src/testcases/org/apache/poi/poifs/property/TestDirectoryProperty.java
index 20605a7..9569de1 100644
--- a/src/testcases/org/apache/poi/poifs/property/TestDirectoryProperty.java
+++ b/src/testcases/org/apache/poi/poifs/property/TestDirectoryProperty.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,63 +14,41 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.property;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
 
-import java.util.*;
+import org.apache.poi.poifs.storage.RawDataUtil;
 
-import junit.framework.*;
-
-import org.apache.poi.poifs.common.POIFSConstants;
+import junit.framework.TestCase;
 
 /**
  * Class to test DirectoryProperty functionality
  *
  * @author Marc Johnson
  */
-
-public class TestDirectoryProperty
-    extends TestCase
-{
+public final class TestDirectoryProperty extends TestCase {
     private DirectoryProperty _property;
     private byte[]            _testblock;
 
     /**
-     * Constructor TestDirectoryProperty
-     *
-     * @param name
-     */
-
-    public TestDirectoryProperty(String name)
-    {
-        super(name);
-    }
-
-    /**
      * Test constructing DirectoryProperty
-     *
-     * @exception IOException
      */
-
-    public void testConstructor()
-        throws IOException
-    {
+    public void testConstructor() throws IOException {
         createBasicDirectoryProperty();
         verifyProperty();
     }
 
     /**
      * Test pre-write functionality
-     *
-     * @exception IOException
      */
-
-    public void testPreWrite()
-        throws IOException
-    {
+    public void testPreWrite() throws IOException {
         createBasicDirectoryProperty();
         _property.preWrite();
 
@@ -119,9 +96,7 @@
         }
     }
 
-    private void verifyChildren(int count)
-        throws IOException
-    {
+    private void verifyChildren(int count) {
         Iterator iter     = _property.getChildren();
         List     children = new ArrayList();
 
@@ -175,8 +150,7 @@
         }
     }
 
-    private void createBasicDirectoryProperty()
-    {
+    private void createBasicDirectoryProperty() {
         String name = "MyDirectory";
 
         _property  = new DirectoryProperty(name);
@@ -209,9 +183,7 @@
         }
     }
 
-    private void verifyProperty()
-        throws IOException
-    {
+    private void verifyProperty() throws IOException {
         ByteArrayOutputStream stream = new ByteArrayOutputStream(512);
 
         _property.writeData(stream);
@@ -225,15 +197,7 @@
         }
     }
 
-    /**
-     * Test addChild
-     *
-     * @exception IOException
-     */
-
-    public void testAddChild()
-        throws IOException
-    {
+    public void testAddChild() throws IOException {
         createBasicDirectoryProperty();
         _property.addChild(new LocalProperty(1));
         _property.addChild(new LocalProperty(2));
@@ -260,15 +224,7 @@
         _property.addChild(new LocalProperty(3));
     }
 
-    /**
-     * Test deleteChild
-     *
-     * @exception IOException
-     */
-
-    public void testDeleteChild()
-        throws IOException
-    {
+    public void testDeleteChild() throws IOException {
         createBasicDirectoryProperty();
         Property p1 = new LocalProperty(1);
 
@@ -288,15 +244,7 @@
         _property.addChild(new LocalProperty(1));
     }
 
-    /**
-     * Test changeName
-     *
-     * @exception IOException
-     */
-
-    public void testChangeName()
-        throws IOException
-    {
+    public void testChangeName() throws IOException {
         createBasicDirectoryProperty();
         Property p1           = new LocalProperty(1);
         String   originalName = p1.getName();
@@ -314,88 +262,35 @@
         assertTrue(_property.changeName(p1, originalName));
     }
 
-    /**
-     * Test reading constructor
-     *
-     * @exception IOException
-     */
-
-    public void testReadingConstructor()
-        throws IOException
-    {
-        byte[] input =
-        {
-            ( byte ) 0x42, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x45, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x08, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xC0, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x46,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xC0, ( byte ) 0x5C, ( byte ) 0xE8, ( byte ) 0x23,
-            ( byte ) 0x9E, ( byte ) 0x6B, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00
+    public void testReadingConstructor() {
+        String[] input = {
+            "42 00 6F 00 6F 00 74 00 20 00 45 00 6E 00 74 00 72 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00",
+            "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+            "16 00 01 01 FF FF FF FF FF FF FF FF 02 00 00 00 20 08 02 00 00 00 00 00 C0 00 00 00 00 00 00 46",
+            "00 00 00 00 00 00 00 00 00 00 00 00 C0 5C E8 23 9E 6B C1 01 FE FF FF FF 00 00 00 00 00 00 00 00",
         };
-
-        verifyReadingProperty(0, input, 0, "Boot Entry");
+        verifyReadingProperty(0, RawDataUtil.decode(input), 0, "Boot Entry");
     }
 
-    private void verifyReadingProperty(int index, byte [] input, int offset,
-                                       String name)
-        throws IOException
-    {
-        DirectoryProperty     property = new DirectoryProperty(index, input,
-                                             offset);
-        ByteArrayOutputStream stream   = new ByteArrayOutputStream(128);
-        byte[]                expected = new byte[ 128 ];
+    private static void verifyReadingProperty(int index, byte[] input, int offset, String name) {
+        DirectoryProperty property = new DirectoryProperty(index, input, offset);
+        ByteArrayOutputStream stream = new ByteArrayOutputStream(128);
+        byte[] expected = new byte[128];
 
         System.arraycopy(input, offset, expected, 0, 128);
-        property.writeData(stream);
+        try {
+            property.writeData(stream);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
         byte[] output = stream.toByteArray();
 
         assertEquals(128, output.length);
-        for (int j = 0; j < 128; j++)
-        {
-            assertEquals("mismatch at offset " + j, expected[ j ],
-                         output[ j ]);
+        for (int j = 0; j < 128; j++) {
+            assertEquals("mismatch at offset " + j, expected[j], output[j]);
         }
         assertEquals(index, property.getIndex());
         assertEquals(name, property.getName());
         assertTrue(!property.getChildren().hasNext());
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.property.DirectoryProperty");
-        junit.textui.TestRunner.run(TestDirectoryProperty.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/property/TestDocumentProperty.java b/src/testcases/org/apache/poi/poifs/property/TestDocumentProperty.java
index 8bf8d00..41acc76 100644
--- a/src/testcases/org/apache/poi/poifs/property/TestDocumentProperty.java
+++ b/src/testcases/org/apache/poi/poifs/property/TestDocumentProperty.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,49 +14,24 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.property;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 
-import java.util.*;
+import org.apache.poi.poifs.storage.RawDataUtil;
 
-import junit.framework.*;
-
-import org.apache.poi.poifs.property.DocumentProperty;
+import junit.framework.TestCase;
 
 /**
  * Class to test DocumentProperty functionality
  *
  * @author Marc Johnson
  */
+public final class TestDocumentProperty extends TestCase {
 
-public class TestDocumentProperty
-    extends TestCase
-{
-
-    /**
-     * Constructor TestDocumentProperty
-     *
-     * @param name
-     */
-
-    public TestDocumentProperty(String name)
-    {
-        super(name);
-    }
-
-    /**
-     * Test constructing DocumentPropertys
-     *
-     * @exception IOException
-     */
-
-    public void testConstructor()
-        throws IOException
-    {
-
+    public void testConstructor() throws IOException {
         // test with short name, small file
         verifyProperty("foo", 1234);
 
@@ -71,160 +45,34 @@
         verifyProperty("A.really.long.long.long.name123", 4096);
     }
 
-    /**
-     * Test reading constructor
-     *
-     * @exception IOException
-     */
-
-    public void testReadingConstructor()
-        throws IOException
-    {
-        byte[] input =
-        {
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x45, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x08, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xC0, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x46,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xC0, ( byte ) 0x5C, ( byte ) 0xE8, ( byte ) 0x23,
-            ( byte ) 0x9E, ( byte ) 0x6B, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-
-            ( byte ) 0x57, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6B, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6B, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x53, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x53, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x38, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00
+    public void testReadingConstructor() throws IOException {
+        String[] hexData = {
+            "52 00 6F 00 6F 00 74 00 20 00 45 00 6E 00 74 00 72 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00",
+            "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+            "16 00 05 01 FF FF FF FF FF FF FF FF 02 00 00 00 20 08 02 00 00 00 00 00 C0 00 00 00 00 00 00 46",
+            "00 00 00 00 00 00 00 00 00 00 00 00 C0 5C E8 23 9E 6B C1 01 FE FF FF FF 00 00 00 00 00 00 00 00",
+            "57 00 6F 00 72 00 6B 00 62 00 6F 00 6F 00 6B 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+            "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+            "12 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+            "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 10 00 00 00 00 00 00",
+            "05 00 53 00 75 00 6D 00 6D 00 61 00 72 00 79 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00",
+            "69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+            "28 00 02 01 01 00 00 00 03 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+            "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 08 00 00 00 00 10 00 00 00 00 00 00",
+            "05 00 44 00 6F 00 63 00 75 00 6D 00 65 00 6E 00 74 00 53 00 75 00 6D 00 6D 00 61 00 72 00 79 00",
+            "49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00",
+            "38 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+            "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 10 00 00 00 00 10 00 00 00 00 00 00",
         };
+        byte[] input = RawDataUtil.decode(hexData);
 
         verifyReadingProperty(1, input, 128, "Workbook");
         verifyReadingProperty(2, input, 256, "\005SummaryInformation");
-        verifyReadingProperty(3, input, 384,
-                              "\005DocumentSummaryInformation");
+        verifyReadingProperty(3, input, 384, "\005DocumentSummaryInformation");
     }
 
-    private void verifyReadingProperty(int index, byte [] input, int offset,
-                                       String name)
-        throws IOException
-    {
+    private void verifyReadingProperty(int index, byte[] input, int offset, String name)
+            throws IOException {
         DocumentProperty      property = new DocumentProperty(index, input,
                                              offset);
         ByteArrayOutputStream stream   = new ByteArrayOutputStream(128);
@@ -244,9 +92,7 @@
         assertEquals(name, property.getName());
     }
 
-    private void verifyProperty(String name, int size)
-        throws IOException
-    {
+    private void verifyProperty(String name, int size) throws IOException {
         DocumentProperty property = new DocumentProperty(name, size);
 
         if (size >= 4096)
@@ -309,17 +155,4 @@
                          output[ j ]);
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.property.DocumentProperty");
-        junit.textui.TestRunner.run(TestDocumentProperty.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/property/TestPropertyFactory.java b/src/testcases/org/apache/poi/poifs/property/TestPropertyFactory.java
index 20ff82e..e6d2c65 100644
--- a/src/testcases/org/apache/poi/poifs/property/TestPropertyFactory.java
+++ b/src/testcases/org/apache/poi/poifs/property/TestPropertyFactory.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,2225 +14,383 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.property;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.List;
 
-import java.util.*;
-
-import junit.framework.*;
+import junit.framework.TestCase;
 
 import org.apache.poi.poifs.storage.RawDataBlock;
+import org.apache.poi.poifs.storage.RawDataUtil;
 
 /**
  * Class to test PropertyFactory functionality
  *
  * @author Marc Johnson
  */
+public final class TestPropertyFactory extends TestCase {
 
-public class TestPropertyFactory
-    extends TestCase
-{
+    public void testConvertToProperties() throws IOException {
 
-    /**
-     * Constructor TestPropertyFactory
-     *
-     * @param name
-     */
+		// real data from a real file!
+		String[] hexData = {
+			"52 00 6F 00 6F 00 74 00 20 00 45 00 6E 00 74 00 72 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"16 00 05 00 FF FF FF FF FF FF FF FF 0D 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 C0 47 A4 DE EC 65 C1 01 03 00 00 00 40 0C 00 00 00 00 00 00",
+			"44 00 6F 00 63 00 75 00 6D 00 65 00 6E 00 74 00 20 00 44 00 65 00 74 00 61 00 69 00 6C 00 73 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 A0 7F 29 08 59 56 C1 01 C0 20 31 08 59 56 C1 01 00 00 00 00 00 00 00 00 00 00 00 00",
+			"43 00 72 00 65 00 61 00 74 00 69 00 6F 00 6E 00 20 00 4E 00 61 00 6D 00 65 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1C 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 2C 00 00 00 00 00 00 00",
+			"43 00 72 00 65 00 61 00 74 00 69 00 6F 00 6E 00 20 00 44 00 61 00 74 00 65 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1C 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 0A 00 00 00 00 00 00 00",
+			"4C 00 61 00 73 00 74 00 20 00 53 00 61 00 76 00 65 00 64 00 20 00 44 00 61 00 74 00 65 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"20 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 0A 00 00 00 00 00 00 00",
+			"44 00 61 00 74 00 65 00 20 00 46 00 69 00 6C 00 65 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"16 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 0A 00 00 00 00 00 00 00",
+			"44 00 6F 00 63 00 75 00 6D 00 65 00 6E 00 74 00 20 00 56 00 65 00 72 00 73 00 69 00 6F 00 6E 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 04 00 00 00 00 00 00 00",
+			"42 00 61 00 63 00 63 00 68 00 75 00 73 00 20 00 44 00 65 00 61 00 6C 00 20 00 4E 00 75 00 6D 00",
+			"62 00 65 00 72 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 04 00 00 00 00 00 00 00",
+			"44 00 6F 00 63 00 75 00 6D 00 65 00 6E 00 74 00 20 00 4C 00 6F 00 63 00 6B 00 65 00 64 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"20 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 04 00 00 00 00 00 00 00",
+			"44 00 6F 00 63 00 75 00 6D 00 65 00 6E 00 74 00 20 00 44 00 65 00 61 00 6C 00 20 00 54 00 79 00",
+			"70 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"26 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 06 00 00 00 00 00 00 00",
+			"44 00 6F 00 63 00 75 00 6D 00 65 00 6E 00 74 00 20 00 41 00 75 00 64 00 69 00 74 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1E 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 C0 20 31 08 59 56 C1 01 80 48 3A 08 59 56 C1 01 00 00 00 00 00 00 00 00 00 00 00 00",
+			"55 00 73 00 65 00 72 00 20 00 41 00 75 00 64 00 69 00 74 00 20 00 54 00 72 00 61 00 69 00 6C 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 42 00 00 00 00 00 00 00",
+			"43 00 6F 00 6E 00 74 00 72 00 61 00 63 00 74 00 20 00 47 00 65 00 6E 00 65 00 72 00 61 00 74 00",
+			"69 00 6F 00 6E 00 20 00 49 00 6E 00 66 00 6F 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"32 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 80 48 3A 08 59 56 C1 01 80 48 3A 08 59 56 C1 01 00 00 00 00 00 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 01 01 FF FF FF FF FF FF FF FF 19 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 80 48 3A 08 59 56 C1 01 80 B2 52 08 59 56 C1 01 00 00 00 00 00 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 44 00 65 00 73 00 63 00 72 00 69 00 70 00 74 00 69 00 6F 00 6E 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 00 16 00 00 00 26 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0A 00 00 00 09 00 00 00 00 00 00 00",
+			"53 00 61 00 6C 00 65 00 73 00 20 00 41 00 72 00 65 00 61 00 20 00 43 00 6F 00 64 00 65 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"20 00 02 01 12 00 00 00 2A 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0B 00 00 00 04 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 43 00 75 00 72 00 72 00 65 00 6E 00 63 00 79 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1C 00 02 01 1B 00 00 00 20 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0C 00 00 00 07 00 00 00 00 00 00 00",
+			"4F 00 75 00 74 00 62 00 6F 00 75 00 6E 00 64 00 20 00 54 00 72 00 61 00 76 00 65 00 6C 00 20 00",
+			"44 00 61 00 74 00 65 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2C 00 02 01 25 00 00 00 27 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0D 00 00 00 21 00 00 00 00 00 00 00",
+			"4D 00 61 00 78 00 69 00 6D 00 75 00 6D 00 20 00 53 00 74 00 61 00 79 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1A 00 02 01 14 00 00 00 10 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0E 00 00 00 05 00 00 00 00 00 00 00",
+			"4D 00 61 00 78 00 69 00 6D 00 75 00 6D 00 20 00 53 00 74 00 61 00 79 00 20 00 50 00 65 00 72 00",
+			"69 00 6F 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 00 18 00 00 00 23 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0F 00 00 00 04 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 54 00 79 00 70 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 00 15 00 00 00 28 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 10 00 00 00 04 00 00 00 00 00 00 00",
+			"53 00 75 00 62 00 20 00 44 00 65 00 61 00 6C 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"12 00 02 01 2E 00 00 00 1F 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 11 00 00 00 04 00 00 00 00 00 00 00",
+			"43 00 6F 00 6D 00 6D 00 69 00 73 00 73 00 69 00 6F 00 6E 00 20 00 56 00 61 00 6C 00 75 00 65 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 12 00 00 00 04 00 00 00 00 00 00 00",
+			"46 00 61 00 72 00 65 00 20 00 54 00 79 00 70 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 13 00 00 00 04 00 00 00 00 00 00 00",
+			"46 00 55 00 44 00 20 00 47 00 72 00 69 00 64 00 20 00 44 00 69 00 6D 00 65 00 6E 00 73 00 69 00",
+			"6F 00 6E 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 14 00 00 00 04 00 00 00 00 00 00 00",
+			"46 00 55 00 44 00 20 00 47 00 72 00 69 00 64 00 20 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00",
+			"74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2A 00 02 01 0F 00 00 00 1A 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 00 00 00",
+			"44 00 6F 00 75 00 62 00 6C 00 65 00 20 00 44 00 65 00 61 00 6C 00 69 00 6E 00 67 00 20 00 49 00",
+			"6E 00 64 00 69 00 63 00 61 00 74 00 6F 00 72 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"32 00 02 01 11 00 00 00 21 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 15 00 00 00 04 00 00 00 00 00 00 00",
+			"42 00 75 00 73 00 69 00 6E 00 65 00 73 00 73 00 20 00 54 00 79 00 70 00 65 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1C 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 16 00 00 00 04 00 00 00 00 00 00 00",
+			"55 00 6D 00 62 00 72 00 65 00 6C 00 6C 00 61 00 20 00 4C 00 69 00 6E 00 6B 00 73 00 20 00 61 00",
+			"6E 00 64 00 20 00 50 00 61 00 73 00 73 00 65 00 6E 00 67 00 65 00 72 00 73 00 00 00 00 00 00 00",
+			"3C 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 00 00 00",
+			"41 00 67 00 65 00 6E 00 74 00 73 00 20 00 4E 00 61 00 6D 00 65 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"18 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 17 00 00 00 04 00 00 00 00 00 00 00",
+			"4E 00 75 00 6D 00 62 00 65 00 72 00 20 00 6F 00 66 00 20 00 50 00 61 00 73 00 73 00 65 00 6E 00",
+			"67 00 65 00 72 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2A 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18 00 00 00 04 00 00 00 00 00 00 00",
+			"41 00 4C 00 43 00 20 00 43 00 6F 00 64 00 65 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 00 00 00",
+			"43 00 6F 00 6E 00 73 00 6F 00 72 00 74 00 69 00 61 00 20 00 43 00 6F 00 64 00 65 00 73 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"20 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 00 00 00",
+			"43 00 68 00 69 00 6C 00 64 00 20 00 50 00 65 00 72 00 63 00 65 00 6E 00 74 00 61 00 67 00 65 00",
+			"20 00 50 00 65 00 72 00 6D 00 69 00 74 00 74 00 65 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"36 00 02 01 24 00 00 00 2C 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 19 00 00 00 04 00 00 00 00 00 00 00",
+			"50 00 65 00 72 00 63 00 65 00 6E 00 74 00 61 00 67 00 65 00 20 00 6F 00 66 00 20 00 59 00 69 00",
+			"65 00 6C 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1A 00 00 00 04 00 00 00 00 00 00 00",
+			"4E 00 65 00 74 00 20 00 52 00 65 00 6D 00 69 00 74 00 20 00 50 00 65 00 72 00 6D 00 69 00 74 00",
+			"74 00 65 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 29 00 00 00 22 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1B 00 00 00 04 00 00 00 00 00 00 00",
+			"49 00 6E 00 66 00 61 00 6E 00 74 00 20 00 44 00 69 00 73 00 63 00 6F 00 75 00 6E 00 74 00 20 00",
+			"50 00 65 00 72 00 6D 00 69 00 74 00 74 00 65 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"34 00 02 01 2D 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1C 00 00 00 04 00 00 00 00 00 00 00",
+			"49 00 6E 00 66 00 61 00 6E 00 74 00 20 00 44 00 69 00 73 00 63 00 6F 00 75 00 6E 00 74 00 20 00",
+			"56 00 61 00 6C 00 75 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2C 00 02 01 1E 00 00 00 2F 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1D 00 00 00 04 00 00 00 00 00 00 00",
+			"54 00 52 00 56 00 41 00 20 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 01 30 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1E 00 00 00 04 00 00 00 00 00 00 00",
+			"42 00 75 00 73 00 69 00 6E 00 65 00 73 00 73 00 20 00 4A 00 75 00 73 00 74 00 69 00 66 00 69 00",
+			"63 00 61 00 74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2E 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1F 00 00 00 04 00 00 00 00 00 00 00",
+			"53 00 75 00 72 00 63 00 68 00 61 00 72 00 67 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 01 17 00 00 00 1D 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 20 00 00 00 04 00 00 00 00 00 00 00",
+			"4E 00 61 00 74 00 75 00 72 00 65 00 20 00 6F 00 66 00 20 00 56 00 61 00 72 00 69 00 61 00 74 00",
+			"69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 21 00 00 00 50 00 00 00 00 00 00 00",
+			"4F 00 74 00 68 00 65 00 72 00 20 00 52 00 65 00 66 00 75 00 6E 00 64 00 20 00 54 00 65 00 78 00",
+			"74 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"24 00 02 01 0E 00 00 00 13 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 23 00 00 00 04 00 00 00 00 00 00 00",
+			"43 00 61 00 6E 00 63 00 65 00 6C 00 6C 00 61 00 74 00 69 00 6F 00 6E 00 20 00 46 00 65 00 65 00",
+			"20 00 50 00 65 00 72 00 63 00 65 00 6E 00 74 00 61 00 67 00 65 00 00 00 00 00 00 00 00 00 00 00",
+			"38 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 24 00 00 00 04 00 00 00 00 00 00 00",
+			"43 00 61 00 6E 00 63 00 65 00 6C 00 6C 00 61 00 74 00 69 00 6F 00 6E 00 20 00 46 00 65 00 65 00",
+			"20 00 46 00 69 00 78 00 65 00 64 00 20 00 56 00 61 00 6C 00 75 00 65 00 00 00 00 00 00 00 00 00",
+			"3A 00 02 01 2B 00 00 00 1C 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 25 00 00 00 04 00 00 00 00 00 00 00",
+			"43 00 61 00 6E 00 63 00 65 00 6C 00 6C 00 61 00 74 00 69 00 6F 00 6E 00 20 00 46 00 65 00 65 00",
+			"20 00 43 00 75 00 72 00 72 00 65 00 6E 00 63 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"34 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 26 00 00 00 07 00 00 00 00 00 00 00",
+			"52 00 65 00 6D 00 61 00 72 00 6B 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"10 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 00 00 00",
+			"4F 00 74 00 68 00 65 00 72 00 20 00 43 00 61 00 72 00 72 00 69 00 65 00 72 00 20 00 53 00 65 00",
+			"63 00 74 00 6F 00 72 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2C 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 27 00 00 00 04 00 00 00 00 00 00 00",
+			"50 00 72 00 6F 00 72 00 61 00 74 00 65 00 20 00 43 00 6F 00 6D 00 6D 00 65 00 6E 00 74 00 73 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 00 00 00",
+			"4E 00 65 00 67 00 6F 00 74 00 69 00 61 00 74 00 69 00 6F 00 6E 00 20 00 49 00 6E 00 66 00 6F 00",
+			"72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"30 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 80 B2 52 08 59 56 C1 01 80 B2 52 08 59 56 C1 01 00 00 00 00 00 00 00 00 00 00 00 00",
+			"52 00 65 00 73 00 74 00 72 00 69 00 63 00 74 00 65 00 64 00 20 00 43 00 61 00 72 00 72 00 69 00",
+			"65 00 72 00 73 00 20 00 26 00 20 00 53 00 74 00 6E 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"36 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 04 00 00 00 00 00 00 00",
+			"41 00 64 00 64 00 69 00 74 00 69 00 6F 00 6E 00 61 00 6C 00 20 00 43 00 6F 00 6D 00 6D 00 65 00",
+			"6E 00 74 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 04 00 00 00 00 00 00 00",
+			"52 00 65 00 76 00 65 00 6E 00 75 00 65 00 20 00 4D 00 61 00 6E 00 61 00 67 00 65 00 6D 00 65 00",
+			"6E 00 74 00 20 00 43 00 6F 00 6D 00 6D 00 65 00 6E 00 74 00 73 00 00 00 00 00 00 00 00 00 00 00",
+			"38 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 04 00 00 00 00 00 00 00",
+			"52 00 65 00 76 00 65 00 6E 00 75 00 65 00 20 00 4D 00 61 00 6E 00 61 00 67 00 65 00 6D 00 65 00",
+			"6E 00 74 00 20 00 52 00 65 00 66 00 65 00 72 00 65 00 6E 00 63 00 65 00 00 00 00 00 00 00 00 00",
+			"3A 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 04 00 00 00 00 00 00 00",
+			"4D 00 69 00 6E 00 69 00 6D 00 75 00 6D 00 20 00 53 00 74 00 61 00 79 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1A 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 04 00 00 00 00 00 00 00",
+			"43 00 72 00 65 00 61 00 74 00 65 00 64 00 20 00 42 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"16 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 1B 00 00 00 00 00 00 00",
+			"4F 00 6E 00 20 00 42 00 65 00 68 00 61 00 6C 00 66 00 20 00 4F 00 66 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1A 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 04 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 50 00 61 00 67 00 65 00 20 00 41 00 75 00 74 00 68 00 20 00 4C 00",
+			"6F 00 63 00 6B 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2A 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 10 00 00 00 00 00 00 00",
+			"47 00 72 00 6F 00 75 00 70 00 20 00 41 00 75 00 74 00 68 00 6F 00 72 00 69 00 73 00 61 00 74 00",
+			"69 00 6F 00 6E 00 20 00 49 00 6E 00 66 00 6F 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"32 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 80 B2 52 08 59 56 C1 01 40 DA 5B 08 59 56 C1 01 00 00 00 00 00 00 00 00 00 00 00 00",
+			"4C 00 61 00 73 00 74 00 20 00 49 00 73 00 73 00 75 00 65 00 64 00 20 00 47 00 72 00 6F 00 75 00",
+			"70 00 20 00 4E 00 75 00 6D 00 62 00 65 00 72 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"32 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 06 00 00 00 00 00 00 00",
+			"47 00 72 00 6F 00 75 00 70 00 20 00 4E 00 75 00 6D 00 62 00 65 00 72 00 73 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1C 00 00 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+		};
 
-    public TestPropertyFactory(String name)
-    {
-        super(name);
-    }
+		byte[] testdata = RawDataUtil.decode(hexData);
+		ByteArrayInputStream stream = new ByteArrayInputStream(testdata);
+		RawDataBlock[] raw_data = new RawDataBlock[testdata.length / 512];
 
-    /**
-     * Test executing convertToProperties
-     *
-     * @exception IOException
-     */
+		for (int j = 0; j < raw_data.length; j++) {
+			raw_data[j] = new RawDataBlock(stream);
+		}
+		List properties = PropertyFactory.convertToProperties(raw_data);
 
-    public void testConvertToProperties()
-        throws IOException
-    {
+		assertEquals(64, properties.size());
+		String[] names = {
+			"Root Entry", null, null, null, null, null, null, null, null,
+			null, null, null, null, "Deal Information", "Deal Description",
+			"Sales Area Code", "Deal Currency", "Outbound Travel Dates",
+			"Maximum Stay", "Maximum Stay Period", "Deal Type", "Sub Deal",
+			"Commission Value", "Fare Type", "FUD Grid Dimensions",
+			"FUD Grid Information", "Double Dealing Indicator",
+			"Business Type", "Umbrella Links and Passengers", "Agents Name",
+			"Number of Passengers", "ALC Codes", "Consortia Codes",
+			"Child Percentage Permitted", "Percentage of Yield",
+			"Net Remit Permitted", "Infant Discount Permitted",
+			"Infant Discount Value", "TRVA Information",
+			"Business Justification", "Surcharge", "Nature of Variation",
+			"Other Refund Text", "Cancellation Fee Percentage",
+			"Cancellation Fee Fixed Value", "Cancellation Fee Currency",
+			"Remarks", "Other Carrier Sectors", "Prorate Comments", null,
+			null, null, null, null, null, null, null, null, null, null, null,
+			null, null, null
+		};
+		assertEquals(64, names.length);
 
-        // real data from a real file!
-        byte[]               testdata =
-        {
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x45, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xC0, ( byte ) 0x47, ( byte ) 0xA4, ( byte ) 0xDE,
-            ( byte ) 0xEC, ( byte ) 0x65, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x40, ( byte ) 0x0C, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xA0, ( byte ) 0x7F, ( byte ) 0x29, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0xC0, ( byte ) 0x20, ( byte ) 0x31, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4E, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x53, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x76, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x56, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x42, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x68, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4E, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4C, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x6B, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x54, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x70, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x26, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x41, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xC0, ( byte ) 0x20, ( byte ) 0x31, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x80, ( byte ) 0x48, ( byte ) 0x3A, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x55, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x41, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x42, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x47, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x32, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x80, ( byte ) 0x48, ( byte ) 0x3A, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x80, ( byte ) 0x48, ( byte ) 0x3A, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x19, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x80, ( byte ) 0x48, ( byte ) 0x3A, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x80, ( byte ) 0xB2, ( byte ) 0x52, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x26, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x09, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x76, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x25, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x27, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x21, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x78, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x78, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0x18, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x23, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0x15, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x2E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x11, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x56, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x46, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x13, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x46, ( byte ) 0x00, ( byte ) 0x55, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x46, ( byte ) 0x00, ( byte ) 0x55, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x0F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x32, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x11, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x21, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x15, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x42, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x55, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4C, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x6B, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4E, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x18, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x17, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x18, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x4C, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x68, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x36, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x24, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x19, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x59, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x29, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x34, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x2D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x56, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x54, ( byte ) 0x00, ( byte ) 0x52, ( byte ) 0x00,
-            ( byte ) 0x56, ( byte ) 0x00, ( byte ) 0x41, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x30, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x42, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4A, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2E, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x68, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x17, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x56, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x21, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x68, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x78, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x24, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x0E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x13, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x23, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x38, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x24, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x78, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x56, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x2B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x25, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x34, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x26, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6B, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x68, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x27, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x30, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x80, ( byte ) 0xB2, ( byte ) 0x52, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x80, ( byte ) 0xB2, ( byte ) 0x52, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x26, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x36, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x76, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x4D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x38, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x76, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x4D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x52, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4D, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x42, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x1B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x42, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x68, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x68, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4C, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x6B, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x70, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x68, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x32, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x80, ( byte ) 0xB2, ( byte ) 0x52, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x40, ( byte ) 0xDA, ( byte ) 0x5B, ( byte ) 0x08,
-            ( byte ) 0x59, ( byte ) 0x56, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x70, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x32, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x70, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00
-        };
-        ByteArrayInputStream stream   = new ByteArrayInputStream(testdata);
-        RawDataBlock[]       raw_data =
-            new RawDataBlock[ testdata.length / 512 ];
+		boolean[] isRoot = {
+			true, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false
+		};
+		assertEquals(64, isRoot.length);
 
-        for (int j = 0; j < raw_data.length; j++)
-        {
-            raw_data[ j ] = new RawDataBlock(stream);
-        }
-        List properties = PropertyFactory.convertToProperties(raw_data);
+		boolean[] isDocument = {
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, true, true, true, true, true,
+			true, true, true, true, true, true, true, true, true, true, true,
+			true, true, true, true, true, true, true, true, true, true, true,
+			true, true, true, true, true, true, true, true, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false
+		};
+		assertEquals(64, isDocument.length);
 
-        assertEquals(64, properties.size());
-        String[] names =
-        {
-            "Root Entry", null, null, null, null, null, null, null, null,
-            null, null, null, null, "Deal Information", "Deal Description",
-            "Sales Area Code", "Deal Currency", "Outbound Travel Dates",
-            "Maximum Stay", "Maximum Stay Period", "Deal Type", "Sub Deal",
-            "Commission Value", "Fare Type", "FUD Grid Dimensions",
-            "FUD Grid Information", "Double Dealing Indicator",
-            "Business Type", "Umbrella Links and Passengers", "Agents Name",
-            "Number of Passengers", "ALC Codes", "Consortia Codes",
-            "Child Percentage Permitted", "Percentage of Yield",
-            "Net Remit Permitted", "Infant Discount Permitted",
-            "Infant Discount Value", "TRVA Information",
-            "Business Justification", "Surcharge", "Nature of Variation",
-            "Other Refund Text", "Cancellation Fee Percentage",
-            "Cancellation Fee Fixed Value", "Cancellation Fee Currency",
-            "Remarks", "Other Carrier Sectors", "Prorate Comments", null,
-            null, null, null, null, null, null, null, null, null, null, null,
-            null, null, null
-        };
+		boolean[] isDirectory = {
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, true, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false
+		};
+		assertEquals(64, isDirectory.length);
 
-        assertEquals(64, names.length);
-        boolean[] isRoot =
-        {
-            true, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false
-        };
+		boolean[] isNull = {
+			false, true, true, true, true, true, true, true, true, true, true,
+			true, true, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, true, true, true, true, true, true, true, true,
+			true, true, true, true, true, true, true
+		};
+		assertEquals(64, isNull.length);
 
-        assertEquals(64, isRoot.length);
-        boolean[] isDocument =
-        {
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, true, true, true, true, true,
-            true, true, true, true, true, true, true, true, true, true, true,
-            true, true, true, true, true, true, true, true, true, true, true,
-            true, true, true, true, true, true, true, true, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false
-        };
-
-        assertEquals(64, isDocument.length);
-        boolean[] isDirectory =
-        {
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, true, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false
-        };
-
-        assertEquals(64, isDirectory.length);
-        boolean[] isNull =
-        {
-            false, true, true, true, true, true, true, true, true, true, true,
-            true, true, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, true, true, true, true, true, true, true, true,
-            true, true, true, true, true, true, true
-        };
-
-        assertEquals(64, isNull.length);
-        for (int j = 0; j < 64; j++)
-        {
-            if (isNull[ j ])
-            {
-                assertNull("Checking property " + j, properties.get(j));
-            }
-            else
-            {
-                assertNotNull("Checking property " + j, properties.get(j));
-                if (isRoot[ j ])
-                {
-                    assertTrue("Checking property " + j,
-                               properties.get(j) instanceof RootProperty);
-                }
-                if (isDirectory[ j ])
-                {
-                    assertTrue("Checking property " + j,
-                               properties.get(j)
-                               instanceof DirectoryProperty);
-                }
-                if (isDocument[ j ])
-                {
-                    assertTrue("Checking property " + j,
-                               properties.get(j) instanceof DocumentProperty);
-                }
-                assertEquals("Checking property " + j, names[ j ],
-                             (( Property ) properties.get(j)).getName());
-            }
-        }
-    }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.property.PropertyFactory");
-        junit.textui.TestRunner.run(TestPropertyFactory.class);
-    }
+		for (int j = 0; j < 64; j++) {
+			if (isNull[j]) {
+				assertNull("Checking property " + j, properties.get(j));
+			} else {
+				assertNotNull("Checking property " + j, properties.get(j));
+				if (isRoot[j]) {
+					assertTrue("Checking property " + j, properties.get(j) instanceof RootProperty);
+				}
+				if (isDirectory[j]) {
+					assertTrue("Checking property " + j,
+							properties.get(j) instanceof DirectoryProperty);
+				}
+				if (isDocument[j]) {
+					assertTrue("Checking property " + j,
+							properties.get(j) instanceof DocumentProperty);
+				}
+				assertEquals("Checking property " + j, names[j], ((Property) properties.get(j))
+						.getName());
+			}
+		}
+	}
 }
diff --git a/src/testcases/org/apache/poi/poifs/property/TestPropertyTable.java b/src/testcases/org/apache/poi/poifs/property/TestPropertyTable.java
index 008504f..52e4aaf 100644
--- a/src/testcases/org/apache/poi/poifs/property/TestPropertyTable.java
+++ b/src/testcases/org/apache/poi/poifs/property/TestPropertyTable.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,2635 +14,459 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.property;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Iterator;
 
-import java.util.*;
-
-import junit.framework.*;
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
 
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.poifs.storage.BlockAllocationTableReader;
+import org.apache.poi.poifs.storage.HeaderBlock;
 import org.apache.poi.poifs.storage.RawDataBlockList;
+import org.apache.poi.poifs.storage.RawDataUtil;
 
 /**
  * Class to test PropertyTable functionality
  *
  * @author Marc Johnson
  */
+public final class TestPropertyTable extends TestCase {
 
-public class TestPropertyTable
-    extends TestCase
-{
+	private static void confirmBlockEncoding(String[] expectedDataHexDumpLines, PropertyTable table) {
+		byte[] expectedData = RawDataUtil.decode(expectedDataHexDumpLines);
+		ByteArrayOutputStream stream = new ByteArrayOutputStream();
+		try {
+			table.writeBlocks(stream);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+		byte[] output = stream.toByteArray();
 
-    /**
-     * Constructor TestPropertyTable
-     *
-     * @param name
-     */
+		assertEquals("length check #1", expectedData.length, output.length);
+		for (int j = 0; j < expectedData.length; j++) {
+			assertEquals("content check #1: mismatch at offset " + j, expectedData[j], output[j]);
+		}
+	}
 
-    public TestPropertyTable(String name)
-    {
-        super(name);
-    }
+	/**
+	 * Test PropertyTable
+	 * <p>
+	 * Running individual tests of the PropertyTable methods, which is the
+	 * traditional way to write unit tests (at least for me), seems somewhat
+	 * useless in this case. Of greater relevance: if one follows the normal
+	 * steps of creating a PropertyTable, and then checking the output, does it
+	 * make sense? In other words, more of an integration test.
+	 * <p>
+	 * So, the test consists of creating a PropertyTable instance, adding three
+	 * DocumentProperty instances to it, and then getting the output (including
+	 * the preWrite phase first), and comparing it against a real property table
+	 * extracted from a file known to be acceptable to Excel.
+	 */
+	public void testWriterPropertyTable() throws IOException {
 
-    /**
-     * Test PropertyTable
-     * <p>
-     * Running individual tests of the PropertyTable methods, which is
-     * the traditional way to write unit tests (at least for me),
-     * seems somewhat useless in this case. Of greater relevance: if
-     * one follows the normal steps of creating a PropertyTable, and
-     * then checking the output, does it make sense? In other words,
-     * more of an integration test.
-     * <p>
-     * So, the test consists of creating a PropertyTable instance,
-     * adding three DocumentProperty instances to it, and then getting
-     * the output (including the preWrite phase first), and comparing
-     * it against a real property table extracted from a file known to
-     * be acceptable to Excel.
-     *
-     * @exception IOException
-     */
+		// create the PropertyTable
+	   HeaderBlock   headerBlock = new HeaderBlock(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+		PropertyTable table = new PropertyTable(headerBlock);
 
-    public void testWriterPropertyTable()
-        throws IOException
-    {
+		// create three DocumentProperty instances and add them to the
+		// PropertyTable
+		DocumentProperty workbook = new DocumentProperty("Workbook", 0x00046777);
 
-        // create the PropertyTable
-        PropertyTable    table    = new PropertyTable();
+		workbook.setStartBlock(0);
+		DocumentProperty summary1 = new DocumentProperty("\005SummaryInformation", 0x00001000);
 
-        // create three DocumentProperty instances and add them to the
-        // PropertyTable
-        DocumentProperty workbook = new DocumentProperty("Workbook",
-                                        0x00046777);
+		summary1.setStartBlock(0x00000234);
+		DocumentProperty summary2 = new DocumentProperty("\005DocumentSummaryInformation",
+				0x00001000);
 
-        workbook.setStartBlock(0);
-        DocumentProperty summary1 =
-            new DocumentProperty("\005SummaryInformation", 0x00001000);
+		summary2.setStartBlock(0x0000023C);
+		table.addProperty(workbook);
+		RootProperty root = table.getRoot();
 
-        summary1.setStartBlock(0x00000234);
-        DocumentProperty summary2 =
-            new DocumentProperty("\005DocumentSummaryInformation",
-                                 0x00001000);
+		root.addChild(workbook);
+		table.addProperty(summary1);
+		root = table.getRoot();
+		root.addChild(summary1);
+		table.addProperty(summary2);
+		root = table.getRoot();
+		root.addChild(summary2);
+		table.preWrite();
 
-        summary2.setStartBlock(0x0000023C);
-        table.addProperty(workbook);
-        RootProperty root = table.getRoot();
+		String[] testblock = {
+			"52 00 6F 00 6F 00 74 00 20 00 45 00 6E 00 74 00 72 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"16 00 05 01 FF FF FF FF FF FF FF FF 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 00 00 00",
+			"57 00 6F 00 72 00 6B 00 62 00 6F 00 6F 00 6B 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"12 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 77 67 04 00 00 00 00 00",
+			"05 00 53 00 75 00 6D 00 6D 00 61 00 72 00 79 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00",
+			"69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 01 00 00 00 03 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 34 02 00 00 00 10 00 00 00 00 00 00",
+			"05 00 44 00 6F 00 63 00 75 00 6D 00 65 00 6E 00 74 00 53 00 75 00 6D 00 6D 00 61 00 72 00 79 00",
+			"49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00",
+			"38 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3C 02 00 00 00 10 00 00 00 00 00 00",
+		};
+		confirmBlockEncoding(testblock, table);
 
-        root.addChild(workbook);
-        table.addProperty(summary1);
-        root = table.getRoot();
-        root.addChild(summary1);
-        table.addProperty(summary2);
-        root = table.getRoot();
-        root.addChild(summary2);
-        table.preWrite();
-        ByteArrayOutputStream stream    = new ByteArrayOutputStream(512);
-        byte[]                testblock =
-        {
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6f, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x45, ( byte ) 0x00,
-            ( byte ) 0x6e, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x01,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xfe, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x57, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6b, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6f, ( byte ) 0x00, ( byte ) 0x6b, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x77, ( byte ) 0x67, ( byte ) 0x04, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x53, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x6d, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6e, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6e, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x34, ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x6f, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6e, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x53, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x6d, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6e, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6e, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x38, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3c, ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00
-        };
+		table.removeProperty(summary1);
+		root = table.getRoot();
+		root.deleteChild(summary1);
+		table.preWrite();
 
-        table.writeBlocks(stream);
-        byte[] output = stream.toByteArray();
+		String[] testblock2 = {
+			"52 00 6F 00 6F 00 74 00 20 00 45 00 6E 00 74 00 72 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"16 00 05 01 FF FF FF FF FF FF FF FF 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 00 00 00",
+			"57 00 6F 00 72 00 6B 00 62 00 6F 00 6F 00 6B 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"12 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 77 67 04 00 00 00 00 00",
+			"05 00 44 00 6F 00 63 00 75 00 6D 00 65 00 6E 00 74 00 53 00 75 00 6D 00 6D 00 61 00 72 00 79 00",
+			"49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00",
+			"38 00 02 01 01 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3C 02 00 00 00 10 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+		};
+		confirmBlockEncoding(testblock2, table);
 
-        assertEquals("length check #1", testblock.length, output.length);
-        for (int j = 0; j < testblock.length; j++)
-        {
-            assertEquals("content check #1: mismatch at offset " + j,
-                         testblock[ j ], output[ j ]);
-        }
-        table.removeProperty(summary1);
-        root = table.getRoot();
-        root.deleteChild(summary1);
-        table.preWrite();
-        stream = new ByteArrayOutputStream(512);
-        byte[] testblock2 =
-        {
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6f, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x45, ( byte ) 0x00,
-            ( byte ) 0x6e, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x01,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xfe, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x57, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6b, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6f, ( byte ) 0x00, ( byte ) 0x6b, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x77, ( byte ) 0x67, ( byte ) 0x04, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x6f, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6e, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x53, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x6d, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6e, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6e, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x38, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3c, ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00
-        };
+		table.addProperty(summary1);
+		root = table.getRoot();
+		root.addChild(summary1);
+		table.preWrite();
 
-        table.writeBlocks(stream);
-        output = stream.toByteArray();
-        assertEquals("length check #2", testblock2.length, output.length);
-        for (int j = 0; j < testblock2.length; j++)
-        {
-            assertEquals("content check #2: mismatch at offset " + j,
-                         testblock2[ j ], output[ j ]);
-        }
-        table.addProperty(summary1);
-        root = table.getRoot();
-        root.addChild(summary1);
-        table.preWrite();
-        stream = new ByteArrayOutputStream(512);
-        byte[] testblock3 =
-        {
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6f, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x45, ( byte ) 0x00,
-            ( byte ) 0x6e, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x01,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xfe, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x57, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6b, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6f, ( byte ) 0x00, ( byte ) 0x6b, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x77, ( byte ) 0x67, ( byte ) 0x04, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x6f, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6e, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x53, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x6d, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6e, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6e, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x38, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3c, ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x53, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x6d, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6e, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6d, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6f, ( byte ) 0x00,
-            ( byte ) 0x6e, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff, ( byte ) 0xff,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x34, ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00
-        };
+		String[] testblock3 = {
+			"52 00 6F 00 6F 00 74 00 20 00 45 00 6E 00 74 00 72 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"16 00 05 01 FF FF FF FF FF FF FF FF 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 00 00 00",
+			"57 00 6F 00 72 00 6B 00 62 00 6F 00 6F 00 6B 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"12 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 77 67 04 00 00 00 00 00",
+			"05 00 44 00 6F 00 63 00 75 00 6D 00 65 00 6E 00 74 00 53 00 75 00 6D 00 6D 00 61 00 72 00 79 00",
+			"49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00",
+			"38 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3C 02 00 00 00 10 00 00 00 00 00 00",
+			"05 00 53 00 75 00 6D 00 6D 00 61 00 72 00 79 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00",
+			"69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 01 00 00 00 02 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 34 02 00 00 00 10 00 00 00 00 00 00",
+		};
+		confirmBlockEncoding(testblock3, table);
+	}
 
-        table.writeBlocks(stream);
-        output = stream.toByteArray();
-        assertEquals("length check #3", testblock3.length, output.length);
-        for (int j = 0; j < testblock3.length; j++)
-        {
-            assertEquals("content check #3: mismatch at offset " + j,
-                         testblock3[ j ], output[ j ]);
-        }
-    }
+	public void testReadingConstructor() throws IOException {
 
-    /**
-     * test reading constructor
-     *
-     * @exception IOException
-     */
+		// first, we need the raw data blocks
+		String[] raw_data_array = {
+			"52 00 6F 00 6F 00 74 00 20 00 45 00 6E 00 74 00 72 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"16 00 05 01 FF FF FF FF FF FF FF FF 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0A 00 00 00 80 07 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 01 01 FF FF FF FF FF FF FF FF 15 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"46 00 55 00 44 00 20 00 47 00 72 00 69 00 64 00 20 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00",
+			"74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2A 00 02 01 FF FF FF FF 0E 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"44 00 6F 00 75 00 62 00 6C 00 65 00 20 00 44 00 65 00 61 00 6C 00 69 00 6E 00 67 00 20 00 49 00",
+			"6E 00 64 00 69 00 63 00 61 00 74 00 6F 00 72 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"32 00 02 01 FF FF FF FF 09 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00",
+			"43 00 68 00 69 00 6C 00 64 00 20 00 50 00 65 00 72 00 63 00 65 00 6E 00 74 00 61 00 67 00 65 00",
+			"20 00 50 00 65 00 72 00 6D 00 69 00 74 00 74 00 65 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"36 00 02 01 FF FF FF FF 07 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 04 00 00 00 00 00 00 00",
+			"43 00 61 00 6E 00 63 00 65 00 6C 00 6C 00 61 00 74 00 69 00 6F 00 6E 00 20 00 46 00 65 00 65 00",
+			"20 00 46 00 69 00 78 00 65 00 64 00 20 00 56 00 61 00 6C 00 75 00 65 00 00 00 00 00 00 00 00 00",
+			"3A 00 02 01 FF FF FF FF 06 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 02 00 00 00 04 00 00 00 00 00 00 00",
+			"55 00 6D 00 62 00 72 00 65 00 6C 00 6C 00 61 00 20 00 4C 00 69 00 6E 00 6B 00 73 00 20 00 61 00",
+			"6E 00 64 00 20 00 50 00 61 00 73 00 73 00 65 00 6E 00 67 00 65 00 72 00 73 00 00 00 00 00 00 00",
+			"3C 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"43 00 61 00 6E 00 63 00 65 00 6C 00 6C 00 61 00 74 00 69 00 6F 00 6E 00 20 00 46 00 65 00 65 00",
+			"20 00 50 00 65 00 72 00 63 00 65 00 6E 00 74 00 61 00 67 00 65 00 00 00 00 00 00 00 00 00 00 00",
+			"38 00 02 01 FF FF FF FF 05 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 03 00 00 00 04 00 00 00 00 00 00 00",
+			"49 00 6E 00 66 00 61 00 6E 00 74 00 20 00 44 00 69 00 73 00 63 00 6F 00 75 00 6E 00 74 00 20 00",
+			"50 00 65 00 72 00 6D 00 69 00 74 00 74 00 65 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"34 00 02 01 FF FF FF FF 04 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 00 04 00 00 00 00 00 00 00",
+			"43 00 61 00 6E 00 63 00 65 00 6C 00 6C 00 61 00 74 00 69 00 6F 00 6E 00 20 00 46 00 65 00 65 00",
+			"20 00 43 00 75 00 72 00 72 00 65 00 6E 00 63 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"34 00 02 01 FF FF FF FF 08 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 05 00 00 00 07 00 00 00 00 00 00 00",
+			"4F 00 75 00 74 00 62 00 6F 00 75 00 6E 00 64 00 20 00 54 00 72 00 61 00 76 00 65 00 6C 00 20 00",
+			"44 00 61 00 74 00 65 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2C 00 02 01 FF FF FF FF 0B 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 06 00 00 00 21 00 00 00 00 00 00 00",
+			"42 00 75 00 73 00 69 00 6E 00 65 00 73 00 73 00 20 00 4A 00 75 00 73 00 74 00 69 00 66 00 69 00",
+			"63 00 61 00 74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2E 00 02 01 FF FF FF FF 03 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 07 00 00 00 04 00 00 00 00 00 00 00",
+			"49 00 6E 00 66 00 61 00 6E 00 74 00 20 00 44 00 69 00 73 00 63 00 6F 00 75 00 6E 00 74 00 20 00",
+			"56 00 61 00 6C 00 75 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2C 00 02 01 FF FF FF FF 0D 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 08 00 00 00 04 00 00 00 00 00 00 00",
+			"4F 00 74 00 68 00 65 00 72 00 20 00 43 00 61 00 72 00 72 00 69 00 65 00 72 00 20 00 53 00 65 00",
+			"63 00 74 00 6F 00 72 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2C 00 02 01 FF FF FF FF 0A 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 09 00 00 00 04 00 00 00 00 00 00 00",
+			"4E 00 75 00 6D 00 62 00 65 00 72 00 20 00 6F 00 66 00 20 00 50 00 61 00 73 00 73 00 65 00 6E 00",
+			"67 00 65 00 72 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2A 00 02 01 FF FF FF FF 0C 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0A 00 00 00 04 00 00 00 00 00 00 00",
+			"53 00 61 00 6C 00 65 00 73 00 20 00 41 00 72 00 65 00 61 00 20 00 43 00 6F 00 64 00 65 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"20 00 02 01 1C 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0B 00 00 00 04 00 00 00 00 00 00 00",
+			"4F 00 74 00 68 00 65 00 72 00 20 00 52 00 65 00 66 00 75 00 6E 00 64 00 20 00 54 00 65 00 78 00",
+			"74 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"24 00 02 01 17 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0C 00 00 00 04 00 00 00 00 00 00 00",
+			"4D 00 61 00 78 00 69 00 6D 00 75 00 6D 00 20 00 53 00 74 00 61 00 79 00 20 00 50 00 65 00 72 00",
+			"69 00 6F 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 FF FF FF FF 14 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0D 00 00 00 04 00 00 00 00 00 00 00",
+			"4E 00 65 00 74 00 20 00 52 00 65 00 6D 00 69 00 74 00 20 00 50 00 65 00 72 00 6D 00 69 00 74 00",
+			"74 00 65 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 FF FF FF FF 13 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0E 00 00 00 04 00 00 00 00 00 00 00",
+			"50 00 65 00 72 00 63 00 65 00 6E 00 74 00 61 00 67 00 65 00 20 00 6F 00 66 00 20 00 59 00 69 00",
+			"65 00 6C 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 FF FF FF FF 02 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0F 00 00 00 04 00 00 00 00 00 00 00",
+			"4E 00 61 00 74 00 75 00 72 00 65 00 20 00 6F 00 66 00 20 00 56 00 61 00 72 00 69 00 61 00 74 00",
+			"69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 FF FF FF FF 12 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 10 00 00 00 50 00 00 00 00 00 00 00",
+			"46 00 55 00 44 00 20 00 47 00 72 00 69 00 64 00 20 00 44 00 69 00 6D 00 65 00 6E 00 73 00 69 00",
+			"6F 00 6E 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 10 00 00 00 11 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 12 00 00 00 04 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 44 00 65 00 73 00 63 00 72 00 69 00 70 00 74 00 69 00 6F 00 6E 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 01 19 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 13 00 00 00 09 00 00 00 00 00 00 00",
+			"54 00 52 00 56 00 41 00 20 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 01 18 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 14 00 00 00 04 00 00 00 00 00 00 00",
+			"50 00 72 00 6F 00 72 00 61 00 74 00 65 00 20 00 43 00 6F 00 6D 00 6D 00 65 00 6E 00 74 00 73 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 01 16 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"43 00 6F 00 6D 00 6D 00 69 00 73 00 73 00 69 00 6F 00 6E 00 20 00 56 00 61 00 6C 00 75 00 65 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 01 0F 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 15 00 00 00 04 00 00 00 00 00 00 00",
+			"4D 00 61 00 78 00 69 00 6D 00 75 00 6D 00 20 00 53 00 74 00 61 00 79 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1A 00 02 01 20 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 16 00 00 00 05 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 43 00 75 00 72 00 72 00 65 00 6E 00 63 00 79 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1C 00 02 01 1D 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 17 00 00 00 07 00 00 00 00 00 00 00",
+			"43 00 6F 00 6E 00 73 00 6F 00 72 00 74 00 69 00 61 00 20 00 43 00 6F 00 64 00 65 00 73 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"20 00 02 01 1B 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"42 00 75 00 73 00 69 00 6E 00 65 00 73 00 73 00 20 00 54 00 79 00 70 00 65 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1C 00 02 01 1A 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18 00 00 00 04 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 54 00 79 00 70 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 01 23 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 19 00 00 00 04 00 00 00 00 00 00 00",
+			"53 00 75 00 72 00 63 00 68 00 61 00 72 00 67 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 01 21 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1A 00 00 00 04 00 00 00 00 00 00 00",
+			"41 00 67 00 65 00 6E 00 74 00 73 00 20 00 4E 00 61 00 6D 00 65 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"18 00 02 01 1F 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1B 00 00 00 04 00 00 00 00 00 00 00",
+			"46 00 61 00 72 00 65 00 20 00 54 00 79 00 70 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 01 1E 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1C 00 00 00 04 00 00 00 00 00 00 00",
+			"53 00 75 00 62 00 20 00 44 00 65 00 61 00 6C 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"12 00 02 01 24 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1D 00 00 00 04 00 00 00 00 00 00 00",
+			"41 00 4C 00 43 00 20 00 43 00 6F 00 64 00 65 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 01 22 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"52 00 65 00 6D 00 61 00 72 00 6B 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"10 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 03 00 47 42 50 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 1D 00 28 41 29 31 36 2D 4F 63 74 2D 32 30 30 31 20 74 6F 20 31 36 2D 4F 63 74 2D 32 30 30",
+			"31 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 01 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00",
+			"02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00",
+			"02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 18 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 05 00 6A 61 6D 65 73 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 01 00 31 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 03 00 47 42 50 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF",
+			"FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF",
+			"11 00 00 00 FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF",
+			"FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 08 00 00 00",
+			"09 00 00 00 FE FF FF FF 0B 00 00 00 0C 00 00 00 0D 00 00 00 FE FF FF FF FE FF FF FF FE FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+		};
 
-    public void testReadingConstructor()
-        throws IOException
-    {
+		RawDataBlockList data_blocks = new RawDataBlockList(new ByteArrayInputStream(RawDataUtil
+				.decode(raw_data_array)), POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+		int[] bat_array = { 15 };
 
-        // first, we need the raw data blocks
-        byte[]           raw_data_array =
-        {
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x45, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x80, ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x15, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x46, ( byte ) 0x00, ( byte ) 0x55, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x32, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x09, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x68, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x36, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x78, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x56, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x55, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4C, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x6B, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x38, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x34, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x34, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x76, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x21, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x42, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4A, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2E, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x56, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x68, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x09, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x68, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x78, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x24, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x17, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x78, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x13, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x59, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x56, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x46, ( byte ) 0x00, ( byte ) 0x55, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x11, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x19, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x13, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x09, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x54, ( byte ) 0x00, ( byte ) 0x52, ( byte ) 0x00,
-            ( byte ) 0x56, ( byte ) 0x00, ( byte ) 0x41, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x18, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x56, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x0F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x15, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x78, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x17, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x42, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x18, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x23, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x19, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x68, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x21, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4E, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x18, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x46, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x24, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x4C, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6B, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x42, ( byte ) 0x50, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x1D, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x41, ( byte ) 0x29, ( byte ) 0x31,
-            ( byte ) 0x36, ( byte ) 0x2D, ( byte ) 0x4F, ( byte ) 0x63,
-            ( byte ) 0x74, ( byte ) 0x2D, ( byte ) 0x32, ( byte ) 0x30,
-            ( byte ) 0x30, ( byte ) 0x31, ( byte ) 0x20, ( byte ) 0x74,
-            ( byte ) 0x6F, ( byte ) 0x20, ( byte ) 0x31, ( byte ) 0x36,
-            ( byte ) 0x2D, ( byte ) 0x4F, ( byte ) 0x63, ( byte ) 0x74,
-            ( byte ) 0x2D, ( byte ) 0x32, ( byte ) 0x30, ( byte ) 0x30,
-            ( byte ) 0x31, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x18, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x00,
-            ( byte ) 0x6A, ( byte ) 0x61, ( byte ) 0x6D, ( byte ) 0x65,
-            ( byte ) 0x73, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x00,
-            ( byte ) 0x31, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x42, ( byte ) 0x50, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x11, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x09, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF
-        };
-        RawDataBlockList data_blocks    =
-            new RawDataBlockList(new ByteArrayInputStream(raw_data_array), POIFSConstants.BIG_BLOCK_SIZE);
-        int[]            bat_array      =
-        {
-            15
-        };
+		// need to initialize the block list with a block allocation
+		// table
+		new BlockAllocationTableReader(
+		      POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 1, bat_array, 0, -2, data_blocks);
 
-        // need to initialize the block list with a block allocation
-        // table
-        new BlockAllocationTableReader(1, bat_array, 0, -2, data_blocks);
+      // Fake up a header
+      HeaderBlock header_block = new HeaderBlock(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+      header_block.setPropertyStart(0);
+      
+		// get property table from the document
+		PropertyTable table = new PropertyTable(header_block, data_blocks);
 
-        // get property table from the document
-        PropertyTable table = new PropertyTable(0, data_blocks);
+		assertEquals(30 * 64, table.getRoot().getSize());
+		int count = 0;
+		Property child = null;
+		Iterator iter = table.getRoot().getChildren();
 
-        assertEquals(30 * 64, table.getRoot().getSize());
-        int      count = 0;
-        Property child = null;
-        Iterator iter  = table.getRoot().getChildren();
-
-        while (iter.hasNext())
-        {
-            child = ( Property ) iter.next();
-            ++count;
-        }
-        assertEquals(1, count);
-        assertTrue(child.isDirectory());
-        iter  = (( DirectoryProperty ) child).getChildren();
-        count = 0;
-        while (iter.hasNext())
-        {
-            iter.next();
-            ++count;
-        }
-        assertEquals(35, count);
-    }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.property.PropertyTable");
-        junit.textui.TestRunner.run(TestPropertyTable.class);
-    }
+		while (iter.hasNext()) {
+			child = (Property) iter.next();
+			++count;
+		}
+		if (child == null) {
+			throw new AssertionFailedError("no children found");
+		}
+		assertEquals(1, count);
+		assertTrue(child.isDirectory());
+		iter = ((DirectoryProperty) child).getChildren();
+		count = 0;
+		while (iter.hasNext()) {
+			iter.next();
+			++count;
+		}
+		assertEquals(35, count);
+	}
 }
diff --git a/src/testcases/org/apache/poi/poifs/property/TestRootProperty.java b/src/testcases/org/apache/poi/poifs/property/TestRootProperty.java
index 6ba5da0..46c0730 100644
--- a/src/testcases/org/apache/poi/poifs/property/TestRootProperty.java
+++ b/src/testcases/org/apache/poi/poifs/property/TestRootProperty.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,210 +14,118 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.property;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 
-import java.util.*;
-
-import junit.framework.*;
+import junit.framework.TestCase;
 
 import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.poifs.storage.RawDataUtil;
 
 /**
  * Class to test RootProperty functionality
  *
  * @author Marc Johnson
  */
+public final class TestRootProperty extends TestCase {
+	private RootProperty _property;
+	private byte[] _testblock;
 
-public class TestRootProperty
-    extends TestCase
-{
-    private RootProperty _property;
-    private byte[]       _testblock;
+	public void testConstructor() throws IOException {
+		createBasicRootProperty();
+		verifyProperty();
+	}
 
-    /**
-     * Constructor TestRootProperty
-     *
-     * @param name
-     */
+	private void createBasicRootProperty() {
+		_property = new RootProperty();
+		_testblock = new byte[128];
+		int index = 0;
 
-    public TestRootProperty(String name)
-    {
-        super(name);
-    }
+		for (; index < 0x40; index++) {
+			_testblock[index] = (byte) 0;
+		}
+		String name = "Root Entry";
+		int limit = Math.min(31, name.length());
 
-    /**
-     * Test constructing RootProperty
-     *
-     * @exception IOException
-     */
+		_testblock[index++] = (byte) (2 * (limit + 1));
+		_testblock[index++] = (byte) 0;
+		_testblock[index++] = (byte) 5;
+		_testblock[index++] = (byte) 1;
+		for (; index < 0x50; index++) {
+			_testblock[index] = (byte) 0xff;
+		}
+		for (; index < 0x74; index++) {
+			_testblock[index] = (byte) 0;
+		}
+		_testblock[index++] = (byte) POIFSConstants.END_OF_CHAIN;
+		for (; index < 0x78; index++) {
+			_testblock[index] = (byte) 0xff;
+		}
+		for (; index < 0x80; index++) {
+			_testblock[index] = (byte) 0;
+		}
+		byte[] name_bytes = name.getBytes();
 
-    public void testConstructor()
-        throws IOException
-    {
-        createBasicRootProperty();
-        verifyProperty();
-    }
+		for (index = 0; index < limit; index++) {
+			_testblock[index * 2] = name_bytes[index];
+		}
+	}
 
-    private void createBasicRootProperty()
-    {
-        _property  = new RootProperty();
-        _testblock = new byte[ 128 ];
-        int index = 0;
+	private void verifyProperty() throws IOException {
+		ByteArrayOutputStream stream = new ByteArrayOutputStream(512);
 
-        for (; index < 0x40; index++)
-        {
-            _testblock[ index ] = ( byte ) 0;
-        }
-        String name  = "Root Entry";
-        int    limit = Math.min(31, name.length());
+		_property.writeData(stream);
+		byte[] output = stream.toByteArray();
 
-        _testblock[ index++ ] = ( byte ) (2 * (limit + 1));
-        _testblock[ index++ ] = ( byte ) 0;
-        _testblock[ index++ ] = ( byte ) 5;
-        _testblock[ index++ ] = ( byte ) 1;
-        for (; index < 0x50; index++)
-        {
-            _testblock[ index ] = ( byte ) 0xff;
-        }
-        for (; index < 0x74; index++)
-        {
-            _testblock[ index ] = ( byte ) 0;
-        }
-        _testblock[ index++ ] = ( byte ) POIFSConstants.END_OF_CHAIN;
-        for (; index < 0x78; index++)
-        {
-            _testblock[ index ] = ( byte ) 0xff;
-        }
-        for (; index < 0x80; index++)
-        {
-            _testblock[ index ] = ( byte ) 0;
-        }
-        byte[] name_bytes = name.getBytes();
+		assertEquals(_testblock.length, output.length);
+		for (int j = 0; j < _testblock.length; j++) {
+			assertEquals("mismatch at offset " + j, _testblock[j], output[j]);
+		}
+	}
 
-        for (index = 0; index < limit; index++)
-        {
-            _testblock[ index * 2 ] = name_bytes[ index ];
-        }
-    }
+	public void testSetSize() {
+		for (int j = 0; j < 10; j++) {
+			createBasicRootProperty();
+			_property.setSize(j);
+			assertEquals("trying block count of " + j, j * 64, _property.getSize());
+		}
+	}
 
-    private void verifyProperty()
-        throws IOException
-    {
-        ByteArrayOutputStream stream = new ByteArrayOutputStream(512);
+	public void testReadingConstructor() {
+		String[] input = {
+			"52 00 6F 00 6F 00 74 00 20 00 45 00 6E 00 74 00 72 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"16 00 05 01 FF FF FF FF FF FF FF FF 02 00 00 00 20 08 02 00 00 00 00 00 C0 00 00 00 00 00 00 46",
+			"00 00 00 00 00 00 00 00 00 00 00 00 C0 5C E8 23 9E 6B C1 01 FE FF FF FF 00 00 00 00 00 00 00 00",
+		};
+		verifyReadingProperty(0, RawDataUtil.decode(input), 0, "Root Entry",
+				"{00020820-0000-0000-C000-000000000046}");
+	}
 
-        _property.writeData(stream);
-        byte[] output = stream.toByteArray();
+	private void verifyReadingProperty(int index, byte[] input, int offset, String name,
+			String sClsId) {
+		RootProperty property = new RootProperty(index, input, offset);
+		ByteArrayOutputStream stream = new ByteArrayOutputStream(128);
+		byte[] expected = new byte[128];
 
-        assertEquals(_testblock.length, output.length);
-        for (int j = 0; j < _testblock.length; j++)
-        {
-            assertEquals("mismatch at offset " + j, _testblock[ j ],
-                         output[ j ]);
-        }
-    }
+		System.arraycopy(input, offset, expected, 0, 128);
+		try {
+			property.writeData(stream);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+		byte[] output = stream.toByteArray();
 
-    /**
-     * test setSize
-     */
-
-    public void testSetSize()
-    {
-        for (int j = 0; j < 10; j++)
-        {
-            createBasicRootProperty();
-            _property.setSize(j);
-            assertEquals("trying block count of " + j, j * 64,
-                         _property.getSize());
-        }
-    }
-
-    /**
-     * Test reading constructor
-     *
-     * @exception IOException
-     */
-
-    public void testReadingConstructor()
-        throws IOException
-    {
-        byte[] input =
-        {
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x45, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x08, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xC0, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x46,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xC0, ( byte ) 0x5C, ( byte ) 0xE8, ( byte ) 0x23,
-            ( byte ) 0x9E, ( byte ) 0x6B, ( byte ) 0xC1, ( byte ) 0x01,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00
-        };
-
-        verifyReadingProperty(0, input, 0, "Root Entry", "{00020820-0000-0000-C000-000000000046}");
-    }
-
-    private void verifyReadingProperty(int index, byte [] input, int offset,
-                                       String name, String sClsId)
-        throws IOException
-    {
-        RootProperty          property = new RootProperty(index, input,
-                                             offset);
-        ByteArrayOutputStream stream   = new ByteArrayOutputStream(128);
-        byte[]                expected = new byte[ 128 ];
-
-        System.arraycopy(input, offset, expected, 0, 128);
-        property.writeData(stream);
-        byte[] output = stream.toByteArray();
-
-        assertEquals(128, output.length);
-        for (int j = 0; j < 128; j++)
-        {
-            assertEquals("mismatch at offset " + j, expected[ j ],
-                         output[ j ]);
-        }
-        assertEquals(index, property.getIndex());
-        assertEquals(name, property.getName());
-        assertTrue(!property.getChildren().hasNext());
-        assertEquals(property.getStorageClsid().toString(), sClsId);
-    }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.property.RootProperty");
-        junit.textui.TestRunner.run(TestRootProperty.class);
-    }
+		assertEquals(128, output.length);
+		for (int j = 0; j < 128; j++) {
+			assertEquals("mismatch at offset " + j, expected[j], output[j]);
+		}
+		assertEquals(index, property.getIndex());
+		assertEquals(name, property.getName());
+		assertTrue(!property.getChildren().hasNext());
+		assertEquals(property.getStorageClsid().toString(), sClsId);
+	}
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/AllPOIFSStorageTests.java b/src/testcases/org/apache/poi/poifs/storage/AllPOIFSStorageTests.java
index 8c15d38..4601191 100755
--- a/src/testcases/org/apache/poi/poifs/storage/AllPOIFSStorageTests.java
+++ b/src/testcases/org/apache/poi/poifs/storage/AllPOIFSStorageTests.java
@@ -26,22 +26,22 @@
  */
 public final class AllPOIFSStorageTests {
 
-    public static Test suite() {
-        TestSuite result = new TestSuite("Tests for org.apache.poi.poifs.storage");
-        result.addTestSuite(TestBATBlock.class);
-        result.addTestSuite(TestBlockAllocationTableReader.class);
-        result.addTestSuite(TestBlockAllocationTableWriter.class);
-        result.addTestSuite(TestBlockListImpl.class);
-        result.addTestSuite(TestDocumentBlock.class);
-        result.addTestSuite(TestHeaderBlockReader.class);
-        result.addTestSuite(TestHeaderBlockWriter.class);
-        result.addTestSuite(TestPropertyBlock.class);
-        result.addTestSuite(TestRawDataBlock.class);
-        result.addTestSuite(TestRawDataBlockList.class);
-        result.addTestSuite(TestSmallBlockTableReader.class);
-        result.addTestSuite(TestSmallBlockTableWriter.class);
-        result.addTestSuite(TestSmallDocumentBlock.class);
-        result.addTestSuite(TestSmallDocumentBlockList.class);
-        return result;
-    }
+	public static Test suite() {
+		TestSuite result = new TestSuite(AllPOIFSStorageTests.class.getName());
+		result.addTestSuite(TestBATBlock.class);
+		result.addTestSuite(TestBlockAllocationTableReader.class);
+		result.addTestSuite(TestBlockAllocationTableWriter.class);
+		result.addTestSuite(TestBlockListImpl.class);
+		result.addTestSuite(TestDocumentBlock.class);
+		result.addTestSuite(TestHeaderBlockReading.class);
+		result.addTestSuite(TestHeaderBlockWriting.class);
+		result.addTestSuite(TestPropertyBlock.class);
+		result.addTestSuite(TestRawDataBlock.class);
+		result.addTestSuite(TestRawDataBlockList.class);
+		result.addTestSuite(TestSmallBlockTableReader.class);
+		result.addTestSuite(TestSmallBlockTableWriter.class);
+		result.addTestSuite(TestSmallDocumentBlock.class);
+		result.addTestSuite(TestSmallDocumentBlockList.class);
+		return result;
+	}
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/LocalRawDataBlockList.java b/src/testcases/org/apache/poi/poifs/storage/LocalRawDataBlockList.java
index 21049eb..42a9d2c 100644
--- a/src/testcases/org/apache/poi/poifs/storage/LocalRawDataBlockList.java
+++ b/src/testcases/org/apache/poi/poifs/storage/LocalRawDataBlockList.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,42 +14,32 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.apache.poi.poifs.common.POIFSConstants;
-import org.apache.poi.poifs.filesystem.POIFSFileSystem;
 import org.apache.poi.util.LittleEndian;
 import org.apache.poi.util.LittleEndianConsts;
 
-import java.io.*;
-
-import java.util.*;
-
 /**
  * Class LocalRawDataBlockList
  *
  * @author Marc Johnson(mjohnson at apache dot org)
  */
-
-public class LocalRawDataBlockList
-    extends RawDataBlockList
-{
-    private List           _list;
+public final class LocalRawDataBlockList extends RawDataBlockList {
+    private List<RawDataBlock> _list;
     private RawDataBlock[] _array;
 
-    /**
-     * Constructor LocalRawDataBlockList
-     *
-     * @exception IOException
-     */
-
     public LocalRawDataBlockList()
         throws IOException
     {
-        super(new ByteArrayInputStream(new byte[ 0 ]), POIFSConstants.BIG_BLOCK_SIZE);
-        _list  = new ArrayList();
+        super(new ByteArrayInputStream(new byte[ 0 ]), POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+        _list  = new ArrayList<RawDataBlock>();
         _array = null;
     }
 
@@ -60,10 +49,7 @@
      * @param start index of first BAT block
      * @param end index of last BAT block
      * @param chain index of next XBAT block
-     *
-     * @exception IOException
      */
-
     public void createNewXBATBlock(final int start, final int end,
                                    final int chain)
         throws IOException
@@ -89,10 +75,7 @@
      * create a BAT block and add it to the list
      *
      * @param start_index initial index for the block list
-     *
-     * @exception IOException
      */
-
     public void createNewBATBlock(final int start_index)
         throws IOException
     {
@@ -124,10 +107,7 @@
      * fill the list with dummy blocks
      *
      * @param count of blocks
-     *
-     * @exception IOException
      */
-
     public void fill(final int count)
         throws IOException
     {
@@ -144,7 +124,6 @@
      *
      * @param block new block to add
      */
-
     public void add(RawDataBlock block)
     {
         _list.add(block);
@@ -156,10 +135,7 @@
      * @param index of block to be removed
      *
      * @return desired block
-     *
-     * @exception IOException
      */
-
     public ListManagedBlock remove(final int index)
         throws IOException
     {
@@ -189,7 +165,6 @@
      * @param index the index of the specified block; if the index is
      *              out of range, that's ok
      */
-
     public void zap(final int index)
     {
         ensureArrayExists();
@@ -203,7 +178,11 @@
     {
         if (_array == null)
         {
-            _array = ( RawDataBlock [] ) _list.toArray(new RawDataBlock[ 0 ]);
+            _array = _list.toArray(new RawDataBlock[ 0 ]);
         }
     }
+    
+    public int blockCount() {
+       return _list.size();
+    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/RawDataUtil.java b/src/testcases/org/apache/poi/poifs/storage/RawDataUtil.java
new file mode 100644
index 0000000..d69fd68
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/storage/RawDataUtil.java
@@ -0,0 +1,86 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+package org.apache.poi.poifs.storage;
+
+import java.io.ByteArrayOutputStream;
+import java.util.Arrays;
+
+import org.apache.poi.util.HexDump;
+import org.apache.poi.util.HexRead;
+
+/**
+ * Test utility class.<br/>
+ *
+ * Creates raw <code>byte[]</code> data from hex-dump String arrays.
+ *
+ * @author Josh Micich
+ */
+public final class RawDataUtil {
+
+	public static byte[] decode(String[] hexDataLines) {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream(hexDataLines.length * 32 + 32);
+
+		for (int i = 0; i < hexDataLines.length; i++) {
+			byte[] lineData = HexRead.readFromString(hexDataLines[i]);
+			baos.write(lineData, 0, lineData.length);
+		}
+		return baos.toByteArray();
+	}
+
+	/**
+	 * Development time utility method.<br/>
+	 * Transforms a byte array into hex-dump String lines in java source code format.
+	 */
+	public static void dumpData(byte[] data) {
+		int i=0;
+		System.out.println("String[] hexDataLines = {");
+		System.out.print("\t\"");
+		while(true) {
+			char[] cc = HexDump.byteToHex(data[i]);
+			System.out.print(cc[2]);
+			System.out.print(cc[3]);
+			i++;
+			if (i>=data.length) {
+				break;
+			}
+			if (i % 32 == 0) {
+				System.out.println("\",");
+				System.out.print("\t\"");
+			} else {
+				System.out.print(" ");
+			}
+		}
+		System.out.println("\",");
+		System.out.println("};");
+	}
+
+	/**
+	 * Development time utility method.<br/>
+	 * Confirms that the specified byte array is equivalent to the hex-dump String lines.
+	 */
+	public static void confirmEqual(byte[] expected, String[] hexDataLines) {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream(hexDataLines.length * 32 + 32);
+
+		for (int i = 0; i < hexDataLines.length; i++) {
+			byte[] lineData = HexRead.readFromString(hexDataLines[i]);
+			baos.write(lineData, 0, lineData.length);
+		}
+		if (!Arrays.equals(expected, baos.toByteArray())) {
+			throw new RuntimeException("different");
+		}
+	}
+}
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestBATBlock.java b/src/testcases/org/apache/poi/poifs/storage/TestBATBlock.java
index c39454d..758d559 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestBATBlock.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestBATBlock.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,78 +14,62 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
-import java.util.*;
+import org.apache.poi.poifs.common.POIFSConstants;
 
-import junit.framework.*;
+import junit.framework.TestCase;
 
 /**
  * Class to test BATBlock functionality
  *
  * @author Marc Johnson
  */
-
-public class TestBATBlock
-    extends TestCase
-{
-
-    /**
-     * Constructor TestBATBlock
-     *
-     * @param name
-     */
-
-    public TestBATBlock(String name)
-    {
-        super(name);
-    }
+public final class TestBATBlock extends TestCase {
 
     /**
      * Test the createBATBlocks method. The test involves setting up
      * various arrays of int's and ensuring that the correct number of
      * BATBlocks is created for each array, and that the data from
      * each array is correctly written to the BATBlocks.
-     *
-     * @exception IOException
      */
-
-    public void testCreateBATBlocks()
-        throws IOException
-    {
+    public void testCreateBATBlocks() throws IOException {
 
         // test 0 length array (basic sanity)
-        BATBlock[] rvalue = BATBlock.createBATBlocks(createTestArray(0));
+        BATBlock[] rvalue = BATBlock.createBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(0));
 
         assertEquals(0, rvalue.length);
 
         // test array of length 1
-        rvalue = BATBlock.createBATBlocks(createTestArray(1));
+        rvalue = BATBlock.createBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(1));
         assertEquals(1, rvalue.length);
         verifyContents(rvalue, 1);
 
         // test array of length 127
-        rvalue = BATBlock.createBATBlocks(createTestArray(127));
+        rvalue = BATBlock.createBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(127));
         assertEquals(1, rvalue.length);
         verifyContents(rvalue, 127);
 
         // test array of length 128
-        rvalue = BATBlock.createBATBlocks(createTestArray(128));
+        rvalue = BATBlock.createBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(128));
         assertEquals(1, rvalue.length);
         verifyContents(rvalue, 128);
 
         // test array of length 129
-        rvalue = BATBlock.createBATBlocks(createTestArray(129));
+        rvalue = BATBlock.createBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(129));
         assertEquals(2, rvalue.length);
         verifyContents(rvalue, 129);
     }
 
-    private int [] createTestArray(int count)
-    {
+    private static int[] createTestArray(int count) {
         int[] rvalue = new int[ count ];
 
         for (int j = 0; j < count; j++)
@@ -96,9 +79,7 @@
         return rvalue;
     }
 
-    private void verifyContents(BATBlock [] blocks, int entries)
-        throws IOException
-    {
+    private static void verifyContents(BATBlock[] blocks, int entries) throws IOException {
         byte[] expected = new byte[ 512 * blocks.length ];
 
         Arrays.fill(expected, ( byte ) 0xFF);
@@ -127,51 +108,40 @@
         }
     }
 
-    /**
-     * test createXBATBlocks
-     *
-     * @exception IOException
-     */
-
-    public void testCreateXBATBlocks()
-        throws IOException
-    {
-
+    public void testCreateXBATBlocks() throws IOException {
         // test 0 length array (basic sanity)
-        BATBlock[] rvalue = BATBlock.createXBATBlocks(createTestArray(0), 1);
+        BATBlock[] rvalue = BATBlock.createXBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(0), 1);
 
         assertEquals(0, rvalue.length);
 
         // test array of length 1
-        rvalue = BATBlock.createXBATBlocks(createTestArray(1), 1);
+        rvalue = BATBlock.createXBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(1), 1);
         assertEquals(1, rvalue.length);
         verifyXBATContents(rvalue, 1, 1);
 
         // test array of length 127
-        rvalue = BATBlock.createXBATBlocks(createTestArray(127), 1);
+        rvalue = BATBlock.createXBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(127), 1);
         assertEquals(1, rvalue.length);
         verifyXBATContents(rvalue, 127, 1);
 
         // test array of length 128
-        rvalue = BATBlock.createXBATBlocks(createTestArray(128), 1);
+        rvalue = BATBlock.createXBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(128), 1);
         assertEquals(2, rvalue.length);
         verifyXBATContents(rvalue, 128, 1);
 
         // test array of length 254
-        rvalue = BATBlock.createXBATBlocks(createTestArray(254), 1);
+        rvalue = BATBlock.createXBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(254), 1);
         assertEquals(2, rvalue.length);
         verifyXBATContents(rvalue, 254, 1);
 
         // test array of length 255
-        rvalue = BATBlock.createXBATBlocks(createTestArray(255), 1);
+        rvalue = BATBlock.createXBATBlocks(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, createTestArray(255), 1);
         assertEquals(3, rvalue.length);
         verifyXBATContents(rvalue, 255, 1);
     }
 
-    private void verifyXBATContents(BATBlock [] blocks, int entries,
-                                    int start_block)
-        throws IOException
-    {
+    private static void verifyXBATContents(BATBlock[] blocks, int entries, int start_block)
+			throws IOException {
         byte[] expected = new byte[ 512 * blocks.length ];
 
         Arrays.fill(expected, ( byte ) 0xFF);
@@ -220,65 +190,197 @@
         }
     }
 
-    /**
-     * test calculateXBATStorageRequirements
-     */
-
-    public void testCalculateXBATStorageRequirements()
-    {
-        int[] blockCounts  =
-        {
-            0, 1, 127, 128
-        };
-        int[] requirements =
-        {
-            0, 1, 1, 2
-        };
+    public void testCalculateXBATStorageRequirements() {
+        int[] blockCounts = { 0, 1, 127, 128 };
+        int[] requirements = { 0, 1, 1, 2 };
 
         for (int j = 0; j < blockCounts.length; j++)
         {
             assertEquals(
                 "requirement for " + blockCounts[ j ], requirements[ j ],
-                BATBlock.calculateXBATStorageRequirements(blockCounts[ j ]));
+                BATBlock.calculateXBATStorageRequirements(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, blockCounts[ j ]));
         }
     }
 
-    /**
-     * test entriesPerBlock
-     */
-
-    public void testEntriesPerBlock()
-    {
-        assertEquals(128, BATBlock.entriesPerBlock());
+    public void testEntriesPerBlock() {
+        assertEquals(128, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS.getBATEntriesPerBlock()); 
     }
-
-    /**
-     * test entriesPerXBATBlock
-     */
-
-    public void testEntriesPerXBATBlock()
-    {
-        assertEquals(127, BATBlock.entriesPerXBATBlock());
+    public void testEntriesPerXBATBlock() {
+        assertEquals(127, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS.getXBATEntriesPerBlock());
     }
-
-    /**
-     * test getXBATChainOffset
-     */
-
-    public void testGetXBATChainOffset()
-    {
-        assertEquals(508, BATBlock.getXBATChainOffset());
+    public void testGetXBATChainOffset() {
+        assertEquals(508, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS.getNextXBATChainOffset());
     }
+    
+    public void testCalculateMaximumSize() throws Exception {
+       // Zero fat blocks isn't technically valid, but it'd be header only
+       assertEquals(
+             512, 
+             BATBlock.calculateMaximumSize(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 0)
+       );
+       assertEquals(
+             4096, 
+             BATBlock.calculateMaximumSize(POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS, 0)
+       );
+       
+       // A single FAT block can address 128/1024 blocks
+       assertEquals(
+             512 + 512*128, 
+             BATBlock.calculateMaximumSize(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 1)
+       );
+       assertEquals(
+             4096 + 4096*1024, 
+             BATBlock.calculateMaximumSize(POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS, 1)
+       );
+       
+       assertEquals(
+             512 + 4*512*128, 
+             BATBlock.calculateMaximumSize(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 4)
+       );
+       assertEquals(
+             4096 + 4*4096*1024, 
+             BATBlock.calculateMaximumSize(POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS, 4)
+       );
+       
+       // One XBAT block holds 127/1023 individual BAT blocks, so they can address
+       //  a fairly hefty amount of space themselves
+       // However, the BATs continue as before
+       assertEquals(
+             512 + 109*512*128, 
+             BATBlock.calculateMaximumSize(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 109)
+       );
+       assertEquals(
+             4096 + 109*4096*1024, 
+             BATBlock.calculateMaximumSize(POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS, 109)
+       );
+             
+       assertEquals(
+             512 + 110*512*128, 
+             BATBlock.calculateMaximumSize(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 110)
+       );
+       assertEquals(
+             4096 + 110*4096*1024, 
+             BATBlock.calculateMaximumSize(POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS, 110)
+       );
+       
+       assertEquals(
+             512 + 112*512*128, 
+             BATBlock.calculateMaximumSize(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 112)
+       );
+       assertEquals(
+             4096 + 112*4096*1024, 
+             BATBlock.calculateMaximumSize(POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS, 112)
+       );
+    }
+    
+    public void testGetBATBlockAndIndex() throws Exception {
+       HeaderBlock header = new HeaderBlock(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+       List<BATBlock> blocks = new ArrayList<BATBlock>();
+       int offset;
+       
+       
+       // First, try a one BAT block file
+       header.setBATCount(1);
+       blocks.add(
+             BATBlock.createBATBlock(header.getBigBlockSize(), ByteBuffer.allocate(512))
+       );
+       
+       offset = 0;
+       assertEquals(0, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 1;
+       assertEquals(1, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 127;
+       assertEquals(127, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       
+       // Now go for one with multiple BAT blocks
+       header.setBATCount(2);
+       blocks.add(
+             BATBlock.createBATBlock(header.getBigBlockSize(), ByteBuffer.allocate(512))
+       );
+       
+       offset = 0;
+       assertEquals(0, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 127;
+       assertEquals(127, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 128;
+       assertEquals(0, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(1, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 129;
+       assertEquals(1, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(1, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       
+       // The XBAT count makes no difference, as we flatten in memory
+       header.setBATCount(1);
+       header.setXBATCount(1);
+       offset = 0;
+       assertEquals(0, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 126;
+       assertEquals(126, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 127;
+       assertEquals(127, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 128;
+       assertEquals(0, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(1, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 129;
+       assertEquals(1, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(1, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       
+       // Check with the bigger block size too
+       header = new HeaderBlock(POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS);
+       
+       offset = 0;
+       assertEquals(0, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 1022;
+       assertEquals(1022, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 1023;
+       assertEquals(1023, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 1024;
+       assertEquals(0, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(1, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
 
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println("Testing org.apache.poi.poifs.storage.BATBlock");
-        junit.textui.TestRunner.run(TestBATBlock.class);
+       // Biggr block size, back to real BATs
+       header.setBATCount(2);
+       
+       offset = 0;
+       assertEquals(0, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 1022;
+       assertEquals(1022, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 1023;
+       assertEquals(1023, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(0, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
+       
+       offset = 1024;
+       assertEquals(0, BATBlock.getBATBlockAndIndex(offset, header, blocks).getIndex());
+       assertEquals(1, blocks.indexOf( BATBlock.getBATBlockAndIndex(offset, header, blocks).getBlock() ));
     }
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestBlockAllocationTableReader.java b/src/testcases/org/apache/poi/poifs/storage/TestBlockAllocationTableReader.java
index a209de6..6a249af 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestBlockAllocationTableReader.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestBlockAllocationTableReader.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -7,7 +6,7 @@
    (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
+	   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,
@@ -15,17 +14,20 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
 
-import java.util.*;
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
 
-import junit.framework.*;
-
+import org.apache.poi.poifs.common.POIFSBigBlockSize;
 import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.util.HexRead;
 import org.apache.poi.util.LittleEndian;
 import org.apache.poi.util.LittleEndianConsts;
 
@@ -34,1333 +36,394 @@
  *
  * @author Marc Johnson
  */
+public final class TestBlockAllocationTableReader extends TestCase {
 
-public class TestBlockAllocationTableReader
-    extends TestCase
-{
+	/**
+	 * Test small block allocation table constructor
+	 */
+	public void testSmallBATConstructor() throws IOException {
 
-    /**
-     * Constructor TestBlockAllocationTableReader
-     *
-     * @param name
-     */
+		// need to create an array of raw blocks containing the SBAT,
+		// and a small document block list
+		String[] sbat_data = {
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF",
+			"FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF",
+			"FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF",
+			"FE FF FF FF 22 00 00 00 FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+		};
 
-    public TestBlockAllocationTableReader(String name)
-    {
-        super(name);
-    }
+		RawDataBlock[] sbats = { new RawDataBlock(makeDataStream(sbat_data)) };
 
-    /**
-     * Test small block allocation table constructor
-     *
-     * @exception IOException
-     */
+		String[] sbt_data = {
+			"08 00 28 00 6A 61 6D 65 73 2D 55 37 37 32 37 39 32 2D 28 31 36 2D 4F 63 74 2D 32 30 30 31 40 31",
+			"36 2D 34 31 2D 33 33 29 2E 5A 44 46 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"07 00 00 00 00 00 80 27 E2 40 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"07 00 00 00 00 00 80 27 E2 40 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"07 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"0B 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"03 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 02 00 20 31 08 00 05 00 53 61 76 65 64 08 00 17 00 53 2E 48 55 53 53 41 49 4E 20 41 20 44",
+			"45 56 20 4F 46 46 52 20 55 4B 08 00 0B 00 31 36 2D 4F 63 74 2D 32 30 30 31 08 00 05 00 35 2E 33",
+			"2E 32 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 05 00 6A 61 6D 65 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 03 00 47 42 50 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 1D 00 28 41 29 31 36 2D 4F 63 74 2D 32 30 30 31 20 74 6F 20 31 36 2D 4F 63 74 2D 32 30 30",
+			"31 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 01 00 31 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 18 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00",
+			"02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00",
+			"02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 03 00 47 42 50 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 17 00 53 2E 48 55 53 53 41 49 4E 20 41 20 44 45 56 20 4F 46 46 52 20 55 4B 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+		};
 
-    public void testSmallBATConstructor()
-        throws IOException
-    {
+		RawDataBlock[] sbts = new RawDataBlock[7];
+		InputStream sbt_input = makeDataStream(sbt_data);
 
-        // need to create an array of raw blocks containing the SBAT,
-        // and a small document block list
-        byte[]               sbat_data =
-        {
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF
-        };
-        RawDataBlock[]       sbats     =
-        {
-            new RawDataBlock(new ByteArrayInputStream(sbat_data))
-        };
-        byte[]               sbt_data  =
-        {
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x28, ( byte ) 0x00,
-            ( byte ) 0x6A, ( byte ) 0x61, ( byte ) 0x6D, ( byte ) 0x65,
-            ( byte ) 0x73, ( byte ) 0x2D, ( byte ) 0x55, ( byte ) 0x37,
-            ( byte ) 0x37, ( byte ) 0x32, ( byte ) 0x37, ( byte ) 0x39,
-            ( byte ) 0x32, ( byte ) 0x2D, ( byte ) 0x28, ( byte ) 0x31,
-            ( byte ) 0x36, ( byte ) 0x2D, ( byte ) 0x4F, ( byte ) 0x63,
-            ( byte ) 0x74, ( byte ) 0x2D, ( byte ) 0x32, ( byte ) 0x30,
-            ( byte ) 0x30, ( byte ) 0x31, ( byte ) 0x40, ( byte ) 0x31,
-            ( byte ) 0x36, ( byte ) 0x2D, ( byte ) 0x34, ( byte ) 0x31,
-            ( byte ) 0x2D, ( byte ) 0x33, ( byte ) 0x33, ( byte ) 0x29,
-            ( byte ) 0x2E, ( byte ) 0x5A, ( byte ) 0x44, ( byte ) 0x46,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x80, ( byte ) 0x27,
-            ( byte ) 0xE2, ( byte ) 0x40, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x80, ( byte ) 0x27,
-            ( byte ) 0xE2, ( byte ) 0x40, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x31, ( byte ) 0x08, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x53, ( byte ) 0x61,
-            ( byte ) 0x76, ( byte ) 0x65, ( byte ) 0x64, ( byte ) 0x08,
-            ( byte ) 0x00, ( byte ) 0x17, ( byte ) 0x00, ( byte ) 0x53,
-            ( byte ) 0x2E, ( byte ) 0x48, ( byte ) 0x55, ( byte ) 0x53,
-            ( byte ) 0x53, ( byte ) 0x41, ( byte ) 0x49, ( byte ) 0x4E,
-            ( byte ) 0x20, ( byte ) 0x41, ( byte ) 0x20, ( byte ) 0x44,
-            ( byte ) 0x45, ( byte ) 0x56, ( byte ) 0x20, ( byte ) 0x4F,
-            ( byte ) 0x46, ( byte ) 0x46, ( byte ) 0x52, ( byte ) 0x20,
-            ( byte ) 0x55, ( byte ) 0x4B, ( byte ) 0x08, ( byte ) 0x00,
-            ( byte ) 0x0B, ( byte ) 0x00, ( byte ) 0x31, ( byte ) 0x36,
-            ( byte ) 0x2D, ( byte ) 0x4F, ( byte ) 0x63, ( byte ) 0x74,
-            ( byte ) 0x2D, ( byte ) 0x32, ( byte ) 0x30, ( byte ) 0x30,
-            ( byte ) 0x31, ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x05,
-            ( byte ) 0x00, ( byte ) 0x35, ( byte ) 0x2E, ( byte ) 0x33,
-            ( byte ) 0x2E, ( byte ) 0x32, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x00,
-            ( byte ) 0x6A, ( byte ) 0x61, ( byte ) 0x6D, ( byte ) 0x65,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x42, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x1D, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x41, ( byte ) 0x29, ( byte ) 0x31,
-            ( byte ) 0x36, ( byte ) 0x2D, ( byte ) 0x4F, ( byte ) 0x63,
-            ( byte ) 0x74, ( byte ) 0x2D, ( byte ) 0x32, ( byte ) 0x30,
-            ( byte ) 0x30, ( byte ) 0x31, ( byte ) 0x20, ( byte ) 0x74,
-            ( byte ) 0x6F, ( byte ) 0x20, ( byte ) 0x31, ( byte ) 0x36,
-            ( byte ) 0x2D, ( byte ) 0x4F, ( byte ) 0x63, ( byte ) 0x74,
-            ( byte ) 0x2D, ( byte ) 0x32, ( byte ) 0x30, ( byte ) 0x30,
-            ( byte ) 0x31, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x00,
-            ( byte ) 0x31, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x18, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x42, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x17, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x2E, ( byte ) 0x48, ( byte ) 0x55,
-            ( byte ) 0x53, ( byte ) 0x53, ( byte ) 0x41, ( byte ) 0x49,
-            ( byte ) 0x4E, ( byte ) 0x20, ( byte ) 0x41, ( byte ) 0x20,
-            ( byte ) 0x44, ( byte ) 0x45, ( byte ) 0x56, ( byte ) 0x20,
-            ( byte ) 0x4F, ( byte ) 0x46, ( byte ) 0x46, ( byte ) 0x52,
-            ( byte ) 0x20, ( byte ) 0x55, ( byte ) 0x4B, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00
-        };
-        RawDataBlock[]       sbts      = new RawDataBlock[ 7 ];
-        ByteArrayInputStream sbt_input = new ByteArrayInputStream(sbt_data);
+		for (int j = 0; j < 7; j++) {
+			sbts[j] = new RawDataBlock(sbt_input);
+		}
+		SmallDocumentBlockList small_blocks = new SmallDocumentBlockList(SmallDocumentBlock
+				.extract(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, sbts));
+		BlockAllocationTableReader sbat = new BlockAllocationTableReader(
+		      POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, sbats, small_blocks);
+		boolean[] isUsed = {
+			false, false, false, false, false, false, false, false, false,
+			false, true, true, true, true, true, true, true, true, true, true,
+			true, true, true, true, true, true, true, true, true, true, true,
+			true, true, true, true, true, true, true, true, true, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false
+		};
+		int[] nextIndex = {
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -2, -2, -2, -2,
+			-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+			-2, 34, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+		};
 
-        for (int j = 0; j < 7; j++)
-        {
-            sbts[ j ] = new RawDataBlock(sbt_input);
-        }
-        SmallDocumentBlockList     small_blocks =
-            new SmallDocumentBlockList(SmallDocumentBlock.extract(sbts));
-        BlockAllocationTableReader sbat         =
-            new BlockAllocationTableReader(sbats, small_blocks);
-        boolean[]                  isUsed       =
-        {
-            false, false, false, false, false, false, false, false, false,
-            false, true, true, true, true, true, true, true, true, true, true,
-            true, true, true, true, true, true, true, true, true, true, true,
-            true, true, true, true, true, true, true, true, true, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false, false, false, false,
-            false, false, false, false, false, false
-        };
-        int[]                      nextIndex    =
-        {
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -2, -2, -2, -2,
-            -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-            -2, 34, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-        };
+		for (int j = 0; j < 128; j++) {
+			if (isUsed[j]) {
+				assertTrue("checking usage of block " + j, sbat.isUsed(j));
+				assertEquals("checking usage of block " + j, nextIndex[j], sbat
+						.getNextBlockIndex(j));
+				small_blocks.remove(j);
+			} else {
+				assertTrue("checking usage of block " + j, !sbat.isUsed(j));
+				try {
+					small_blocks.remove(j);
+					fail("removing block " + j + " should have failed");
+				} catch (IOException ignored) {
+					// expected during successful test
+				}
+			}
+		}
+	}
 
-        for (int j = 0; j < 128; j++)
-        {
-            if (isUsed[ j ])
-            {
-                assertTrue("checking usage of block " + j, sbat.isUsed(j));
-                assertEquals("checking usage of block " + j, nextIndex[ j ],
-                             sbat.getNextBlockIndex(j));
-                small_blocks.remove(j);
-            }
-            else
-            {
-                assertTrue("checking usage of block " + j, !sbat.isUsed(j));
-                try
-                {
-                    small_blocks.remove(j);
-                    fail("removing block " + j + " should have failed");
-                }
-                catch (IOException ignored)
-                {
-                }
-            }
-        }
-    }
+	private static InputStream makeDataStream(String[] hexDataLines) {
+		return new ByteArrayInputStream(RawDataUtil.decode(hexDataLines));
+	}
 
-    /**
-     * Test reading constructor
-     *
-     * @exception IOException
-     */
+	public void testReadingConstructor() throws IOException {
 
-    public void testReadingConstructor()
-        throws IOException
-    {
+		// create a document, minus the header block, and use that to
+		// create a RawDataBlockList. The document will exist entire
+		// of BATBlocks and XBATBlocks
+		//
+		// we will create two XBAT blocks, which will encompass 128
+		// BAT blocks between them, and two extra BAT blocks which
+		// will be in the block array passed to the constructor. This
+		// makes a total of 130 BAT blocks, which will encompass
+		// 16,640 blocks, for a file size of some 8.5 megabytes.
+		//
+		// Naturally, we'll fake that out ...
+		//
+		// map of blocks:
+		// block 0: xbat block 0
+		// block 1: xbat block 1
+		// block 2: bat block 0
+		// block 3: bat block 1
+		// blocks 4-130: bat blocks 2-128, contained in xbat block 0
+		// block 131: bat block 129, contained in xbat block 1
+		// blocks 132-16639: fictitious blocks, faked out. All blocks
+		// whose index is evenly divisible by 256
+		// will be unused
+		LocalRawDataBlockList list = new LocalRawDataBlockList();
 
-        // create a document, minus the header block, and use that to
-        // create a RawDataBlockList. The document will exist entire
-        // of BATBlocks and XBATBlocks
-        // 
-        // we will create two XBAT blocks, which will encompass 128
-        // BAT blocks between them, and two extra BAT blocks which
-        // will be in the block array passed to the constructor. This
-        // makes a total of 130 BAT blocks, which will encompass
-        // 16,640 blocks, for a file size of some 8.5 megabytes.
-        // 
-        // Naturally, we'll fake that out ...
-        // 
-        // map of blocks:
-        // block 0: xbat block 0
-        // block 1: xbat block 1
-        // block 2: bat block 0
-        // block 3: bat block 1
-        // blocks 4-130: bat blocks 2-128, contained in xbat block 0
-        // block 131: bat block 129, contained in xbat block 1
-        // blocks 132-16639: fictitious blocks, faked out. All blocks
-        // whose index is evenly divisible by 256
-        // will be unused
-        LocalRawDataBlockList list = new LocalRawDataBlockList();
+		list.createNewXBATBlock(4, 130, 1);
+		list.createNewXBATBlock(131, 131, -2);
+		for (int j = 0; j < 130; j++) {
+			list.createNewBATBlock(j * 128);
+		}
+		list.fill(132);
+		int[] blocks = { 2, 3 };
+		BlockAllocationTableReader table = new BlockAllocationTableReader(
+		      POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 130, blocks, 2, 0, list);
 
-        list.createNewXBATBlock(4, 130, 1);
-        list.createNewXBATBlock(131, 131, -2);
-        for (int j = 0; j < 130; j++)
-        {
-            list.createNewBATBlock(j * 128);
-        }
-        list.fill(132);
-        int[]                      blocks =
-        {
-            2, 3
-        };
-        BlockAllocationTableReader table  =
-            new BlockAllocationTableReader(130, blocks, 2, 0, list);
+		for (int i = 0; i < (130 * 128); i++) {
+			if (i % 256 == 0) {
+				assertTrue("verifying block " + i + " is unused", !table.isUsed(i));
+			} else if (i % 256 == 255) {
+				assertEquals("Verify end of chain for block " + i, POIFSConstants.END_OF_CHAIN,
+						table.getNextBlockIndex(i));
+			} else {
+				assertEquals("Verify next index for block " + i, i + 1, table.getNextBlockIndex(i));
+			}
+		}
+	}
 
-        for (int i = 0; i < (130 * 128); i++)
-        {
-            if (i % 256 == 0)
-            {
-                assertTrue("verifying block " + i + " is unused",
-                           !table.isUsed(i));
-            }
-            else if (i % 256 == 255)
-            {
-                assertEquals("Verify end of chain for block " + i,
-                             POIFSConstants.END_OF_CHAIN,
-                             table.getNextBlockIndex(i));
-            }
-            else
-            {
-                assertEquals("Verify next index for block " + i, i + 1,
-                             table.getNextBlockIndex(i));
-            }
-        }
-    }
+	public void testFetchBlocks() throws IOException {
 
-    /**
-     * Test fetchBlocks
-     *
-     * @exception IOException
-     */
+		// strategy:
+		//
+		// 1. set up a single BAT block from which to construct a
+		// BAT. create nonsense blocks in the raw data block list
+		// corresponding to the indices in the BAT block.
+		// 2. The indices will include very short documents (0 and 1
+		// block in length), longer documents, and some screwed up
+		// documents (one with a loop, one that will peek into
+		// another document's data, one that includes an unused
+		// document, one that includes a reserved (BAT) block, one
+		// that includes a reserved (XBAT) block, and one that
+		// points off into space somewhere
+		LocalRawDataBlockList list = new LocalRawDataBlockList();
+		byte[] data = new byte[512];
+		int offset = 0;
 
-    public void testFetchBlocks()
-        throws IOException
-    {
+		LittleEndian.putInt(data, offset, -3); // for the BAT block itself
+		offset += LittleEndianConsts.INT_SIZE;
 
-        // strategy:
-        // 
-        // 1. set up a single BAT block from which to construct a
-        // BAT. create nonsense blocks in the raw data block list
-        // corresponding to the indices in the BAT block.
-        // 2. The indices will include very short documents (0 and 1
-        // block in length), longer documents, and some screwed up
-        // documents (one with a loop, one that will peek into
-        // another document's data, one that includes an unused
-        // document, one that includes a reserved (BAT) block, one
-        // that includes a reserved (XBAT) block, and one that
-        // points off into space somewhere
-        LocalRawDataBlockList list   = new LocalRawDataBlockList();
-        byte[]                data   = new byte[ 512 ];
-        int                   offset = 0;
+		// document 1: is at end of file already; start block = -2
+		// document 2: has only one block; start block = 1
+		LittleEndian.putInt(data, offset, -2);
+		offset += LittleEndianConsts.INT_SIZE;
 
-        LittleEndian.putInt(data, offset, -3);   // for the BAT block itself
-        offset += LittleEndianConsts.INT_SIZE;
+		// document 3: has a loop in it; start block = 2
+		LittleEndian.putInt(data, offset, 2);
+		offset += LittleEndianConsts.INT_SIZE;
 
-        // document 1: is at end of file already; start block = -2
-        // document 2: has only one block; start block = 1
-        LittleEndian.putInt(data, offset, -2);
-        offset += LittleEndianConsts.INT_SIZE;
+		// document 4: peeks into document 2's data; start block = 3
+		LittleEndian.putInt(data, offset, 4);
+		offset += LittleEndianConsts.INT_SIZE;
+		LittleEndian.putInt(data, offset, 1);
+		offset += LittleEndianConsts.INT_SIZE;
 
-        // document 3: has a loop in it; start block = 2
-        LittleEndian.putInt(data, offset, 2);
-        offset += LittleEndianConsts.INT_SIZE;
+		// document 5: includes an unused block; start block = 5
+		LittleEndian.putInt(data, offset, 6);
+		offset += LittleEndianConsts.INT_SIZE;
+		LittleEndian.putInt(data, offset, -1);
+		offset += LittleEndianConsts.INT_SIZE;
 
-        // document 4: peeks into document 2's data; start block = 3
-        LittleEndian.putInt(data, offset, 4);
-        offset += LittleEndianConsts.INT_SIZE;
-        LittleEndian.putInt(data, offset, 1);
-        offset += LittleEndianConsts.INT_SIZE;
+		// document 6: includes a BAT block; start block = 7
+		LittleEndian.putInt(data, offset, 8);
+		offset += LittleEndianConsts.INT_SIZE;
+		LittleEndian.putInt(data, offset, 0);
+		offset += LittleEndianConsts.INT_SIZE;
 
-        // document 5: includes an unused block; start block = 5
-        LittleEndian.putInt(data, offset, 6);
-        offset += LittleEndianConsts.INT_SIZE;
-        LittleEndian.putInt(data, offset, -1);
-        offset += LittleEndianConsts.INT_SIZE;
+		// document 7: includes an XBAT block; start block = 9
+		LittleEndian.putInt(data, offset, 10);
+		offset += LittleEndianConsts.INT_SIZE;
+		LittleEndian.putInt(data, offset, -4);
+		offset += LittleEndianConsts.INT_SIZE;
 
-        // document 6: includes a BAT block; start block = 7
-        LittleEndian.putInt(data, offset, 8);
-        offset += LittleEndianConsts.INT_SIZE;
-        LittleEndian.putInt(data, offset, 0);
-        offset += LittleEndianConsts.INT_SIZE;
+		// document 8: goes off into space; start block = 11;
+		LittleEndian.putInt(data, offset, 1000);
+		offset += LittleEndianConsts.INT_SIZE;
 
-        // document 7: includes an XBAT block; start block = 9
-        LittleEndian.putInt(data, offset, 10);
-        offset += LittleEndianConsts.INT_SIZE;
-        LittleEndian.putInt(data, offset, -4);
-        offset += LittleEndianConsts.INT_SIZE;
+		// document 9: no screw ups; start block = 12;
+		int index = 13;
 
-        // document 8: goes off into space; start block = 11;
-        LittleEndian.putInt(data, offset, 1000);
-        offset += LittleEndianConsts.INT_SIZE;
+		for (; offset < 508; offset += LittleEndianConsts.INT_SIZE) {
+			LittleEndian.putInt(data, offset, index++);
+		}
+		LittleEndian.putInt(data, offset, -2);
+		list.add(new RawDataBlock(new ByteArrayInputStream(data)));
+		list.fill(1);
+		int[] blocks = { 0 };
+		BlockAllocationTableReader table = new BlockAllocationTableReader(
+		      POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 1, blocks, 0, -2, list);
+		int[] start_blocks = { -2, 1, 2, 3, 5, 7, 9, 11, 12 };
+		int[] expected_length = { 0, 1, -1, -1, -1, -1, -1, -1, 116 };
 
-        // document 9: no screw ups; start block = 12;
-        int index = 13;
+		for (int j = 0; j < start_blocks.length; j++) {
+			try {
+				ListManagedBlock[] dataBlocks = table.fetchBlocks(start_blocks[j], -1, list);
 
-        for (; offset < 508; offset += LittleEndianConsts.INT_SIZE)
-        {
-            LittleEndian.putInt(data, offset, index++);
-        }
-        LittleEndian.putInt(data, offset, -2);
-        list.add(new RawDataBlock(new ByteArrayInputStream(data)));
-        list.fill(1);
-        int[]                      blocks          =
-        {
-            0
-        };
-        BlockAllocationTableReader table           =
-            new BlockAllocationTableReader(1, blocks, 0, -2, list);
-        int[]                      start_blocks    =
-        {
-            -2, 1, 2, 3, 5, 7, 9, 11, 12
-        };
-        int[]                      expected_length =
-        {
-            0, 1, -1, -1, -1, -1, -1, -1, 116
-        };
+				if (expected_length[j] == -1) {
+					fail("document " + j + " should have failed, but found a length of "
+							+ dataBlocks.length);
+				} else {
+					assertEquals(expected_length[j], dataBlocks.length);
+				}
+			} catch (IOException e) {
+				if (expected_length[j] == -1) {
 
-        for (int j = 0; j < start_blocks.length; j++)
-        {
-            try
-            {
-                ListManagedBlock[] dataBlocks =
-                    table.fetchBlocks(start_blocks[ j ], list);
+					// no problem, we expected a failure here
+				} else {
+					throw e;
+				}
+			}
+		}
+	}
 
-                if (expected_length[ j ] == -1)
-                {
-                    fail("document " + j + " should have failed");
-                }
-                else
-                {
-                    assertEquals(expected_length[ j ], dataBlocks.length);
-                }
-            }
-            catch (IOException e)
-            {
-                if (expected_length[ j ] == -1)
-                {
+	/**
+	 * Bugzilla 48085 describes an error where a corrupted Excel file causes POI to throw an
+	 * {@link OutOfMemoryError}.
+	 */
+	public void testBadSectorAllocationTableSize_bug48085() {
+		int BLOCK_SIZE = 512;
+		POIFSBigBlockSize bigBlockSize = POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS;
+		assertEquals(BLOCK_SIZE, bigBlockSize.getBigBlockSize());
+		
+		// 512 bytes take from the start of bugzilla attachment 24444
+		byte[] initData = HexRead.readFromString(
 
-                    // no problem, we expected a failure here
-                }
-                else
-                {
-                    throw e;
-                }
-            }
-        }
-    }
+		"D0 CF 11 E0 A1 B1 1A E1 20 20 20 20 20 20 20 20  20 20 20 20 20 20 20 20 3E 20 03 20 FE FF 09 20" +
+		"06 20 20 20 20 20 20 20 20 20 20 20 01 20 20 20  01 20 20 20 20 20 20 20 20 10 20 20 02 20 20 20" +
+		"02 20 20 20 FE FF FF FF 20 20 20 20 20 20 20 20  "
+		);
+		// the rest of the block is 'FF'
+		byte[] data = new byte[BLOCK_SIZE];
+		Arrays.fill(data, (byte)0xFF);
+		System.arraycopy(initData, 0, data, 0, initData.length);
 
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.storage.BlockAllocationTableReader");
-        junit.textui.TestRunner.run(TestBlockAllocationTableReader.class);
-    }
+		// similar code to POIFSFileSystem.<init>:
+		InputStream stream = new ByteArrayInputStream(data);
+		HeaderBlock hb;
+		RawDataBlockList dataBlocks;
+		try {
+			hb = new HeaderBlock(stream);
+			dataBlocks = new RawDataBlockList(stream, bigBlockSize);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+		try {
+			new BlockAllocationTableReader(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 
+			      hb.getBATCount(), hb.getBATArray(), hb.getXBATCount(),
+					hb.getXBATIndex(), dataBlocks);
+		} catch (IOException e) {
+			// expected during successful test
+         assertEquals("Block count 538976257 is too high. POI maximum is 65535.", e.getMessage());
+		} catch (OutOfMemoryError e) {
+			if (e.getStackTrace()[1].getMethodName().equals("testBadSectorAllocationTableSize")) {
+				throw new AssertionFailedError("Identified bug 48085");
+			}
+		}
+	}
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestBlockAllocationTableWriter.java b/src/testcases/org/apache/poi/poifs/storage/TestBlockAllocationTableWriter.java
index e13191a..4539c60 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestBlockAllocationTableWriter.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestBlockAllocationTableWriter.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,15 +14,14 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
 
-import java.util.*;
-
-import junit.framework.*;
+import junit.framework.TestCase;
 
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.util.LittleEndian;
@@ -34,30 +32,11 @@
  *
  * @author Marc Johnson
  */
+public final class TestBlockAllocationTableWriter extends TestCase {
 
-public class TestBlockAllocationTableWriter
-    extends TestCase
-{
-
-    /**
-     * Constructor TestBlockAllocationTableWriter
-     *
-     * @param name
-     */
-
-    public TestBlockAllocationTableWriter(String name)
-    {
-        super(name);
-    }
-
-    /**
-     * Test the allocateSpace method.
-     */
-
-    public void testAllocateSpace()
-    {
+    public void testAllocateSpace() {
         BlockAllocationTableWriter table         =
-            new BlockAllocationTableWriter();
+            new BlockAllocationTableWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
         int[]                      blockSizes    =
         {
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
@@ -71,45 +50,37 @@
         }
     }
 
-    /**
-     * Test the createBlocks method
-     *
-     * @exception IOException
-     */
-
-    public void testCreateBlocks()
-        throws IOException
-    {
-        BlockAllocationTableWriter table = new BlockAllocationTableWriter();
+    public void testCreateBlocks() {
+        BlockAllocationTableWriter table = new BlockAllocationTableWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
 
         table.allocateSpace(127);
         table.createBlocks();
         verifyBlocksCreated(table, 1);
-        table = new BlockAllocationTableWriter();
+        table = new BlockAllocationTableWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
         table.allocateSpace(128);
         table.createBlocks();
         verifyBlocksCreated(table, 2);
-        table = new BlockAllocationTableWriter();
+        table = new BlockAllocationTableWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
         table.allocateSpace(254);
         table.createBlocks();
         verifyBlocksCreated(table, 2);
-        table = new BlockAllocationTableWriter();
+        table = new BlockAllocationTableWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
         table.allocateSpace(255);
         table.createBlocks();
         verifyBlocksCreated(table, 3);
-        table = new BlockAllocationTableWriter();
+        table = new BlockAllocationTableWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
         table.allocateSpace(13843);
         table.createBlocks();
         verifyBlocksCreated(table, 109);
-        table = new BlockAllocationTableWriter();
+        table = new BlockAllocationTableWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
         table.allocateSpace(13844);
         table.createBlocks();
         verifyBlocksCreated(table, 110);
-        table = new BlockAllocationTableWriter();
+        table = new BlockAllocationTableWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
         table.allocateSpace(13969);
         table.createBlocks();
         verifyBlocksCreated(table, 110);
-        table = new BlockAllocationTableWriter();
+        table = new BlockAllocationTableWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
         table.allocateSpace(13970);
         table.createBlocks();
         verifyBlocksCreated(table, 111);
@@ -117,14 +88,9 @@
 
     /**
      * Test content produced by BlockAllocationTableWriter
-     *
-     * @exception IOException
      */
-
-    public void testProduct()
-        throws IOException
-    {
-        BlockAllocationTableWriter table = new BlockAllocationTableWriter();
+    public void testProduct() throws IOException {
+        BlockAllocationTableWriter table = new BlockAllocationTableWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
 
         for (int k = 1; k <= 22; k++)
         {
@@ -168,28 +134,16 @@
         }
     }
 
-    private void verifyBlocksCreated(BlockAllocationTableWriter table,
-                                     int count)
-        throws IOException
-    {
+    private static void verifyBlocksCreated(BlockAllocationTableWriter table, int count){
         ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
-        table.writeBlocks(stream);
+        try {
+			table.writeBlocks(stream);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
         byte[] output = stream.toByteArray();
 
         assertEquals(count * 512, output.length);
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.storage.BlockAllocationTableWriter");
-        junit.textui.TestRunner.run(TestBlockAllocationTableWriter.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestBlockListImpl.java b/src/testcases/org/apache/poi/poifs/storage/TestBlockListImpl.java
index 6b8d091..2a36dd0 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestBlockListImpl.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestBlockListImpl.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,16 +14,18 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
-import java.util.*;
+import junit.framework.TestCase;
 
-import junit.framework.*;
-
+import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.util.LittleEndian;
 import org.apache.poi.util.LittleEndianConsts;
 
@@ -33,32 +34,18 @@
  *
  * @author Marc Johnson
  */
-
-public class TestBlockListImpl
-    extends TestCase
-{
-
-    /**
-     * Constructor TestBlockListImpl
-     *
-     * @param name
-     */
-
-    public TestBlockListImpl(String name)
-    {
-        super(name);
+public final class TestBlockListImpl extends TestCase {
+    private static final class BlockListTestImpl extends BlockListImpl {
+        public BlockListTestImpl() {
+            // no extra initialisation
+        }
+    }
+    private static BlockListImpl create() {
+        return new BlockListTestImpl();
     }
 
-    /**
-     * test zap method
-     *
-     * @exception IOException
-     */
-
-    public void testZap()
-        throws IOException
-    {
-        BlockListImpl list = new BlockListImpl();
+    public void testZap() throws IOException {
+        BlockListImpl list = create();
 
         // verify that you can zap anything
         for (int j = -2; j < 10; j++)
@@ -92,16 +79,9 @@
         }
     }
 
-    /**
-     * test remove method
-     *
-     * @exception IOException
-     */
 
-    public void testRemove()
-        throws IOException
-    {
-        BlockListImpl  list   = new BlockListImpl();
+    public void testRemove() throws IOException {
+        BlockListImpl  list   = create();
         RawDataBlock[] blocks = new RawDataBlock[ 5 ];
         byte[]         data   = new byte[ 512 * 5 ];
 
@@ -159,22 +139,14 @@
         }
     }
 
-    /**
-     * test setBAT
-     *
-     * @exception IOException
-     */
-
-    public void testSetBAT()
-        throws IOException
-    {
-        BlockListImpl list = new BlockListImpl();
+    public void testSetBAT() throws IOException {
+        BlockListImpl list = create();
 
         list.setBAT(null);
-        list.setBAT(new BlockAllocationTableReader());
+        list.setBAT(new BlockAllocationTableReader(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS));
         try
         {
-            list.setBAT(new BlockAllocationTableReader());
+            list.setBAT(new BlockAllocationTableReader(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS));
             fail("second attempt should have failed");
         }
         catch (IOException ignored)
@@ -182,18 +154,10 @@
         }
     }
 
-    /**
-     * Test fetchBlocks
-     *
-     * @exception IOException
-     */
-
-    public void testFetchBlocks()
-        throws IOException
-    {
+    public void testFetchBlocks() throws IOException {
 
         // strategy:
-        // 
+        //
         // 1. set up a single BAT block from which to construct a
         // BAT. create nonsense blocks in the raw data block list
         // corresponding to the indices in the BAT block.
@@ -204,7 +168,7 @@
         // document, one that includes a reserved (BAT) block, one
         // that includes a reserved (XBAT) block, and one that
         // points off into space somewhere
-        BlockListImpl list       = new BlockListImpl();
+        BlockListImpl list       = create();
         List          raw_blocks = new ArrayList();
         byte[]        data       = new byte[ 512 ];
         int           offset     = 0;
@@ -270,7 +234,7 @@
             0
         };
         BlockAllocationTableReader table           =
-            new BlockAllocationTableReader(1, blocks, 0, -2, list);
+            new BlockAllocationTableReader(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 1, blocks, 0, -2, list);
         int[]                      start_blocks    =
         {
             -2, 1, 2, 3, 5, 7, 9, 11, 12
@@ -285,7 +249,7 @@
             try
             {
                 ListManagedBlock[] dataBlocks =
-                    list.fetchBlocks(start_blocks[ j ]);
+                    list.fetchBlocks(start_blocks[ j ], -1);
 
                 if (expected_length[ j ] == -1)
                 {
@@ -310,17 +274,4 @@
             }
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.storage.BlockListImpl");
-        junit.textui.TestRunner.run(TestBlockListImpl.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestDocumentBlock.java b/src/testcases/org/apache/poi/poifs/storage/TestDocumentBlock.java
index bb0ca8c..313d92c 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestDocumentBlock.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestDocumentBlock.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,25 +14,23 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 
-import java.util.*;
+import org.apache.poi.poifs.common.POIFSConstants;
 
-import junit.framework.*;
+import junit.framework.TestCase;
 
 /**
  * Class to test DocumentBlock functionality
  *
  * @author Marc Johnson
  */
-
-public class TestDocumentBlock
-    extends TestCase
-{
+public final class TestDocumentBlock extends TestCase {
     static final private byte[] _testdata;
 
     static
@@ -44,25 +41,10 @@
             _testdata[ j ] = ( byte ) j;
         }
     }
-    ;
-
-    /**
-     * Constructor TestDocumentBlock
-     *
-     * @param name
-     */
-
-    public TestDocumentBlock(String name)
-    {
-        super(name);
-    }
 
     /**
      * Test the writing DocumentBlock constructor.
-     *
-     * @exception IOException
      */
-
     public void testConstructor()
         throws IOException
     {
@@ -75,7 +57,7 @@
             byte[] data = new byte[ Math.min(_testdata.length - index, 512) ];
 
             System.arraycopy(_testdata, index, data, 0, data.length);
-            DocumentBlock block = new DocumentBlock(input);
+            DocumentBlock block = new DocumentBlock(input, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
 
             verifyOutput(block, data);
             size += block.size();
@@ -88,46 +70,10 @@
         assertEquals(_testdata.length, size);
     }
 
-    /**
-     * test static read method
-     *
-     * @exception IOException
-     */
-
-    public void testRead()
-        throws IOException
-    {
-        DocumentBlock[]      blocks = new DocumentBlock[ 4 ];
-        ByteArrayInputStream input  = new ByteArrayInputStream(_testdata);
-
-        for (int j = 0; j < 4; j++)
-        {
-            blocks[ j ] = new DocumentBlock(input);
-        }
-        for (int j = 1; j <= 2000; j += 17)
-        {
-            byte[] buffer = new byte[ j ];
-            int    offset = 0;
-
-            for (int k = 0; k < (2000 / j); k++)
-            {
-                DocumentBlock.read(blocks, buffer, offset);
-                for (int n = 0; n < buffer.length; n++)
-                {
-                    assertEquals("checking byte " + (k * j) + n,
-                                 _testdata[ (k * j) + n ], buffer[ n ]);
-                }
-                offset += j;
-            }
-        }
-    }
 
     /**
      * Test 'reading' constructor
-     *
-     * @exception IOException
      */
-
     public void testReadingConstructor()
         throws IOException
     {
@@ -164,17 +110,4 @@
             assertEquals(( byte ) 0xFF, copy[ j ]);
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.storage.DocumentBlock");
-        junit.textui.TestRunner.run(TestDocumentBlock.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockReader.java b/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockReader.java
deleted file mode 100644
index 738aeb1..0000000
--- a/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockReader.java
+++ /dev/null
@@ -1,247 +0,0 @@
-
-/* ====================================================================
-   Licensed to the Apache Software Foundation (ASF) under one or more
-   contributor license agreements.  See the NOTICE file distributed with
-   this work for additional information regarding copyright ownership.
-   The ASF licenses this file to You 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.
-==================================================================== */
-        
-
-package org.apache.poi.poifs.storage;
-
-import java.io.*;
-
-import java.util.*;
-
-import junit.framework.*;
-
-import org.apache.poi.util.LittleEndian;
-import org.apache.poi.util.LittleEndianConsts;
-
-/**
- * Class to test HeaderBlockReader functionality
- *
- * @author Marc Johnson
- */
-
-public class TestHeaderBlockReader
-    extends TestCase
-{
-
-    /**
-     * Constructor TestHeaderBlockReader
-     *
-     * @param name
-     */
-
-    public TestHeaderBlockReader(String name)
-    {
-        super(name);
-    }
-
-    /**
-     * Test creating a HeaderBlockReader
-     *
-     * @exception IOException
-     */
-
-    public void testConstructors()
-        throws IOException
-    {
-        byte[]            content =
-        {
-            ( byte ) 0xD0, ( byte ) 0xCF, ( byte ) 0x11, ( byte ) 0xE0,
-            ( byte ) 0xA1, ( byte ) 0xB1, ( byte ) 0x1A, ( byte ) 0xE1,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3B, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0x09, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF
-        };
-        HeaderBlockReader block   =
-            new HeaderBlockReader(new ByteArrayInputStream(content));
-
-        assertEquals(-2, block.getPropertyStart());
-
-        // verify we can't read a short block
-        byte[] shortblock = new byte[ 511 ];
-
-        System.arraycopy(content, 0, shortblock, 0, 511);
-        try
-        {
-            block =
-                new HeaderBlockReader(new ByteArrayInputStream(shortblock));
-            fail("Should have caught IOException reading a short block");
-        }
-        catch (IOException ignored)
-        {
-
-            // as expected
-        }
-
-        // try various forms of corruption
-        for (int index = 0; index < 8; index++)
-        {
-            content[ index ] = ( byte ) (content[ index ] - 1);
-            try
-            {
-                block =
-                    new HeaderBlockReader(new ByteArrayInputStream(content));
-                fail("Should have caught IOException corrupting byte "
-                     + index);
-            }
-            catch (IOException ignored)
-            {
-
-                // as expected
-            }
-
-            // restore byte value
-            content[ index ] = ( byte ) (content[ index ] + 1);
-        }
-    }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.storage.HeaderBlockReader");
-        junit.textui.TestRunner.run(TestHeaderBlockReader.class);
-    }
-}
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockReading.java b/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockReading.java
new file mode 100644
index 0000000..15077c4
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockReading.java
@@ -0,0 +1,83 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.storage;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+
+import junit.framework.TestCase;
+
+/**
+ * Class to test HeaderBlockReader functionality
+ *
+ * @author Marc Johnson
+ */
+public final class TestHeaderBlockReading extends TestCase {
+
+	public void testConstructors() throws IOException {
+		String[] hexData = {
+			"D0 CF 11 E0 A1 B1 1A E1 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3B 00 03 00 FE FF 09 00",
+			"06 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 10 00 00 FE FF FF FF",
+			"01 00 00 00 FE FF FF FF 00 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+		};
+		byte[] content = RawDataUtil.decode(hexData);
+		HeaderBlock block = new HeaderBlock(new ByteArrayInputStream(content));
+
+		assertEquals(-2, block.getPropertyStart());
+
+		// verify we can't read a short block
+		byte[] shortblock = new byte[511];
+
+		System.arraycopy(content, 0, shortblock, 0, 511);
+		try {
+			block = new HeaderBlock(new ByteArrayInputStream(shortblock));
+			fail("Should have caught IOException reading a short block");
+		} catch (IOException ignored) {
+
+			// as expected
+		}
+
+		// try various forms of corruption
+		for (int index = 0; index < 8; index++) {
+			content[index] = (byte) (content[index] - 1);
+			try {
+				block = new HeaderBlock(new ByteArrayInputStream(content));
+				fail("Should have caught IOException corrupting byte " + index);
+			} catch (IOException ignored) {
+
+				// as expected
+			}
+
+			// restore byte value
+			content[index] = (byte) (content[index] + 1);
+		}
+	}
+}
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockWriter.java b/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockWriter.java
deleted file mode 100644
index 9fe75be..0000000
--- a/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockWriter.java
+++ /dev/null
@@ -1,1025 +0,0 @@
-
-/* ====================================================================
-   Licensed to the Apache Software Foundation (ASF) under one or more
-   contributor license agreements.  See the NOTICE file distributed with
-   this work for additional information regarding copyright ownership.
-   The ASF licenses this file to You 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.
-==================================================================== */
-        
-
-package org.apache.poi.poifs.storage;
-
-import java.io.*;
-
-import java.util.*;
-
-import junit.framework.*;
-
-import org.apache.poi.util.LittleEndian;
-import org.apache.poi.util.LittleEndianConsts;
-
-/**
- * Class to test HeaderBlockWriter functionality
- *
- * @author Marc Johnson
- */
-
-public class TestHeaderBlockWriter
-    extends TestCase
-{
-
-    /**
-     * Constructor TestHeaderBlockWriter
-     *
-     * @param name
-     */
-
-    public TestHeaderBlockWriter(String name)
-    {
-        super(name);
-    }
-
-    /**
-     * Test creating a HeaderBlockWriter
-     *
-     * @exception IOException
-     */
-
-    public void testConstructors()
-        throws IOException
-    {
-        HeaderBlockWriter     block  = new HeaderBlockWriter();
-        ByteArrayOutputStream output = new ByteArrayOutputStream(512);
-
-        block.writeBlocks(output);
-        byte[] copy     = output.toByteArray();
-        byte[] expected =
-        {
-            ( byte ) 0xD0, ( byte ) 0xCF, ( byte ) 0x11, ( byte ) 0xE0,
-            ( byte ) 0xA1, ( byte ) 0xB1, ( byte ) 0x1A, ( byte ) 0xE1,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3B, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0x09, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF
-        };
-
-        assertEquals(expected.length, copy.length);
-        for (int j = 0; j < 512; j++)
-        {
-            assertEquals("testing byte " + j, expected[ j ], copy[ j ]);
-        }
-
-        // verify we can read a 'good' HeaderBlockWriter (also test
-        // getPropertyStart)
-        block.setPropertyStart(0x87654321);
-        output = new ByteArrayOutputStream(512);
-        block.writeBlocks(output);
-        assertEquals(0x87654321,
-                     new HeaderBlockReader(new ByteArrayInputStream(output
-                         .toByteArray())).getPropertyStart());
-    }
-
-    /**
-     * Test setting the SBAT start block
-     *
-     * @exception IOException
-     */
-
-    public void testSetSBATStart()
-        throws IOException
-    {
-        HeaderBlockWriter block = new HeaderBlockWriter();
-
-        block.setSBATStart(0x01234567);
-        ByteArrayOutputStream output = new ByteArrayOutputStream(512);
-
-        block.writeBlocks(output);
-        byte[] copy     = output.toByteArray();
-        byte[] expected =
-        {
-            ( byte ) 0xD0, ( byte ) 0xCF, ( byte ) 0x11, ( byte ) 0xE0,
-            ( byte ) 0xA1, ( byte ) 0xB1, ( byte ) 0x1A, ( byte ) 0xE1,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3B, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0x09, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF
-        };
-
-        assertEquals(expected.length, copy.length);
-        for (int j = 0; j < 512; j++)
-        {
-            assertEquals("testing byte " + j, expected[ j ], copy[ j ]);
-        }
-    }
-
-    /**
-     * test setPropertyStart and getPropertyStart
-     *
-     * @exception IOException
-     */
-
-    public void testSetPropertyStart()
-        throws IOException
-    {
-        HeaderBlockWriter block = new HeaderBlockWriter();
-
-        block.setPropertyStart(0x01234567);
-        ByteArrayOutputStream output = new ByteArrayOutputStream(512);
-
-        block.writeBlocks(output);
-        byte[] copy     = output.toByteArray();
-        byte[] expected =
-        {
-            ( byte ) 0xD0, ( byte ) 0xCF, ( byte ) 0x11, ( byte ) 0xE0,
-            ( byte ) 0xA1, ( byte ) 0xB1, ( byte ) 0x1A, ( byte ) 0xE1,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3B, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0x09, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF
-        };
-
-        assertEquals(expected.length, copy.length);
-        for (int j = 0; j < 512; j++)
-        {
-            assertEquals("testing byte " + j, expected[ j ], copy[ j ]);
-        }
-    }
-
-    /**
-     * test setting the BAT blocks; also tests getBATCount,
-     * getBATArray, getXBATCount
-     *
-     * @exception IOException
-     */
-
-    public void testSetBATBlocks()
-        throws IOException
-    {
-
-        // first, a small set of blocks
-        HeaderBlockWriter block = new HeaderBlockWriter();
-        BATBlock[]        xbats = block.setBATBlocks(5, 0x01234567);
-
-        assertEquals(0, xbats.length);
-        assertEquals(0, HeaderBlockWriter
-            .calculateXBATStorageRequirements(5));
-        ByteArrayOutputStream output = new ByteArrayOutputStream(512);
-
-        block.writeBlocks(output);
-        byte[] copy     = output.toByteArray();
-        byte[] expected =
-        {
-            ( byte ) 0xD0, ( byte ) 0xCF, ( byte ) 0x11, ( byte ) 0xE0,
-            ( byte ) 0xA1, ( byte ) 0xB1, ( byte ) 0x1A, ( byte ) 0xE1,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3B, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0x09, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x68, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x69, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6A, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6B, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF
-        };
-
-        assertEquals(expected.length, copy.length);
-        for (int j = 0; j < 512; j++)
-        {
-            assertEquals("testing byte " + j, expected[ j ], copy[ j ]);
-        }
-
-        // second, a full set of blocks (109 blocks)
-        block = new HeaderBlockWriter();
-        xbats = block.setBATBlocks(109, 0x01234567);
-        assertEquals(0, xbats.length);
-        assertEquals(0, HeaderBlockWriter
-            .calculateXBATStorageRequirements(109));
-        output = new ByteArrayOutputStream(512);
-        block.writeBlocks(output);
-        copy = output.toByteArray();
-        byte[] expected2 =
-        {
-            ( byte ) 0xD0, ( byte ) 0xCF, ( byte ) 0x11, ( byte ) 0xE0,
-            ( byte ) 0xA1, ( byte ) 0xB1, ( byte ) 0x1A, ( byte ) 0xE1,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3B, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0x09, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x68, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x69, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6A, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6B, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6C, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6D, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6E, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6F, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x70, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x71, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x72, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x73, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x74, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x75, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x76, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x77, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x78, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x79, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7A, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7B, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7C, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7D, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7E, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7F, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x80, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x81, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x82, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x83, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x84, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x85, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x86, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x87, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x88, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x89, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8A, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8B, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8C, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8D, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8E, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8F, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x90, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x91, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x92, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x93, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x94, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x95, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x96, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x97, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x98, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x99, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9A, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9B, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9C, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9D, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9E, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9F, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA0, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA1, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA2, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA3, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA4, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA5, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA6, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA7, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA8, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA9, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAA, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAB, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAC, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAD, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAE, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAF, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB0, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB1, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB2, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB3, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB4, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB5, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB6, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB7, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB8, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB9, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBA, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBB, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBC, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBD, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBE, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBF, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC0, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC1, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC2, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC3, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC4, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC5, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC6, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC7, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC8, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC9, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCA, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCB, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCC, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCD, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCE, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCF, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xD0, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xD1, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xD2, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xD3, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01
-        };
-
-        assertEquals(expected2.length, copy.length);
-        for (int j = 0; j < 512; j++)
-        {
-            assertEquals("testing byte " + j, expected2[ j ], copy[ j ]);
-        }
-
-        // finally, a really large set of blocks (256 blocks)
-        block = new HeaderBlockWriter();
-        xbats = block.setBATBlocks(256, 0x01234567);
-        assertEquals(2, xbats.length);
-        assertEquals(2, HeaderBlockWriter
-            .calculateXBATStorageRequirements(256));
-        output = new ByteArrayOutputStream(512);
-        block.writeBlocks(output);
-        copy = output.toByteArray();
-        byte[] expected3 =
-        {
-            ( byte ) 0xD0, ( byte ) 0xCF, ( byte ) 0x11, ( byte ) 0xE0,
-            ( byte ) 0xA1, ( byte ) 0xB1, ( byte ) 0x1A, ( byte ) 0xE1,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3B, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0x09, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x46, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x68, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x69, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6A, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6B, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6C, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6D, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6E, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x6F, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x70, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x71, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x72, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x73, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x74, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x75, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x76, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x77, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x78, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x79, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7A, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7B, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7C, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7D, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7E, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x7F, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x80, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x81, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x82, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x83, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x84, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x85, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x86, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x87, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x88, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x89, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8A, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8B, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8C, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8D, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8E, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x8F, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x90, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x91, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x92, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x93, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x94, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x95, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x96, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x97, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x98, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x99, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9A, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9B, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9C, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9D, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9E, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0x9F, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA0, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA1, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA2, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA3, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA4, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA5, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA6, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA7, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA8, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xA9, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAA, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAB, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAC, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAD, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAE, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xAF, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB0, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB1, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB2, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB3, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB4, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB5, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB6, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB7, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB8, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xB9, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBA, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBB, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBC, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBD, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBE, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xBF, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC0, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC1, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC2, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC3, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC4, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC5, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC6, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC7, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC8, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xC9, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCA, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCB, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCC, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCD, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCE, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xCF, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xD0, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xD1, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xD2, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01,
-            ( byte ) 0xD3, ( byte ) 0x45, ( byte ) 0x23, ( byte ) 0x01
-        };
-
-        assertEquals(expected3.length, copy.length);
-        for (int j = 0; j < 512; j++)
-        {
-            assertEquals("testing byte " + j, expected3[ j ], copy[ j ]);
-        }
-        output = new ByteArrayOutputStream(1028);
-        xbats[ 0 ].writeBlocks(output);
-        xbats[ 1 ].writeBlocks(output);
-        copy = output.toByteArray();
-        int correct = 0x012345D4;
-        int offset  = 0;
-        int k       = 0;
-
-        for (; k < 127; k++)
-        {
-            assertEquals("XBAT entry " + k, correct,
-                         LittleEndian.getInt(copy, offset));
-            correct++;
-            offset += LittleEndianConsts.INT_SIZE;
-        }
-        assertEquals("XBAT Chain", 0x01234567 + 257,
-                     LittleEndian.getInt(copy, offset));
-        offset += LittleEndianConsts.INT_SIZE;
-        k++;
-        for (; k < 148; k++)
-        {
-            assertEquals("XBAT entry " + k, correct,
-                         LittleEndian.getInt(copy, offset));
-            correct++;
-            offset += LittleEndianConsts.INT_SIZE;
-        }
-        for (; k < 255; k++)
-        {
-            assertEquals("XBAT entry " + k, -1,
-                         LittleEndian.getInt(copy, offset));
-            offset += LittleEndianConsts.INT_SIZE;
-        }
-        assertEquals("XBAT End of chain", -2,
-                     LittleEndian.getInt(copy, offset));
-    }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.storage.HeaderBlockWriter");
-        junit.textui.TestRunner.run(TestHeaderBlockWriter.class);
-    }
-}
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockWriting.java b/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockWriting.java
new file mode 100644
index 0000000..e01c788
--- /dev/null
+++ b/src/testcases/org/apache/poi/poifs/storage/TestHeaderBlockWriting.java
@@ -0,0 +1,270 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.poifs.storage;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import junit.framework.TestCase;
+
+import org.apache.poi.poifs.common.POIFSConstants;
+import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
+
+/**
+ * Class to test HeaderBlockWriter functionality
+ *
+ * @author Marc Johnson
+ */
+public final class TestHeaderBlockWriting extends TestCase {
+
+	private static void confirmEqual(String[] expectedDataHexDumpLines, byte[] actual) {
+		byte[] expected = RawDataUtil.decode(expectedDataHexDumpLines);
+
+		assertEquals(expected.length, actual.length);
+		for (int j = 0; j < expected.length; j++) {
+			assertEquals("testing byte " + j, expected[j], actual[j]);
+		}
+	}
+
+	/**
+	 * Test creating a HeaderBlockWriter
+	 */
+	public void testConstructors() throws IOException {
+		HeaderBlockWriter block = new HeaderBlockWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+		ByteArrayOutputStream output = new ByteArrayOutputStream(512);
+
+		block.writeBlocks(output);
+		byte[] copy = output.toByteArray();
+		String[] expected = {
+			"D0 CF 11 E0 A1 B1 1A E1 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3B 00 03 00 FE FF 09 00",
+			"06 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 10 00 00 FE FF FF FF",
+			"00 00 00 00 FE FF FF FF 00 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+		};
+
+		confirmEqual(expected, copy);
+
+		// verify we can read a 'good' HeaderBlockWriter (also test
+		// getPropertyStart)
+		block.setPropertyStart(0x87654321);
+		output = new ByteArrayOutputStream(512);
+		block.writeBlocks(output);
+		assertEquals(0x87654321, new HeaderBlock(
+		      new ByteArrayInputStream(output.toByteArray())).getPropertyStart());
+	}
+
+	/**
+	 * Test setting the SBAT start block
+	 */
+	public void testSetSBATStart() throws IOException {
+	   HeaderBlockWriter block = new HeaderBlockWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+
+		block.setSBATStart(0x01234567);
+		ByteArrayOutputStream output = new ByteArrayOutputStream(512);
+
+		block.writeBlocks(output);
+		byte[] copy = output.toByteArray();
+		String[] expected = {
+			"D0 CF 11 E0 A1 B1 1A E1 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3B 00 03 00 FE FF 09 00",
+			"06 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FE FF FF FF 00 00 00 00 00 10 00 00 67 45 23 01",
+			"00 00 00 00 FE FF FF FF 00 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+		};
+		confirmEqual(expected, copy);
+	}
+
+	/**
+	 * test setPropertyStart and getPropertyStart
+	 */
+	public void testSetPropertyStart() throws IOException {
+	   HeaderBlockWriter block = new HeaderBlockWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+
+		block.setPropertyStart(0x01234567);
+		ByteArrayOutputStream output = new ByteArrayOutputStream(512);
+
+		block.writeBlocks(output);
+		byte[] copy = output.toByteArray();
+		String[] expected = {
+			"D0 CF 11 E0 A1 B1 1A E1 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3B 00 03 00 FE FF 09 00",
+			"06 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 67 45 23 01 00 00 00 00 00 10 00 00 FE FF FF FF",
+			"00 00 00 00 FE FF FF FF 00 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+		};
+		confirmEqual(expected, copy);
+	}
+
+	/**
+	 * test setting the BAT blocks; also tests getBATCount, getBATArray,
+	 * getXBATCount
+	 */
+	public void testSetBATBlocks() throws IOException {
+
+		// first, a small set of blocks
+	   HeaderBlockWriter block = new HeaderBlockWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+		BATBlock[] xbats = block.setBATBlocks(5, 0x01234567);
+
+		assertEquals(0, xbats.length);
+		assertEquals(0, HeaderBlockWriter.calculateXBATStorageRequirements(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,5));
+		ByteArrayOutputStream output = new ByteArrayOutputStream(512);
+
+		block.writeBlocks(output);
+		byte[] copy = output.toByteArray();
+		String[] expected = {
+			"D0 CF 11 E0 A1 B1 1A E1 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3B 00 03 00 FE FF 09 00",
+			"06 00 00 00 00 00 00 00 00 00 00 00 05 00 00 00 FE FF FF FF 00 00 00 00 00 10 00 00 FE FF FF FF",
+			"00 00 00 00 FE FF FF FF 00 00 00 00 67 45 23 01 68 45 23 01 69 45 23 01 6A 45 23 01 6B 45 23 01",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+		};
+
+		confirmEqual(expected, copy);
+
+		// second, a full set of blocks (109 blocks)
+		block = new HeaderBlockWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+		xbats = block.setBATBlocks(109, 0x01234567);
+		assertEquals(0, xbats.length);
+		assertEquals(0, HeaderBlockWriter.calculateXBATStorageRequirements(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,109));
+		output = new ByteArrayOutputStream(512);
+		block.writeBlocks(output);
+		copy = output.toByteArray();
+		String[] expected2 = {
+			"D0 CF 11 E0 A1 B1 1A E1 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3B 00 03 00 FE FF 09 00",
+			"06 00 00 00 00 00 00 00 00 00 00 00 6D 00 00 00 FE FF FF FF 00 00 00 00 00 10 00 00 FE FF FF FF",
+			"00 00 00 00 FE FF FF FF 00 00 00 00 67 45 23 01 68 45 23 01 69 45 23 01 6A 45 23 01 6B 45 23 01",
+			"6C 45 23 01 6D 45 23 01 6E 45 23 01 6F 45 23 01 70 45 23 01 71 45 23 01 72 45 23 01 73 45 23 01",
+			"74 45 23 01 75 45 23 01 76 45 23 01 77 45 23 01 78 45 23 01 79 45 23 01 7A 45 23 01 7B 45 23 01",
+			"7C 45 23 01 7D 45 23 01 7E 45 23 01 7F 45 23 01 80 45 23 01 81 45 23 01 82 45 23 01 83 45 23 01",
+			"84 45 23 01 85 45 23 01 86 45 23 01 87 45 23 01 88 45 23 01 89 45 23 01 8A 45 23 01 8B 45 23 01",
+			"8C 45 23 01 8D 45 23 01 8E 45 23 01 8F 45 23 01 90 45 23 01 91 45 23 01 92 45 23 01 93 45 23 01",
+			"94 45 23 01 95 45 23 01 96 45 23 01 97 45 23 01 98 45 23 01 99 45 23 01 9A 45 23 01 9B 45 23 01",
+			"9C 45 23 01 9D 45 23 01 9E 45 23 01 9F 45 23 01 A0 45 23 01 A1 45 23 01 A2 45 23 01 A3 45 23 01",
+			"A4 45 23 01 A5 45 23 01 A6 45 23 01 A7 45 23 01 A8 45 23 01 A9 45 23 01 AA 45 23 01 AB 45 23 01",
+			"AC 45 23 01 AD 45 23 01 AE 45 23 01 AF 45 23 01 B0 45 23 01 B1 45 23 01 B2 45 23 01 B3 45 23 01",
+			"B4 45 23 01 B5 45 23 01 B6 45 23 01 B7 45 23 01 B8 45 23 01 B9 45 23 01 BA 45 23 01 BB 45 23 01",
+			"BC 45 23 01 BD 45 23 01 BE 45 23 01 BF 45 23 01 C0 45 23 01 C1 45 23 01 C2 45 23 01 C3 45 23 01",
+			"C4 45 23 01 C5 45 23 01 C6 45 23 01 C7 45 23 01 C8 45 23 01 C9 45 23 01 CA 45 23 01 CB 45 23 01",
+			"CC 45 23 01 CD 45 23 01 CE 45 23 01 CF 45 23 01 D0 45 23 01 D1 45 23 01 D2 45 23 01 D3 45 23 01",
+		};
+		confirmEqual(expected2, copy);
+
+		// finally, a really large set of blocks (256 blocks)
+		block = new HeaderBlockWriter(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+		xbats = block.setBATBlocks(256, 0x01234567);
+		assertEquals(2, xbats.length);
+		assertEquals(2, HeaderBlockWriter.calculateXBATStorageRequirements(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,256));
+		output = new ByteArrayOutputStream(512);
+		block.writeBlocks(output);
+		copy = output.toByteArray();
+		String[] expected3 = {
+			"D0 CF 11 E0 A1 B1 1A E1 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3B 00 03 00 FE FF 09 00",
+			"06 00 00 00 00 00 00 00 00 00 00 00 00 01 00 00 FE FF FF FF 00 00 00 00 00 10 00 00 FE FF FF FF",
+			"00 00 00 00 67 46 23 01 02 00 00 00 67 45 23 01 68 45 23 01 69 45 23 01 6A 45 23 01 6B 45 23 01",
+			"6C 45 23 01 6D 45 23 01 6E 45 23 01 6F 45 23 01 70 45 23 01 71 45 23 01 72 45 23 01 73 45 23 01",
+			"74 45 23 01 75 45 23 01 76 45 23 01 77 45 23 01 78 45 23 01 79 45 23 01 7A 45 23 01 7B 45 23 01",
+			"7C 45 23 01 7D 45 23 01 7E 45 23 01 7F 45 23 01 80 45 23 01 81 45 23 01 82 45 23 01 83 45 23 01",
+			"84 45 23 01 85 45 23 01 86 45 23 01 87 45 23 01 88 45 23 01 89 45 23 01 8A 45 23 01 8B 45 23 01",
+			"8C 45 23 01 8D 45 23 01 8E 45 23 01 8F 45 23 01 90 45 23 01 91 45 23 01 92 45 23 01 93 45 23 01",
+			"94 45 23 01 95 45 23 01 96 45 23 01 97 45 23 01 98 45 23 01 99 45 23 01 9A 45 23 01 9B 45 23 01",
+			"9C 45 23 01 9D 45 23 01 9E 45 23 01 9F 45 23 01 A0 45 23 01 A1 45 23 01 A2 45 23 01 A3 45 23 01",
+			"A4 45 23 01 A5 45 23 01 A6 45 23 01 A7 45 23 01 A8 45 23 01 A9 45 23 01 AA 45 23 01 AB 45 23 01",
+			"AC 45 23 01 AD 45 23 01 AE 45 23 01 AF 45 23 01 B0 45 23 01 B1 45 23 01 B2 45 23 01 B3 45 23 01",
+			"B4 45 23 01 B5 45 23 01 B6 45 23 01 B7 45 23 01 B8 45 23 01 B9 45 23 01 BA 45 23 01 BB 45 23 01",
+			"BC 45 23 01 BD 45 23 01 BE 45 23 01 BF 45 23 01 C0 45 23 01 C1 45 23 01 C2 45 23 01 C3 45 23 01",
+			"C4 45 23 01 C5 45 23 01 C6 45 23 01 C7 45 23 01 C8 45 23 01 C9 45 23 01 CA 45 23 01 CB 45 23 01",
+			"CC 45 23 01 CD 45 23 01 CE 45 23 01 CF 45 23 01 D0 45 23 01 D1 45 23 01 D2 45 23 01 D3 45 23 01",
+		};
+
+		confirmEqual(expected3, copy);
+
+		output = new ByteArrayOutputStream(1028);
+		xbats[0].writeBlocks(output);
+		xbats[1].writeBlocks(output);
+		copy = output.toByteArray();
+		int correct = 0x012345D4;
+		int offset = 0;
+		int k = 0;
+
+		for (; k < 127; k++) {
+			assertEquals("XBAT entry " + k, correct, LittleEndian.getInt(copy, offset));
+			correct++;
+			offset += LittleEndianConsts.INT_SIZE;
+		}
+		assertEquals("XBAT Chain", 0x01234567 + 257, LittleEndian.getInt(copy, offset));
+		offset += LittleEndianConsts.INT_SIZE;
+		k++;
+		for (; k < 148; k++) {
+			assertEquals("XBAT entry " + k, correct, LittleEndian.getInt(copy, offset));
+			correct++;
+			offset += LittleEndianConsts.INT_SIZE;
+		}
+		for (; k < 255; k++) {
+			assertEquals("XBAT entry " + k, -1, LittleEndian.getInt(copy, offset));
+			offset += LittleEndianConsts.INT_SIZE;
+		}
+		assertEquals("XBAT End of chain", -2, LittleEndian.getInt(copy, offset));
+	}
+}
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestPropertyBlock.java b/src/testcases/org/apache/poi/poifs/storage/TestPropertyBlock.java
index 64750b1..0cf8398 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestPropertyBlock.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestPropertyBlock.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,59 +14,37 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 
-import java.util.*;
+import org.apache.poi.poifs.common.POIFSConstants;
 
-import junit.framework.*;
-
-import org.apache.poi.poifs.property.Property;
+import junit.framework.TestCase;
 
 /**
  * Class to test PropertyBlock functionality
  *
  * @author Marc Johnson
  */
+public final class TestPropertyBlock extends TestCase {
 
-public class TestPropertyBlock
-    extends TestCase
-{
-
-    /**
-     * Constructor TestPropertyBlock
-     *
-     * @param name
-     */
-
-    public TestPropertyBlock(String name)
-    {
-        super(name);
-    }
-
-    /**
-     * Test constructing PropertyBlocks
-     *
-     * @exception IOException
-     */
-
-    public void testCreatePropertyBlocks()
-        throws IOException
-    {
+    public void testCreatePropertyBlocks() {
 
         // test with 0 properties
         List            properties = new ArrayList();
         BlockWritable[] blocks     =
-            PropertyBlock.createPropertyBlockArray(properties);
+            PropertyBlock.createPropertyBlockArray(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,properties);
 
         assertEquals(0, blocks.length);
 
         // test with 1 property
         properties.add(new LocalProperty("Root Entry"));
-        blocks = PropertyBlock.createPropertyBlockArray(properties);
+        blocks = PropertyBlock.createPropertyBlockArray(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,properties);
         assertEquals(1, blocks.length);
         byte[] testblock = new byte[ 512 ];
 
@@ -91,7 +68,7 @@
         // test with 3 properties
         properties.add(new LocalProperty("workbook"));
         properties.add(new LocalProperty("summary"));
-        blocks = PropertyBlock.createPropertyBlockArray(properties);
+        blocks = PropertyBlock.createPropertyBlockArray(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,properties);
         assertEquals(1, blocks.length);
         testblock[ 0x0080 ] = ( byte ) 'w';
         testblock[ 0x0082 ] = ( byte ) 'o';
@@ -114,7 +91,7 @@
 
         // test with 4 properties
         properties.add(new LocalProperty("wintery"));
-        blocks = PropertyBlock.createPropertyBlockArray(properties);
+        blocks = PropertyBlock.createPropertyBlockArray(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,properties);
         assertEquals(1, blocks.length);
         testblock[ 0x0180 ] = ( byte ) 'w';
         testblock[ 0x0182 ] = ( byte ) 'i';
@@ -128,7 +105,7 @@
 
         // test with 5 properties
         properties.add(new LocalProperty("foo"));
-        blocks = PropertyBlock.createPropertyBlockArray(properties);
+        blocks = PropertyBlock.createPropertyBlockArray(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,properties);
         assertEquals(2, blocks.length);
         testblock = new byte[ 1024 ];
         for (int j = 0; j < 8; j++)
@@ -178,7 +155,7 @@
         verifyCorrect(blocks, testblock);
     }
 
-    private void setDefaultBlock(byte [] testblock, int j)
+    private static void setDefaultBlock(byte [] testblock, int j)
     {
         int base  = j * 128;
         int index = 0;
@@ -204,15 +181,16 @@
         }
     }
 
-    private void verifyCorrect(BlockWritable [] blocks, byte [] testblock)
-        throws IOException
-    {
+    private static void verifyCorrect(BlockWritable[] blocks, byte[] testblock) {
         ByteArrayOutputStream stream = new ByteArrayOutputStream(512
                                            * blocks.length);
 
-        for (int j = 0; j < blocks.length; j++)
-        {
-            blocks[ j ].writeBlocks(stream);
+        for (int j = 0; j < blocks.length; j++) {
+            try {
+				blocks[ j ].writeBlocks(stream);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
         }
         byte[] output = stream.toByteArray();
 
@@ -223,17 +201,4 @@
                          output[ j ]);
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.storage.PropertyBlock");
-        junit.textui.TestRunner.run(TestPropertyBlock.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestRawDataBlock.java b/src/testcases/org/apache/poi/poifs/storage/TestRawDataBlock.java
index a4cdb73..5b632ce 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestRawDataBlock.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestRawDataBlock.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,233 +14,212 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
 import java.util.Random;
 
-import org.apache.poi.util.DummyPOILogger;
-import org.apache.poi.util.POILogFactory;
+import junit.framework.TestCase;
 
-import junit.framework.*;
+import org.apache.poi.util.DummyPOILogger;
 
 /**
  * Class to test RawDataBlock functionality
  *
  * @author Marc Johnson
  */
-
-public class TestRawDataBlock
-    extends TestCase
-{
+public final class TestRawDataBlock extends TestCase {
 	static {
-        // We always want to use our own
-        //  logger
-        System.setProperty(
-        		"org.apache.poi.util.POILogger",
-        		"org.apache.poi.util.DummyPOILogger"
-        );
+		// We always want to use our own
+		//  logger
+		System.setProperty(
+				"org.apache.poi.util.POILogger",
+				"org.apache.poi.util.DummyPOILogger"
+		);
 	}
 
-    /**
-     * Constructor TestRawDataBlock
-     *
-     * @param name
-     */
-    public TestRawDataBlock(String name)
-    {
-        super(name);
-    }
+	/**
+	 * Test creating a normal RawDataBlock
+	 */
+	public void testNormalConstructor() throws IOException {
+		byte[] data = new byte[ 512 ];
 
-    /**
-     * Test creating a normal RawDataBlock
-     *
-     * @exception IOException
-     */
+		for (int j = 0; j < 512; j++)
+		{
+			data[ j ] = ( byte ) j;
+		}
+		RawDataBlock block = new RawDataBlock(new ByteArrayInputStream(data));
 
-    public void testNormalConstructor()
-        throws IOException
-    {
-        byte[] data = new byte[ 512 ];
+		assertTrue("Should not be at EOF", !block.eof());
+		byte[] out_data = block.getData();
 
-        for (int j = 0; j < 512; j++)
-        {
-            data[ j ] = ( byte ) j;
-        }
-        RawDataBlock block = new RawDataBlock(new ByteArrayInputStream(data));
+		assertEquals("Should be same length", data.length, out_data.length);
+		for (int j = 0; j < 512; j++)
+		{
+			assertEquals("Should be same value at offset " + j, data[ j ],
+						 out_data[ j ]);
+		}
+	}
 
-        assertTrue("Should not be at EOF", !block.eof());
-        byte[] out_data = block.getData();
+	/**
+	 * Test creating an empty RawDataBlock
+	 */
+	public void testEmptyConstructor() throws IOException {
+		byte[]	   data  = new byte[ 0 ];
+		RawDataBlock block = new RawDataBlock(new ByteArrayInputStream(data));
 
-        assertEquals("Should be same length", data.length, out_data.length);
-        for (int j = 0; j < 512; j++)
-        {
-            assertEquals("Should be same value at offset " + j, data[ j ],
-                         out_data[ j ]);
-        }
-    }
+		assertTrue("Should be at EOF", block.eof());
+		try
+		{
+			block.getData();
+		}
+		catch (IOException ignored)
+		{
 
-    /**
-     * Test creating an empty RawDataBlock
-     *
-     * @exception IOException
-     */
+			// as expected
+		}
+	}
 
-    public void testEmptyConstructor()
-        throws IOException
-    {
-        byte[]       data  = new byte[ 0 ];
-        RawDataBlock block = new RawDataBlock(new ByteArrayInputStream(data));
+	/**
+	 * Test creating a short RawDataBlock
+	 * Will trigger a warning, but no longer an IOException,
+	 *  as people seem to have "valid" truncated files
+	 */
+	public void testShortConstructor() throws Exception {
+		// Get the logger to be used
+		DummyPOILogger logger = new DummyPOILogger();
+		Field fld = RawDataBlock.class.getDeclaredField("log");
+		fld.setAccessible(true);
+		fld.set(null, logger);
+		assertEquals(0, logger.logged.size());
 
-        assertTrue("Should be at EOF", block.eof());
-        try
-        {
-            block.getData();
-        }
-        catch (IOException ignored)
-        {
+		// Test for various data sizes
+		for (int k = 1; k <= 512; k++)
+		{
+			byte[] data = new byte[ k ];
 
-            // as expected
-        }
-    }
+			for (int j = 0; j < k; j++)
+			{
+				data[ j ] = ( byte ) j;
+			}
+			RawDataBlock block = null;
 
-    /**
-     * Test creating a short RawDataBlock
-     * Will trigger a warning, but no longer an IOException,
-     *  as people seem to have "valid" truncated files
-     */
-    public void testShortConstructor() throws Exception
-    {
-        // Get the logger to be used
-        DummyPOILogger logger = (DummyPOILogger)POILogFactory.getLogger(
-        		RawDataBlock.class
-        );
-        assertEquals(0, logger.logged.size());
-        
-        // Test for various data sizes
-        for (int k = 1; k <= 512; k++)
-        {
-            byte[] data = new byte[ k ];
+			logger.reset();
+			assertEquals(0, logger.logged.size());
 
-            for (int j = 0; j < k; j++)
-            {
-                data[ j ] = ( byte ) j;
-            }
-            RawDataBlock block = null;
-            
-            logger.reset();
-            assertEquals(0, logger.logged.size());
-            
-            // Have it created
-            block = new RawDataBlock(new ByteArrayInputStream(data));
-            assertNotNull(block);
-            
-            // Check for the warning is there for <512
-            if(k < 512) {
-	            assertEquals(
-	            		"Warning on " + k + " byte short block",
-	            		1, logger.logged.size()
-	            );
-	
-	            // Build the expected warning message, and check
-	            String bts = k + " byte";
-	            if(k > 1) {
-	            	bts += "s";
-	            }
-	            
-	            assertEquals(
-	            		"7 - Unable to read entire block; "+bts+" read before EOF; expected 512 bytes. Your document was either written by software that ignores the spec, or has been truncated!", 
-	            		(String)(logger.logged.get(0))
-	            );
-            } else {
-            	assertEquals(0, logger.logged.size());
-            }
-        }
-    }
-    
-    /**
-     * Tests that when using a slow input stream, which
-     *  won't return a full block at a time, we don't
-     *  incorrectly think that there's not enough data
-     */
-    public void testSlowInputStream() throws Exception {
-        // Get the logger to be used
-        DummyPOILogger logger = (DummyPOILogger)POILogFactory.getLogger(
-        		RawDataBlock.class
-        );
-        assertEquals(0, logger.logged.size());
-        
-        // Test for various ok data sizes
-        for (int k = 1; k < 512; k++) {
-            byte[] data = new byte[ 512 ];
-            for (int j = 0; j < data.length; j++) {
-                data[j] = (byte) j;
-            }
-            
-            // Shouldn't complain, as there is enough data,
-            //  even if it dribbles through
-            RawDataBlock block = 
-            	new RawDataBlock(new SlowInputStream(data, k));
-            assertFalse(block.eof());
-        }
-        
-        // But if there wasn't enough data available, will
-        //  complain
-        for (int k = 1; k < 512; k++) {
-            byte[] data = new byte[ 511 ];
-            for (int j = 0; j < data.length; j++) {
-                data[j] = (byte) j;
-            }
-            
-            logger.reset();
-            assertEquals(0, logger.logged.size());
-            
-            // Should complain, as there isn't enough data
-            RawDataBlock block = 
-            	new RawDataBlock(new SlowInputStream(data, k));
-            assertNotNull(block);
-            assertEquals(
-            		"Warning on " + k + " byte short block",
-            		1, logger.logged.size()
-            );
-        }
-    }
-    
-    /**
-     * An input stream which will return a maximum of
-     *  a given number of bytes to read, and often claims
-     *  not to have any data
-     */
-    public static class SlowInputStream extends InputStream {
-    	private Random rnd = new Random();
-    	private byte[] data;
-    	private int chunkSize;
-    	private int pos = 0;
-    	
-    	public SlowInputStream(byte[] data, int chunkSize) {
-    		this.chunkSize = chunkSize;
-    		this.data = data;
-    	}
-    	
-    	/**
-    	 * 75% of the time, claim there's no data available
-    	 */
-    	private boolean claimNoData() {
-    		if(rnd.nextFloat() < 0.25f) {
-    			return false;
-    		}
-    		return true;
-    	}
-    	
-		public int read() throws IOException {
+			// Have it created
+			block = new RawDataBlock(new ByteArrayInputStream(data));
+			assertNotNull(block);
+
+			// Check for the warning is there for <512
+			if(k < 512) {
+				assertEquals(
+						"Warning on " + k + " byte short block",
+						1, logger.logged.size()
+				);
+
+				// Build the expected warning message, and check
+				String bts = k + " byte";
+				if(k > 1) {
+					bts += "s";
+				}
+
+				assertEquals(
+						"7 - Unable to read entire block; "+bts+" read before EOF; expected 512 bytes. Your document was either written by software that ignores the spec, or has been truncated!",
+						(String)(logger.logged.get(0))
+				);
+			} else {
+				assertEquals(0, logger.logged.size());
+			}
+		}
+	}
+
+	/**
+	 * Tests that when using a slow input stream, which
+	 *  won't return a full block at a time, we don't
+	 *  incorrectly think that there's not enough data
+	 */
+	public void testSlowInputStream() throws Exception {
+		// Get the logger to be used
+		DummyPOILogger logger = new DummyPOILogger();
+		Field fld = RawDataBlock.class.getDeclaredField("log");
+		fld.setAccessible(true);
+		fld.set(null, logger);
+		assertEquals(0, logger.logged.size());
+
+		// Test for various ok data sizes
+		for (int k = 1; k < 512; k++) {
+			byte[] data = new byte[ 512 ];
+			for (int j = 0; j < data.length; j++) {
+				data[j] = (byte) j;
+			}
+
+			// Shouldn't complain, as there is enough data,
+			//  even if it dribbles through
+			RawDataBlock block =
+				new RawDataBlock(new SlowInputStream(data, k));
+			assertFalse(block.eof());
+		}
+
+		// But if there wasn't enough data available, will
+		//  complain
+		for (int k = 1; k < 512; k++) {
+			byte[] data = new byte[ 511 ];
+			for (int j = 0; j < data.length; j++) {
+				data[j] = (byte) j;
+			}
+
+			logger.reset();
+			assertEquals(0, logger.logged.size());
+
+			// Should complain, as there isn't enough data
+			RawDataBlock block =
+				new RawDataBlock(new SlowInputStream(data, k));
+			assertNotNull(block);
+			assertEquals(
+					"Warning on " + k + " byte short block",
+					1, logger.logged.size()
+			);
+		}
+	}
+
+	/**
+	 * An input stream which will return a maximum of
+	 *  a given number of bytes to read, and often claims
+	 *  not to have any data
+	 */
+	public static class SlowInputStream extends InputStream {
+		private Random rnd = new Random();
+		private byte[] data;
+		private int chunkSize;
+		private int pos = 0;
+
+		public SlowInputStream(byte[] data, int chunkSize) {
+			this.chunkSize = chunkSize;
+			this.data = data;
+		}
+
+		/**
+		 * 75% of the time, claim there's no data available
+		 */
+		private boolean claimNoData() {
+			if(rnd.nextFloat() < 0.25f) {
+				return false;
+			}
+			return true;
+		}
+
+		public int read() {
 			if(pos >= data.length) {
 				return -1;
 			}
 			int ret = data[pos];
 			pos++;
-			
+
 			if(ret < 0) ret += 256;
 			return ret;
 		}
@@ -251,7 +229,7 @@
 		 *  size, whichever is lower.
 		 * Quite often will simply claim to have no data
 		 */
-		public int read(byte[] b, int off, int len) throws IOException {
+		public int read(byte[] b, int off, int len) {
 			// Keep the length within the chunk size
 			if(len > chunkSize) {
 				len = chunkSize;
@@ -259,40 +237,26 @@
 			// Don't read off the end of the data
 			if(pos + len > data.length) {
 				len = data.length - pos;
-				
+
 				// Spot when we're out of data
 				if(len == 0) {
 					return -1;
 				}
 			}
-			
+
 			// 75% of the time, claim there's no data
 			if(claimNoData()) {
 				return 0;
 			}
-			
+
 			// Copy, and return what we read
 			System.arraycopy(data, pos, b, off, len);
 			pos += len;
 			return len;
 		}
 
-		public int read(byte[] b) throws IOException {
+		public int read(byte[] b) {
 			return read(b, 0, b.length);
 		}
-		
-    }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.storage.RawDataBlock");
-        junit.textui.TestRunner.run(TestRawDataBlock.class);
-    }
+	}
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestRawDataBlockList.java b/src/testcases/org/apache/poi/poifs/storage/TestRawDataBlockList.java
index 0f65c0e..6dabfc0 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestRawDataBlockList.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestRawDataBlockList.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,27 +14,24 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.lang.reflect.Field;
+
+import junit.framework.TestCase;
 
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.util.DummyPOILogger;
-import org.apache.poi.util.POILogFactory;
-
-import junit.framework.*;
 
 /**
  * Class to test RawDataBlockList functionality
  *
  * @author Marc Johnson
  */
-
-public class TestRawDataBlockList
-    extends TestCase
-{
+public final class TestRawDataBlockList extends TestCase {
 	static {
         // We always want to use our own
         //  logger
@@ -46,56 +42,36 @@
 	}
 
     /**
-     * Constructor TestRawDataBlockList
-     *
-     * @param name
-     */
-    public TestRawDataBlockList(String name)
-    {
-        super(name);
-    }
-
-    /**
      * Test creating a normal RawDataBlockList
-     *
-     * @exception IOException
      */
-    public void testNormalConstructor()
-        throws IOException
-    {
+    public void testNormalConstructor() throws IOException {
         byte[] data = new byte[ 2560 ];
 
         for (int j = 0; j < 2560; j++)
         {
             data[ j ] = ( byte ) j;
         }
-        new RawDataBlockList(new ByteArrayInputStream(data), POIFSConstants.BIG_BLOCK_SIZE);
+        new RawDataBlockList(new ByteArrayInputStream(data), POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
     }
 
     /**
      * Test creating an empty RawDataBlockList
-     *
-     * @exception IOException
      */
-
-    public void testEmptyConstructor()
-        throws IOException
-    {
-        new RawDataBlockList(new ByteArrayInputStream(new byte[ 0 ]), POIFSConstants.BIG_BLOCK_SIZE);
+    public void testEmptyConstructor() throws IOException {
+        new RawDataBlockList(new ByteArrayInputStream(new byte[ 0 ]), POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
     }
 
     /**
      * Test creating a short RawDataBlockList
      */
-
-    public void testShortConstructor() throws Exception
-    {
+    public void testShortConstructor() throws Exception {
         // Get the logger to be used
-        DummyPOILogger logger = (DummyPOILogger)POILogFactory.getLogger(
-        		RawDataBlock.class
-        );
+        DummyPOILogger logger = new DummyPOILogger();
+        Field fld = RawDataBlock.class.getDeclaredField("log");
+        fld.setAccessible(true);
+        fld.set(null, logger);
         assertEquals(0, logger.logged.size());
-        
+
         // Test for various short sizes
         for (int k = 2049; k < 2560; k++)
         {
@@ -108,21 +84,8 @@
 
             // Check we logged the error
             logger.reset();
-            new RawDataBlockList(new ByteArrayInputStream(data), POIFSConstants.BIG_BLOCK_SIZE);
+            new RawDataBlockList(new ByteArrayInputStream(data), POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
             assertEquals(1, logger.logged.size());
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out
-            .println("Testing org.apache.poi.poifs.storage.RawDataBlockList");
-        junit.textui.TestRunner.run(TestRawDataBlockList.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestSmallBlockTableReader.java b/src/testcases/org/apache/poi/poifs/storage/TestSmallBlockTableReader.java
index 4d4254a..ee8ac39 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestSmallBlockTableReader.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestSmallBlockTableReader.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,15 +14,13 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
 
-import java.util.*;
-
-import junit.framework.*;
+import junit.framework.TestCase;
 
 import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.poifs.property.PropertyTable;
@@ -34,2113 +31,287 @@
  *
  * @author Marc Johnson
  */
+public final class TestSmallBlockTableReader extends TestCase {
 
-public class TestSmallBlockTableReader
-    extends TestCase
-{
+	public void testReadingConstructor() throws IOException {
 
-    /**
-     * Constructor TestSmallBlockTableReader
-     *
-     * @param name
-     */
+		// first, we need the raw data blocks
+		String[] raw_data_array = {
+			"52 00 6F 00 6F 00 74 00 20 00 45 00 6E 00 74 00 72 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"16 00 05 01 FF FF FF FF FF FF FF FF 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0A 00 00 00 80 07 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 01 01 FF FF FF FF FF FF FF FF 15 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"46 00 55 00 44 00 20 00 47 00 72 00 69 00 64 00 20 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00",
+			"74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2A 00 02 01 FF FF FF FF 0E 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"44 00 6F 00 75 00 62 00 6C 00 65 00 20 00 44 00 65 00 61 00 6C 00 69 00 6E 00 67 00 20 00 49 00",
+			"6E 00 64 00 69 00 63 00 61 00 74 00 6F 00 72 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"32 00 02 01 FF FF FF FF 09 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00",
+			"43 00 68 00 69 00 6C 00 64 00 20 00 50 00 65 00 72 00 63 00 65 00 6E 00 74 00 61 00 67 00 65 00",
+			"20 00 50 00 65 00 72 00 6D 00 69 00 74 00 74 00 65 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"36 00 02 01 FF FF FF FF 07 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 04 00 00 00 00 00 00 00",
+			"43 00 61 00 6E 00 63 00 65 00 6C 00 6C 00 61 00 74 00 69 00 6F 00 6E 00 20 00 46 00 65 00 65 00",
+			"20 00 46 00 69 00 78 00 65 00 64 00 20 00 56 00 61 00 6C 00 75 00 65 00 00 00 00 00 00 00 00 00",
+			"3A 00 02 01 FF FF FF FF 06 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 02 00 00 00 04 00 00 00 00 00 00 00",
+			"55 00 6D 00 62 00 72 00 65 00 6C 00 6C 00 61 00 20 00 4C 00 69 00 6E 00 6B 00 73 00 20 00 61 00",
+			"6E 00 64 00 20 00 50 00 61 00 73 00 73 00 65 00 6E 00 67 00 65 00 72 00 73 00 00 00 00 00 00 00",
+			"3C 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"43 00 61 00 6E 00 63 00 65 00 6C 00 6C 00 61 00 74 00 69 00 6F 00 6E 00 20 00 46 00 65 00 65 00",
+			"20 00 50 00 65 00 72 00 63 00 65 00 6E 00 74 00 61 00 67 00 65 00 00 00 00 00 00 00 00 00 00 00",
+			"38 00 02 01 FF FF FF FF 05 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 03 00 00 00 04 00 00 00 00 00 00 00",
+			"49 00 6E 00 66 00 61 00 6E 00 74 00 20 00 44 00 69 00 73 00 63 00 6F 00 75 00 6E 00 74 00 20 00",
+			"50 00 65 00 72 00 6D 00 69 00 74 00 74 00 65 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"34 00 02 01 FF FF FF FF 04 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 00 04 00 00 00 00 00 00 00",
+			"43 00 61 00 6E 00 63 00 65 00 6C 00 6C 00 61 00 74 00 69 00 6F 00 6E 00 20 00 46 00 65 00 65 00",
+			"20 00 43 00 75 00 72 00 72 00 65 00 6E 00 63 00 79 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"34 00 02 01 FF FF FF FF 08 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 05 00 00 00 07 00 00 00 00 00 00 00",
+			"4F 00 75 00 74 00 62 00 6F 00 75 00 6E 00 64 00 20 00 54 00 72 00 61 00 76 00 65 00 6C 00 20 00",
+			"44 00 61 00 74 00 65 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2C 00 02 01 FF FF FF FF 0B 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 06 00 00 00 21 00 00 00 00 00 00 00",
+			"42 00 75 00 73 00 69 00 6E 00 65 00 73 00 73 00 20 00 4A 00 75 00 73 00 74 00 69 00 66 00 69 00",
+			"63 00 61 00 74 00 69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2E 00 02 01 FF FF FF FF 03 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 07 00 00 00 04 00 00 00 00 00 00 00",
+			"49 00 6E 00 66 00 61 00 6E 00 74 00 20 00 44 00 69 00 73 00 63 00 6F 00 75 00 6E 00 74 00 20 00",
+			"56 00 61 00 6C 00 75 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2C 00 02 01 FF FF FF FF 0D 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 08 00 00 00 04 00 00 00 00 00 00 00",
+			"4F 00 74 00 68 00 65 00 72 00 20 00 43 00 61 00 72 00 72 00 69 00 65 00 72 00 20 00 53 00 65 00",
+			"63 00 74 00 6F 00 72 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2C 00 02 01 FF FF FF FF 0A 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 09 00 00 00 04 00 00 00 00 00 00 00",
+			"4E 00 75 00 6D 00 62 00 65 00 72 00 20 00 6F 00 66 00 20 00 50 00 61 00 73 00 73 00 65 00 6E 00",
+			"67 00 65 00 72 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"2A 00 02 01 FF FF FF FF 0C 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0A 00 00 00 04 00 00 00 00 00 00 00",
+			"53 00 61 00 6C 00 65 00 73 00 20 00 41 00 72 00 65 00 61 00 20 00 43 00 6F 00 64 00 65 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"20 00 02 01 1C 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0B 00 00 00 04 00 00 00 00 00 00 00",
+			"4F 00 74 00 68 00 65 00 72 00 20 00 52 00 65 00 66 00 75 00 6E 00 64 00 20 00 54 00 65 00 78 00",
+			"74 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"24 00 02 01 17 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0C 00 00 00 04 00 00 00 00 00 00 00",
+			"4D 00 61 00 78 00 69 00 6D 00 75 00 6D 00 20 00 53 00 74 00 61 00 79 00 20 00 50 00 65 00 72 00",
+			"69 00 6F 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 FF FF FF FF 14 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0D 00 00 00 04 00 00 00 00 00 00 00",
+			"4E 00 65 00 74 00 20 00 52 00 65 00 6D 00 69 00 74 00 20 00 50 00 65 00 72 00 6D 00 69 00 74 00",
+			"74 00 65 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 FF FF FF FF 13 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0E 00 00 00 04 00 00 00 00 00 00 00",
+			"50 00 65 00 72 00 63 00 65 00 6E 00 74 00 61 00 67 00 65 00 20 00 6F 00 66 00 20 00 59 00 69 00",
+			"65 00 6C 00 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 FF FF FF FF 02 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0F 00 00 00 04 00 00 00 00 00 00 00",
+			"4E 00 61 00 74 00 75 00 72 00 65 00 20 00 6F 00 66 00 20 00 56 00 61 00 72 00 69 00 61 00 74 00",
+			"69 00 6F 00 6E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 FF FF FF FF 12 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 10 00 00 00 50 00 00 00 00 00 00 00",
+			"46 00 55 00 44 00 20 00 47 00 72 00 69 00 64 00 20 00 44 00 69 00 6D 00 65 00 6E 00 73 00 69 00",
+			"6F 00 6E 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"28 00 02 01 10 00 00 00 11 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 12 00 00 00 04 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 44 00 65 00 73 00 63 00 72 00 69 00 70 00 74 00 69 00 6F 00 6E 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 01 19 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 13 00 00 00 09 00 00 00 00 00 00 00",
+			"54 00 52 00 56 00 41 00 20 00 49 00 6E 00 66 00 6F 00 72 00 6D 00 61 00 74 00 69 00 6F 00 6E 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 01 18 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 14 00 00 00 04 00 00 00 00 00 00 00",
+			"50 00 72 00 6F 00 72 00 61 00 74 00 65 00 20 00 43 00 6F 00 6D 00 6D 00 65 00 6E 00 74 00 73 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 01 16 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"43 00 6F 00 6D 00 6D 00 69 00 73 00 73 00 69 00 6F 00 6E 00 20 00 56 00 61 00 6C 00 75 00 65 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"22 00 02 01 0F 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 15 00 00 00 04 00 00 00 00 00 00 00",
+			"4D 00 61 00 78 00 69 00 6D 00 75 00 6D 00 20 00 53 00 74 00 61 00 79 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1A 00 02 01 20 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 16 00 00 00 05 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 43 00 75 00 72 00 72 00 65 00 6E 00 63 00 79 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1C 00 02 01 1D 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 17 00 00 00 07 00 00 00 00 00 00 00",
+			"43 00 6F 00 6E 00 73 00 6F 00 72 00 74 00 69 00 61 00 20 00 43 00 6F 00 64 00 65 00 73 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"20 00 02 01 1B 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"42 00 75 00 73 00 69 00 6E 00 65 00 73 00 73 00 20 00 54 00 79 00 70 00 65 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"1C 00 02 01 1A 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18 00 00 00 04 00 00 00 00 00 00 00",
+			"44 00 65 00 61 00 6C 00 20 00 54 00 79 00 70 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 01 23 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 19 00 00 00 04 00 00 00 00 00 00 00",
+			"53 00 75 00 72 00 63 00 68 00 61 00 72 00 67 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 01 21 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1A 00 00 00 04 00 00 00 00 00 00 00",
+			"41 00 67 00 65 00 6E 00 74 00 73 00 20 00 4E 00 61 00 6D 00 65 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"18 00 02 01 1F 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1B 00 00 00 04 00 00 00 00 00 00 00",
+			"46 00 61 00 72 00 65 00 20 00 54 00 79 00 70 00 65 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 01 1E 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1C 00 00 00 04 00 00 00 00 00 00 00",
+			"53 00 75 00 62 00 20 00 44 00 65 00 61 00 6C 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"12 00 02 01 24 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1D 00 00 00 04 00 00 00 00 00 00 00",
+			"41 00 4C 00 43 00 20 00 43 00 6F 00 64 00 65 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"14 00 02 01 22 00 00 00 FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"52 00 65 00 6D 00 61 00 72 00 6B 00 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"10 00 02 01 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 03 00 47 42 50 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 1D 00 28 41 29 31 36 2D 4F 63 74 2D 32 30 30 31 20 74 6F 20 31 36 2D 4F 63 74 2D 32 30 30",
+			"31 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 01 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00",
+			"02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00",
+			"02 00 00 00 08 00 00 00 02 00 00 00 08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 18 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 05 00 6A 61 6D 65 73 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 01 00 31 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 03 00 47 42 50 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"08 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"02 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF",
+			"FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF",
+			"11 00 00 00 FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF",
+			"FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FE FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 08 00 00 00",
+			"09 00 00 00 FE FF FF FF 0B 00 00 00 0C 00 00 00 0D 00 00 00 FE FF FF FF FE FF FF FF FE FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+			"FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF",
+		};
 
-    public TestSmallBlockTableReader(String name)
-    {
-        super(name);
-    }
+		RawDataBlockList data_blocks = new RawDataBlockList(new ByteArrayInputStream(RawDataUtil
+				.decode(raw_data_array)), POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+		int[] bat_array = { 15 };
 
-    /**
-     * test reading constructor
-     *
-     * @exception IOException
-     */
+		// need to initialize the block list with a block allocation
+		// table
+		new BlockAllocationTableReader(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, 1, bat_array, 0, -2, data_blocks);
+		
+		// Fake up a header
+		HeaderBlock header_block = new HeaderBlock(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+		header_block.setPropertyStart(0);
 
-    public void testReadingConstructor()
-        throws IOException
-    {
-
-        // first, we need the raw data blocks
-        byte[]           raw_data_array =
-        {
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x45, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x80, ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x15, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x46, ( byte ) 0x00, ( byte ) 0x55, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x32, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x09, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x68, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x36, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x78, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x56, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x55, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4C, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x6B, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x3C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x38, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x34, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x46, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x34, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x76, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x21, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x42, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4A, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2E, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x49, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x56, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x68, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x09, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x62, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x2A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x6C, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4F, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x68, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x78, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x24, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x17, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x78, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x50, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x13, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x67, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x59, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4E, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x66, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x56, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x46, ( byte ) 0x00, ( byte ) 0x55, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x64, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x11, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x44, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x63, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x19, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x13, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x09, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x54, ( byte ) 0x00, ( byte ) 0x52, ( byte ) 0x00,
-            ( byte ) 0x56, ( byte ) 0x00, ( byte ) 0x41, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x49, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x66, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x18, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x50, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x69, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x56, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x0F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x15, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x4D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x78, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x74, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x79, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x16, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x43, ( byte ) 0x00,
-            ( byte ) 0x75, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x17, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x6F, ( byte ) 0x00, ( byte ) 0x72, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x42, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x69, ( byte ) 0x00,
-            ( byte ) 0x6E, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x18, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x23, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x19, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x63, ( byte ) 0x00,
-            ( byte ) 0x68, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x21, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1A, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x67, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x6E, ( byte ) 0x00,
-            ( byte ) 0x74, ( byte ) 0x00, ( byte ) 0x73, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x4E, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6D, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x18, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1F, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x46, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x20, ( byte ) 0x00, ( byte ) 0x54, ( byte ) 0x00,
-            ( byte ) 0x79, ( byte ) 0x00, ( byte ) 0x70, ( byte ) 0x00,
-            ( byte ) 0x65, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x1E, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x53, ( byte ) 0x00, ( byte ) 0x75, ( byte ) 0x00,
-            ( byte ) 0x62, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x44, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x61, ( byte ) 0x00, ( byte ) 0x6C, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x12, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x24, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x1D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x41, ( byte ) 0x00, ( byte ) 0x4C, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x20, ( byte ) 0x00,
-            ( byte ) 0x43, ( byte ) 0x00, ( byte ) 0x6F, ( byte ) 0x00,
-            ( byte ) 0x64, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x14, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0x22, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x52, ( byte ) 0x00, ( byte ) 0x65, ( byte ) 0x00,
-            ( byte ) 0x6D, ( byte ) 0x00, ( byte ) 0x61, ( byte ) 0x00,
-            ( byte ) 0x72, ( byte ) 0x00, ( byte ) 0x6B, ( byte ) 0x00,
-            ( byte ) 0x73, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x10, ( byte ) 0x00, ( byte ) 0x02, ( byte ) 0x01,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x42, ( byte ) 0x50, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x1D, ( byte ) 0x00,
-            ( byte ) 0x28, ( byte ) 0x41, ( byte ) 0x29, ( byte ) 0x31,
-            ( byte ) 0x36, ( byte ) 0x2D, ( byte ) 0x4F, ( byte ) 0x63,
-            ( byte ) 0x74, ( byte ) 0x2D, ( byte ) 0x32, ( byte ) 0x30,
-            ( byte ) 0x30, ( byte ) 0x31, ( byte ) 0x20, ( byte ) 0x74,
-            ( byte ) 0x6F, ( byte ) 0x20, ( byte ) 0x31, ( byte ) 0x36,
-            ( byte ) 0x2D, ( byte ) 0x4F, ( byte ) 0x63, ( byte ) 0x74,
-            ( byte ) 0x2D, ( byte ) 0x32, ( byte ) 0x30, ( byte ) 0x30,
-            ( byte ) 0x31, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x18, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x05, ( byte ) 0x00,
-            ( byte ) 0x6A, ( byte ) 0x61, ( byte ) 0x6D, ( byte ) 0x65,
-            ( byte ) 0x73, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x01, ( byte ) 0x00,
-            ( byte ) 0x31, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x03, ( byte ) 0x00,
-            ( byte ) 0x47, ( byte ) 0x42, ( byte ) 0x50, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x11, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x01, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x02, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x03, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x04, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x05, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x06, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x07, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x08, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x09, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0x0B, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0C, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0x0D, ( byte ) 0x00, ( byte ) 0x00, ( byte ) 0x00,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFE, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF,
-            ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF, ( byte ) 0xFF
-        };
-        RawDataBlockList data_blocks    =
-            new RawDataBlockList(new ByteArrayInputStream(raw_data_array), POIFSConstants.BIG_BLOCK_SIZE);
-        int[]            bat_array      =
-        {
-            15
-        };
-
-        // need to initialize the block list with a block allocation
-        // table
-        new BlockAllocationTableReader(1, bat_array, 0, -2, data_blocks);
-
-        // get property table from the document
-        PropertyTable properties = new PropertyTable(0, data_blocks);
-        RootProperty  root       = properties.getRoot();
-        BlockList     bl         =
-            SmallBlockTableReader.getSmallDocumentBlocks(data_blocks, root,
-                14);
-    }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.storage.SmallBlockTableReader");
-        junit.textui.TestRunner.run(TestSmallBlockTableReader.class);
-    }
+		// get property table from the document
+		PropertyTable properties = new PropertyTable(header_block, data_blocks);
+		RootProperty root = properties.getRoot();
+		BlockList bl = SmallBlockTableReader.getSmallDocumentBlocks(
+		      POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, data_blocks, root, 14);
+		assertNotNull(bl);
+	}
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestSmallBlockTableWriter.java b/src/testcases/org/apache/poi/poifs/storage/TestSmallBlockTableWriter.java
index 981b244..f10576a 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestSmallBlockTableWriter.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestSmallBlockTableWriter.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,16 +14,17 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 
-import java.util.*;
+import junit.framework.TestCase;
 
-import junit.framework.*;
-
+import org.apache.poi.poifs.common.POIFSConstants;
 import org.apache.poi.poifs.filesystem.POIFSDocument;
 import org.apache.poi.poifs.property.PropertyTable;
 import org.apache.poi.poifs.property.RootProperty;
@@ -34,32 +34,10 @@
  *
  * @author Marc Johnson
  */
+public final class TestSmallBlockTableWriter extends TestCase {
 
-public class TestSmallBlockTableWriter
-    extends TestCase
-{
-
-    /**
-     * Constructor TestSmallBlockTableWriter
-     *
-     * @param name
-     */
-
-    public TestSmallBlockTableWriter(String name)
-    {
-        super(name);
-    }
-
-    /**
-     * test writing constructor
-     *
-     * @exception IOException
-     */
-
-    public void testWritingConstructor()
-        throws IOException
-    {
-        List documents = new ArrayList();
+    public void testWritingConstructor() throws IOException {
+        List<POIFSDocument> documents = new ArrayList<POIFSDocument>();
 
         documents.add(
             new POIFSDocument(
@@ -97,9 +75,11 @@
         documents
             .add(new POIFSDocument("doc9",
                                    new ByteArrayInputStream(new byte[ 9 ])));
-        RootProperty               root = new PropertyTable().getRoot();
-        SmallBlockTableWriter      sbtw = new SmallBlockTableWriter(documents,
-                                              root);
+        
+        HeaderBlock              header = new HeaderBlock(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+        RootProperty               root = new PropertyTable(header).getRoot();
+        SmallBlockTableWriter      sbtw = new SmallBlockTableWriter(
+              POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, documents,root);
         BlockAllocationTableWriter bat  = sbtw.getSBAT();
 
         // 15 small blocks: 6 for doc340, 0 for doc5000 (too big), 0
@@ -113,17 +93,4 @@
         sbtw.setStartBlock(start_block);
         assertEquals(start_block, root.getStartBlock());
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.storage.SmallBlockTableWriter");
-        junit.textui.TestRunner.run(TestSmallBlockTableWriter.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestSmallDocumentBlock.java b/src/testcases/org/apache/poi/poifs/storage/TestSmallDocumentBlock.java
index 05e5197..b061483 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestSmallDocumentBlock.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestSmallDocumentBlock.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,25 +14,26 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
 
-import java.util.*;
+import org.apache.poi.poifs.common.POIFSConstants;
 
-import junit.framework.*;
+import junit.framework.TestCase;
 
 /**
  * Class to test SmallDocumentBlock functionality
  *
  * @author Marc Johnson
  */
-
-public class TestSmallDocumentBlock
-    extends TestCase
-{
+public final class TestSmallDocumentBlock extends TestCase {
     static final private byte[] _testdata;
     static final private int    _testdata_size = 2999;
 
@@ -45,25 +45,10 @@
             _testdata[ j ] = ( byte ) j;
         }
     }
-    ;
-
-    /**
-     * constructor
-     *
-     * @param name
-     */
-
-    public TestSmallDocumentBlock(String name)
-    {
-        super(name);
-    }
 
     /**
      * Test conversion from DocumentBlocks
-     *
-     * @exception IOException
      */
-
     public void testConvert1()
         throws IOException
     {
@@ -72,7 +57,7 @@
 
         while (true)
         {
-            DocumentBlock block = new DocumentBlock(stream);
+            DocumentBlock block = new DocumentBlock(stream,POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
 
             documents.add(block);
             if (block.partiallyRead())
@@ -82,7 +67,7 @@
         }
         SmallDocumentBlock[] results =
             SmallDocumentBlock
-                .convert(( BlockWritable [] ) documents
+                .convert(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,( BlockWritable [] ) documents
                     .toArray(new DocumentBlock[ 0 ]), _testdata_size);
 
         assertEquals("checking correct result size: ",
@@ -113,12 +98,7 @@
 
     /**
      * Test conversion from byte array
-     *
-     * @exception IOException;
-     *
-     * @exception IOException
      */
-
     public void testConvert2()
         throws IOException
     {
@@ -130,8 +110,8 @@
             {
                 array[ k ] = ( byte ) k;
             }
-            SmallDocumentBlock[] blocks = SmallDocumentBlock.convert(array,
-                                              319);
+            SmallDocumentBlock[] blocks = SmallDocumentBlock.convert(
+                  POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, array, 319);
 
             assertEquals(5, blocks.length);
             ByteArrayOutputStream stream = new ByteArrayOutputStream();
@@ -155,56 +135,8 @@
     }
 
     /**
-     * Test read method
-     *
-     * @exception IOException
-     */
-
-    public void testRead()
-        throws IOException
-    {
-        ByteArrayInputStream stream    = new ByteArrayInputStream(_testdata);
-        List                 documents = new ArrayList();
-
-        while (true)
-        {
-            DocumentBlock block = new DocumentBlock(stream);
-
-            documents.add(block);
-            if (block.partiallyRead())
-            {
-                break;
-            }
-        }
-        SmallDocumentBlock[] blocks =
-            SmallDocumentBlock
-                .convert(( BlockWritable [] ) documents
-                    .toArray(new DocumentBlock[ 0 ]), _testdata_size);
-
-        for (int j = 1; j <= _testdata_size; j += 38)
-        {
-            byte[] buffer = new byte[ j ];
-            int    offset = 0;
-
-            for (int k = 0; k < (_testdata_size / j); k++)
-            {
-                SmallDocumentBlock.read(blocks, buffer, offset);
-                for (int n = 0; n < buffer.length; n++)
-                {
-                    assertEquals("checking byte " + (k * j) + n,
-                                 _testdata[ (k * j) + n ], buffer[ n ]);
-                }
-                offset += j;
-            }
-        }
-    }
-
-    /**
      * test fill
-     *
-     * @exception IOException
      */
-
     public void testFill()
         throws IOException
     {
@@ -216,7 +148,7 @@
             {
                 foo.add(new Object());
             }
-            int result = SmallDocumentBlock.fill(foo);
+            int result = SmallDocumentBlock.fill(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,foo);
 
             assertEquals("correct big block count: ", (j + 7) / 8, result);
             assertEquals("correct small block count: ", 8 * result,
@@ -276,7 +208,7 @@
         {
             new RawDataBlock(new ByteArrayInputStream(data))
         };
-        List           output = SmallDocumentBlock.extract(blocks);
+        List           output = SmallDocumentBlock.extract(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,blocks);
         Iterator       iter   = output.iterator();
 
         offset = 0;
@@ -294,17 +226,4 @@
             }
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.storage.SmallDocumentBlock");
-        junit.textui.TestRunner.run(TestSmallDocumentBlock.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/poifs/storage/TestSmallDocumentBlockList.java b/src/testcases/org/apache/poi/poifs/storage/TestSmallDocumentBlockList.java
index 6901112..5301214 100644
--- a/src/testcases/org/apache/poi/poifs/storage/TestSmallDocumentBlockList.java
+++ b/src/testcases/org/apache/poi/poifs/storage/TestSmallDocumentBlockList.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,44 +14,24 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.poifs.storage;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
 
-import junit.framework.*;
+import org.apache.poi.poifs.common.POIFSConstants;
+
+import junit.framework.TestCase;
 
 /**
  * Class to test SmallDocumentBlockList functionality
  *
  * @author Marc Johnson
  */
+public final class TestSmallDocumentBlockList extends TestCase {
 
-public class TestSmallDocumentBlockList
-    extends TestCase
-{
-
-    /**
-     * Constructor TestSmallDocumentBlockList
-     *
-     * @param name
-     */
-
-    public TestSmallDocumentBlockList(String name)
-    {
-        super(name);
-    }
-
-    /**
-     * Test creating a SmallDocumentBlockList
-     *
-     * @exception IOException
-     */
-
-    public void testConstructor()
-        throws IOException
-    {
+    public void testConstructor() throws IOException {
         byte[] data = new byte[ 2560 ];
 
         for (int j = 0; j < 2560; j++)
@@ -67,7 +46,7 @@
             blocks[ j ] = new RawDataBlock(stream);
         }
         SmallDocumentBlockList sdbl =
-            new SmallDocumentBlockList(SmallDocumentBlock.extract(blocks));
+            new SmallDocumentBlockList(SmallDocumentBlock.extract(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,blocks));
 
         // proof we added the blocks
         for (int j = 0; j < 40; j++)
@@ -85,17 +64,4 @@
             // it better have thrown one!!
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println(
-            "Testing org.apache.poi.poifs.storage.SmallDocumentBlockList");
-        junit.textui.TestRunner.run(TestSmallDocumentBlockList.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/util/AllPOIUtilTests.java b/src/testcases/org/apache/poi/util/AllPOIUtilTests.java
index bb6d382..686aa54 100755
--- a/src/testcases/org/apache/poi/util/AllPOIUtilTests.java
+++ b/src/testcases/org/apache/poi/util/AllPOIUtilTests.java
@@ -27,17 +27,14 @@
 public final class AllPOIUtilTests {
 
     public static Test suite() {
-        TestSuite result = new TestSuite("Tests for org.apache.poi.util");
+        TestSuite result = new TestSuite(AllPOIUtilTests.class.getName());
         result.addTestSuite(TestArrayUtil.class);
         result.addTestSuite(TestBinaryTree.class);
         result.addTestSuite(TestBitField.class);
         result.addTestSuite(TestByteField.class);
-        result.addTestSuite(TestDoubleList2d.class);
         result.addTestSuite(TestHexDump.class);
         result.addTestSuite(TestIntegerField.class);
         result.addTestSuite(TestIntList.class);
-        result.addTestSuite(TestIntList2d.class);
-        result.addTestSuite(TestList2d.class);
         result.addTestSuite(TestLittleEndian.class);
         result.addTestSuite(TestLongField.class);
         result.addTestSuite(TestPOILogFactory.class);
diff --git a/src/testcases/org/apache/poi/util/DummyPOILogger.java b/src/testcases/org/apache/poi/util/DummyPOILogger.java
index 7efbfac..f72e37b 100644
--- a/src/testcases/org/apache/poi/util/DummyPOILogger.java
+++ b/src/testcases/org/apache/poi/util/DummyPOILogger.java
@@ -37,10 +37,10 @@
 	public void initialize(String cat) {}
 
 	public void log(int level, Object obj1) {
-		logged.add(new String(level + " - " + obj1));
+		logged.add(level + " - " + obj1);
 	}
 
 	public void log(int level, Object obj1, Throwable exception) {
-		logged.add(new String(level + " - " + obj1 + " - " + exception));
+		logged.add(level + " - " + obj1 + " - " + exception);
 	}
 }
diff --git a/src/testcases/org/apache/poi/util/LocalTestNode.java b/src/testcases/org/apache/poi/util/LocalTestNode.java
index 2f1ae62..6eaaed5 100644
--- a/src/testcases/org/apache/poi/util/LocalTestNode.java
+++ b/src/testcases/org/apache/poi/util/LocalTestNode.java
@@ -15,7 +15,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
@@ -33,7 +32,7 @@
 
     LocalTestNode(final int key)
     {
-        _key   = new Integer(key);
+        _key   = Integer.valueOf(key);
         _value = String.valueOf(key);
     }
 
@@ -118,7 +117,6 @@
     /**
      * @return hash code
      */
-
     public int hashCode()
     {
         return getKey().hashCode() ^ getValue().hashCode();
diff --git a/src/testcases/org/apache/poi/util/TestArrayUtil.java b/src/testcases/org/apache/poi/util/TestArrayUtil.java
index 7a517e3..2af0481 100644
--- a/src/testcases/org/apache/poi/util/TestArrayUtil.java
+++ b/src/testcases/org/apache/poi/util/TestArrayUtil.java
@@ -15,261 +15,264 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.util;
 
-import junit.framework.*;
+import junit.framework.TestCase;
 
 /**
  * Unit test for ArrayUtil
  *
  * @author Nick Burch
  */
-public class TestArrayUtil extends TestCase
-{
+public class TestArrayUtil extends TestCase {
 	/**
 	 * Test to ensure that our own arraycopy behaves as it should do
 	 */
 	public void testarraycopy() {
 		byte[] bytes = new byte[] { 0x01, 0x02, 0x03, 0x04 };
-		
+
 		// Test copy whole thing
 		byte[] dest = new byte[4];
 		ArrayUtil.arraycopy(bytes, 0, dest, 0, 4);
-		
+
 		assertEquals(dest.length, bytes.length);
 		for(int i=0; i<dest.length; i++) {
 			assertEquals(bytes[i], dest[i]);
 		}
-		
+
 		// ToDo - test exceptions are as expected
 	}
-	
-	
+
+
 	/**
-	 * Helper for testArrayMoveWithin 
+	 * Helper for testArrayMoveWithin
 	 */
-	private Integer[] getIntsList() { 
+	private Integer[] getIntsList() {
 		return new Integer[] {
-				new Integer(0),
-				new Integer(1),
-				new Integer(2),
-				new Integer(3),
-				new Integer(4),
-				new Integer(5),
-				new Integer(6),
-				new Integer(7),
-				new Integer(8),
-				new Integer(9)
+				Integer.valueOf(0),
+				Integer.valueOf(1),
+				Integer.valueOf(2),
+				Integer.valueOf(3),
+				Integer.valueOf(4),
+				Integer.valueOf(5),
+				Integer.valueOf(6),
+				Integer.valueOf(7),
+				Integer.valueOf(8),
+				Integer.valueOf(9)
 		};
 	}
+
+	private static void assertEquals(int exp, Integer act) {
+		assertEquals(exp, act.intValue());
+	}
 	
 	/**
 	 * Test to ensure that arrayMoveWithin works as expected
 	 */
 	public void testArrayMoveWithin() {
 		Integer[] ints = getIntsList();
-		
-		assertEquals(new Integer(0), ints[0]);
-		assertEquals(new Integer(1), ints[1]);
-		assertEquals(new Integer(2), ints[2]);
-		assertEquals(new Integer(3), ints[3]);
-		assertEquals(new Integer(4), ints[4]);
-		assertEquals(new Integer(5), ints[5]);
-		assertEquals(new Integer(6), ints[6]);
-		assertEquals(new Integer(7), ints[7]);
-		assertEquals(new Integer(8), ints[8]);
-		assertEquals(new Integer(9), ints[9]);
-		
-		
+
+		assertEquals(0, ints[0]);
+		assertEquals(1, ints[1]);
+		assertEquals(2, ints[2]);
+		assertEquals(3, ints[3]);
+		assertEquals(4, ints[4]);
+		assertEquals(5, ints[5]);
+		assertEquals(6, ints[6]);
+		assertEquals(7, ints[7]);
+		assertEquals(8, ints[8]);
+		assertEquals(9, ints[9]);
+
+
 		//
 		// Moving to a later point in the array
 		//
-		
+
 		// Shift 1 back
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 4, 8, 1);
-		assertEquals(new Integer(0), ints[0]);
-		assertEquals(new Integer(1), ints[1]);
-		assertEquals(new Integer(2), ints[2]);
-		assertEquals(new Integer(3), ints[3]);
-		assertEquals(new Integer(5), ints[4]);
-		assertEquals(new Integer(6), ints[5]);
-		assertEquals(new Integer(7), ints[6]);
-		assertEquals(new Integer(8), ints[7]);
-		assertEquals(new Integer(4), ints[8]);
-		assertEquals(new Integer(9), ints[9]);
-		
+		assertEquals(0, ints[0]);
+		assertEquals(1, ints[1]);
+		assertEquals(2, ints[2]);
+		assertEquals(3, ints[3]);
+		assertEquals(5, ints[4]);
+		assertEquals(6, ints[5]);
+		assertEquals(7, ints[6]);
+		assertEquals(8, ints[7]);
+		assertEquals(4, ints[8]);
+		assertEquals(9, ints[9]);
+
 		// Shift front 1 back
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 0, 7, 1);
-		assertEquals(new Integer(1), ints[0]);
-		assertEquals(new Integer(2), ints[1]);
-		assertEquals(new Integer(3), ints[2]);
-		assertEquals(new Integer(4), ints[3]);
-		assertEquals(new Integer(5), ints[4]);
-		assertEquals(new Integer(6), ints[5]);
-		assertEquals(new Integer(7), ints[6]);
-		assertEquals(new Integer(0), ints[7]);
-		assertEquals(new Integer(8), ints[8]);
-		assertEquals(new Integer(9), ints[9]);
-		
+		assertEquals(1, ints[0]);
+		assertEquals(2, ints[1]);
+		assertEquals(3, ints[2]);
+		assertEquals(4, ints[3]);
+		assertEquals(5, ints[4]);
+		assertEquals(6, ints[5]);
+		assertEquals(7, ints[6]);
+		assertEquals(0, ints[7]);
+		assertEquals(8, ints[8]);
+		assertEquals(9, ints[9]);
+
 		// Shift 1 to end
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 4, 9, 1);
-		assertEquals(new Integer(0), ints[0]);
-		assertEquals(new Integer(1), ints[1]);
-		assertEquals(new Integer(2), ints[2]);
-		assertEquals(new Integer(3), ints[3]);
-		assertEquals(new Integer(5), ints[4]);
-		assertEquals(new Integer(6), ints[5]);
-		assertEquals(new Integer(7), ints[6]);
-		assertEquals(new Integer(8), ints[7]);
-		assertEquals(new Integer(9), ints[8]);
-		assertEquals(new Integer(4), ints[9]);
+		assertEquals(0, ints[0]);
+		assertEquals(1, ints[1]);
+		assertEquals(2, ints[2]);
+		assertEquals(3, ints[3]);
+		assertEquals(5, ints[4]);
+		assertEquals(6, ints[5]);
+		assertEquals(7, ints[6]);
+		assertEquals(8, ints[7]);
+		assertEquals(9, ints[8]);
+		assertEquals(4, ints[9]);
 
-				
+
 		//
 		// Moving to an earlier point in the array
 		//
-		
+
 		// Shift 1 forward
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 8, 3, 1);
-		assertEquals(new Integer(0), ints[0]);
-		assertEquals(new Integer(1), ints[1]);
-		assertEquals(new Integer(2), ints[2]);
-		assertEquals(new Integer(8), ints[3]);
-		assertEquals(new Integer(3), ints[4]);
-		assertEquals(new Integer(4), ints[5]);
-		assertEquals(new Integer(5), ints[6]);
-		assertEquals(new Integer(6), ints[7]);
-		assertEquals(new Integer(7), ints[8]);
-		assertEquals(new Integer(9), ints[9]);
-		
+		assertEquals(0, ints[0]);
+		assertEquals(1, ints[1]);
+		assertEquals(2, ints[2]);
+		assertEquals(8, ints[3]);
+		assertEquals(3, ints[4]);
+		assertEquals(4, ints[5]);
+		assertEquals(5, ints[6]);
+		assertEquals(6, ints[7]);
+		assertEquals(7, ints[8]);
+		assertEquals(9, ints[9]);
+
 		// Shift end 1 forward
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 9, 2, 1);
-		assertEquals(new Integer(0), ints[0]);
-		assertEquals(new Integer(1), ints[1]);
-		assertEquals(new Integer(9), ints[2]);
-		assertEquals(new Integer(2), ints[3]);
-		assertEquals(new Integer(3), ints[4]);
-		assertEquals(new Integer(4), ints[5]);
-		assertEquals(new Integer(5), ints[6]);
-		assertEquals(new Integer(6), ints[7]);
-		assertEquals(new Integer(7), ints[8]);
-		assertEquals(new Integer(8), ints[9]);
-		
+		assertEquals(0, ints[0]);
+		assertEquals(1, ints[1]);
+		assertEquals(9, ints[2]);
+		assertEquals(2, ints[3]);
+		assertEquals(3, ints[4]);
+		assertEquals(4, ints[5]);
+		assertEquals(5, ints[6]);
+		assertEquals(6, ints[7]);
+		assertEquals(7, ints[8]);
+		assertEquals(8, ints[9]);
+
 		// Shift 1 to front
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 5, 0, 1);
-		assertEquals(new Integer(5), ints[0]);
-		assertEquals(new Integer(0), ints[1]);
-		assertEquals(new Integer(1), ints[2]);
-		assertEquals(new Integer(2), ints[3]);
-		assertEquals(new Integer(3), ints[4]);
-		assertEquals(new Integer(4), ints[5]);
-		assertEquals(new Integer(6), ints[6]);
-		assertEquals(new Integer(7), ints[7]);
-		assertEquals(new Integer(8), ints[8]);
-		assertEquals(new Integer(9), ints[9]);
+		assertEquals(5, ints[0]);
+		assertEquals(0, ints[1]);
+		assertEquals(1, ints[2]);
+		assertEquals(2, ints[3]);
+		assertEquals(3, ints[4]);
+		assertEquals(4, ints[5]);
+		assertEquals(6, ints[6]);
+		assertEquals(7, ints[7]);
+		assertEquals(8, ints[8]);
+		assertEquals(9, ints[9]);
 
-		
+
 		//
 		// Moving many to a later point in the array
 		//
-		
+
 		// Shift 3 back
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 2, 6, 3);
-		assertEquals(new Integer(0), ints[0]);
-		assertEquals(new Integer(1), ints[1]);
-		assertEquals(new Integer(5), ints[2]);
-		assertEquals(new Integer(6), ints[3]);
-		assertEquals(new Integer(7), ints[4]);
-		assertEquals(new Integer(8), ints[5]);
-		assertEquals(new Integer(2), ints[6]);
-		assertEquals(new Integer(3), ints[7]);
-		assertEquals(new Integer(4), ints[8]);
-		assertEquals(new Integer(9), ints[9]);
-		
+		assertEquals(0, ints[0]);
+		assertEquals(1, ints[1]);
+		assertEquals(5, ints[2]);
+		assertEquals(6, ints[3]);
+		assertEquals(7, ints[4]);
+		assertEquals(8, ints[5]);
+		assertEquals(2, ints[6]);
+		assertEquals(3, ints[7]);
+		assertEquals(4, ints[8]);
+		assertEquals(9, ints[9]);
+
 		// Shift 3 to back
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 2, 7, 3);
-		assertEquals(new Integer(0), ints[0]);
-		assertEquals(new Integer(1), ints[1]);
-		assertEquals(new Integer(5), ints[2]);
-		assertEquals(new Integer(6), ints[3]);
-		assertEquals(new Integer(7), ints[4]);
-		assertEquals(new Integer(8), ints[5]);
-		assertEquals(new Integer(9), ints[6]);
-		assertEquals(new Integer(2), ints[7]);
-		assertEquals(new Integer(3), ints[8]);
-		assertEquals(new Integer(4), ints[9]);
-		
+		assertEquals(0, ints[0]);
+		assertEquals(1, ints[1]);
+		assertEquals(5, ints[2]);
+		assertEquals(6, ints[3]);
+		assertEquals(7, ints[4]);
+		assertEquals(8, ints[5]);
+		assertEquals(9, ints[6]);
+		assertEquals(2, ints[7]);
+		assertEquals(3, ints[8]);
+		assertEquals(4, ints[9]);
+
 		// Shift from 3 front
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 0, 5, 3);
-		assertEquals(new Integer(3), ints[0]);
-		assertEquals(new Integer(4), ints[1]);
-		assertEquals(new Integer(5), ints[2]);
-		assertEquals(new Integer(6), ints[3]);
-		assertEquals(new Integer(7), ints[4]);
-		assertEquals(new Integer(0), ints[5]);
-		assertEquals(new Integer(1), ints[6]);
-		assertEquals(new Integer(2), ints[7]);
-		assertEquals(new Integer(8), ints[8]);
-		assertEquals(new Integer(9), ints[9]);
-		
-		
+		assertEquals(3, ints[0]);
+		assertEquals(4, ints[1]);
+		assertEquals(5, ints[2]);
+		assertEquals(6, ints[3]);
+		assertEquals(7, ints[4]);
+		assertEquals(0, ints[5]);
+		assertEquals(1, ints[6]);
+		assertEquals(2, ints[7]);
+		assertEquals(8, ints[8]);
+		assertEquals(9, ints[9]);
+
+
 		//
 		// Moving many to an earlier point in the array
 		//
-		
+
 		// Shift 3 forward
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 6, 2, 3);
-		assertEquals(new Integer(0), ints[0]);
-		assertEquals(new Integer(1), ints[1]);
-		assertEquals(new Integer(6), ints[2]);
-		assertEquals(new Integer(7), ints[3]);
-		assertEquals(new Integer(8), ints[4]);
-		assertEquals(new Integer(2), ints[5]);
-		assertEquals(new Integer(3), ints[6]);
-		assertEquals(new Integer(4), ints[7]);
-		assertEquals(new Integer(5), ints[8]);
-		assertEquals(new Integer(9), ints[9]);
-		
+		assertEquals(0, ints[0]);
+		assertEquals(1, ints[1]);
+		assertEquals(6, ints[2]);
+		assertEquals(7, ints[3]);
+		assertEquals(8, ints[4]);
+		assertEquals(2, ints[5]);
+		assertEquals(3, ints[6]);
+		assertEquals(4, ints[7]);
+		assertEquals(5, ints[8]);
+		assertEquals(9, ints[9]);
+
 		// Shift 3 to front
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 6, 0, 3);
-		assertEquals(new Integer(6), ints[0]);
-		assertEquals(new Integer(7), ints[1]);
-		assertEquals(new Integer(8), ints[2]);
-		assertEquals(new Integer(0), ints[3]);
-		assertEquals(new Integer(1), ints[4]);
-		assertEquals(new Integer(2), ints[5]);
-		assertEquals(new Integer(3), ints[6]);
-		assertEquals(new Integer(4), ints[7]);
-		assertEquals(new Integer(5), ints[8]);
-		assertEquals(new Integer(9), ints[9]);
-		
+		assertEquals(6, ints[0]);
+		assertEquals(7, ints[1]);
+		assertEquals(8, ints[2]);
+		assertEquals(0, ints[3]);
+		assertEquals(1, ints[4]);
+		assertEquals(2, ints[5]);
+		assertEquals(3, ints[6]);
+		assertEquals(4, ints[7]);
+		assertEquals(5, ints[8]);
+		assertEquals(9, ints[9]);
+
 		// Shift from 3 back
 		ints = getIntsList();
 		ArrayUtil.arrayMoveWithin(ints, 7, 3, 3);
-		assertEquals(new Integer(0), ints[0]);
-		assertEquals(new Integer(1), ints[1]);
-		assertEquals(new Integer(2), ints[2]);
-		assertEquals(new Integer(7), ints[3]);
-		assertEquals(new Integer(8), ints[4]);
-		assertEquals(new Integer(9), ints[5]);
-		assertEquals(new Integer(3), ints[6]);
-		assertEquals(new Integer(4), ints[7]);
-		assertEquals(new Integer(5), ints[8]);
-		assertEquals(new Integer(6), ints[9]);
-		
-		
+		assertEquals(0, ints[0]);
+		assertEquals(1, ints[1]);
+		assertEquals(2, ints[2]);
+		assertEquals(7, ints[3]);
+		assertEquals(8, ints[4]);
+		assertEquals(9, ints[5]);
+		assertEquals(3, ints[6]);
+		assertEquals(4, ints[7]);
+		assertEquals(5, ints[8]);
+		assertEquals(6, ints[9]);
+
+
 		// Check can't shift more than we have
 		try {
 			ints = getIntsList();
@@ -278,7 +281,7 @@
 		} catch(IllegalArgumentException e) {
 			// Good, we don't have 5 from 7 onwards
 		}
-		
+
 		// Check can't shift where would overshoot
 		try {
 			ints = getIntsList();
@@ -289,4 +292,3 @@
 		}
 	}
 }
-
diff --git a/src/testcases/org/apache/poi/util/TestBinaryTree.java b/src/testcases/org/apache/poi/util/TestBinaryTree.java
index 7f53623..5426359 100644
--- a/src/testcases/org/apache/poi/util/TestBinaryTree.java
+++ b/src/testcases/org/apache/poi/util/TestBinaryTree.java
@@ -15,7 +15,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
@@ -28,28 +27,9 @@
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
+public final class TestBinaryTree extends TestCase {
 
-public class TestBinaryTree
-    extends TestCase
-{
-
-    /**
-     * constructor
-     *
-     * @param name
-     */
-
-    public TestBinaryTree(final String name)
-    {
-        super(name);
-    }
-
-    /**
-     * test size() method
-     */
-
-    public void testSize()
-    {
+    public void testSize() {
         Map m = new BinaryTree();
 
         assertEquals(0, m.size());
@@ -74,12 +54,7 @@
         }
     }
 
-    /**
-     * test IsEmpty() method
-     */
-
-    public void testIsEmpty()
-    {
+    public void testIsEmpty() {
         Map m = new BinaryTree();
 
         assertTrue(m.isEmpty());
@@ -118,12 +93,7 @@
         }
     }
 
-    /**
-     * test containsKey() method
-     */
-
-    public void testContainsKey()
-    {
+    public void testContainsKey() {
         Map m = new BinaryTree();
 
         try
@@ -150,7 +120,7 @@
             m.put(nodes[ k ].getKey(), nodes[ k ]);
             assertTrue(m.containsKey(nodes[ k ].getKey()));
         }
-        assertTrue(!m.containsKey(new Integer(-1)));
+        assertTrue(!m.containsKey(Integer.valueOf(-1)));
         try
         {
             m.containsKey("foo");
@@ -166,12 +136,7 @@
         }
     }
 
-    /**
-     * test containsValue() method
-     */
-
-    public void testContainsValue()
-    {
+    public void testContainsValue() {
         Map           m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
 
@@ -187,12 +152,7 @@
         }
     }
 
-    /**
-     * test get() method
-     */
-
-    public void testGet()
-    {
+    public void testGet() {
         Map m = new BinaryTree();
 
         try
@@ -219,7 +179,7 @@
             m.put(nodes[ k ].getKey(), nodes[ k ]);
             assertSame(m.get(nodes[ k ].getKey()), nodes[ k ]);
         }
-        assertNull(m.get(new Integer(-1)));
+        assertNull(m.get(Integer.valueOf(-1)));
         try
         {
             m.get("foo");
@@ -236,12 +196,7 @@
         }
     }
 
-    /**
-     * test put() method
-     */
-
-    public void testPut()
-    {
+    public void testPut() {
         Map m = new BinaryTree();
 
         try
@@ -291,12 +246,7 @@
         }
     }
 
-    /**
-     * test remove() method
-     */
-
-    public void testRemove()
-    {
+    public void testRemove() {
         BinaryTree    m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
 
@@ -320,7 +270,7 @@
         catch (ClassCastException ignored)
         {
         }
-        assertNull(m.remove(new Integer(-1)));
+        assertNull(m.remove(Integer.valueOf(-1)));
         try
         {
             m.remove("foo");
@@ -350,12 +300,7 @@
         assertTrue(m.isEmpty());
     }
 
-    /**
-     * Method testPutAll
-     */
-
-    public void testPutAll()
-    {
+    public void testPutAll() {
         Map           m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
 
@@ -419,12 +364,7 @@
         }
     }
 
-    /**
-     * test clear() method
-     */
-
-    public void testClear()
-    {
+    public void testClear() {
         Map           m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
 
@@ -448,12 +388,7 @@
         }
     }
 
-    /**
-     * test keySet() method
-     */
-
-    public void testKeySet()
-    {
+    public void testKeySet() {
         testKeySet(new BinaryTree());
         Map           m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
@@ -515,7 +450,7 @@
         Collection c1 = new LinkedList();
         Collection c2 = new LinkedList();
 
-        c2.add(new Integer(-99));
+        c2.add(Integer.valueOf(-99));
         for (int k = 0; k < nodes.length; k++)
         {
             m.put(nodes[ k ].getKey(), nodes[ k ]);
@@ -526,7 +461,7 @@
         assertTrue(!m.keySet().containsAll(c2));
         m  = new BinaryTree();
         c1 = new LinkedList();
-        c1.add(new Integer(-55));
+        c1.add(Integer.valueOf(-55));
         try
         {
             m.keySet().addAll(c1);
@@ -600,12 +535,7 @@
         assertTrue(m.size() == 0);
     }
 
-    /**
-     * test values() method
-     */
-
-    public void testValues()
-    {
+    public void testValues() {
         testValues(new BinaryTree());
         Map           m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
@@ -741,12 +671,7 @@
         assertEquals(0, m.size());
     }
 
-    /**
-     * test entrySet() method
-     */
-
-    public void testEntrySet()
-    {
+    public void testEntrySet() {
         testEntrySet(new BinaryTree());
         Map           m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
@@ -820,12 +745,7 @@
         }
     }
 
-    /**
-     * Method testEquals
-     */
-
-    public void testEquals()
-    {
+    public void testEquals() {
         Map           m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
 
@@ -871,12 +791,7 @@
         assertEquals(m, m1);
     }
 
-    /**
-     * test hashCode() method
-     */
-
-    public void testHashCode()
-    {
+    public void testHashCode() {
         Map           m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
 
@@ -893,12 +808,7 @@
         assertTrue(m.hashCode() == m1.hashCode());
     }
 
-    /**
-     * test constructors
-     */
-
-    public void testConstructors()
-    {
+    public void testConstructors() {
         BinaryTree m = new BinaryTree();
 
         assertTrue(m.isEmpty());
@@ -959,7 +869,7 @@
         }
 
         // reject incompatible values
-        m2.put("2", new Integer(2));
+        m2.put("2", Integer.valueOf(2));
         try
         {
             m = new BinaryTree(m2);
@@ -971,7 +881,7 @@
 
         // reject incompatible keys
         m2.remove("2");
-        m2.put(new Integer(2), "bad key");
+        m2.put(Integer.valueOf(2), "bad key");
         try
         {
             m = new BinaryTree(m2);
@@ -995,12 +905,7 @@
         }
     }
 
-    /**
-     * test getKeyForValue() method
-     */
-
-    public void testGetKeyForValue()
-    {
+    public void testGetKeyForValue() {
         BinaryTree m = new BinaryTree();
 
         try
@@ -1044,12 +949,7 @@
         }
     }
 
-    /**
-     * test removeValue() method
-     */
-
-    public void testRemoveValue()
-    {
+    public void testRemoveValue() {
         BinaryTree    m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
 
@@ -1073,7 +973,7 @@
         catch (ClassCastException ignored)
         {
         }
-        assertNull(m.remove(new Integer(-1)));
+        assertNull(m.remove(Integer.valueOf(-1)));
         try
         {
             m.removeValue("foo");
@@ -1099,12 +999,7 @@
         assertTrue(m.isEmpty());
     }
 
-    /**
-     * test entrySetByValue() method
-     */
-
-    public void testEntrySetByValue()
-    {
+    public void testEntrySetByValue() {
         testEntrySetByValue(new BinaryTree());
         BinaryTree    m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
@@ -1178,12 +1073,7 @@
         }
     }
 
-    /**
-     * test keySetByValue() method
-     */
-
-    public void testKeySetByValue()
-    {
+    public void testKeySetByValue() {
         testKeySetByValue(new BinaryTree());
         BinaryTree    m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
@@ -1245,7 +1135,7 @@
         Collection c1 = new LinkedList();
         Collection c2 = new LinkedList();
 
-        c2.add(new Integer(-99));
+        c2.add(Integer.valueOf(-99));
         for (int k = 0; k < nodes.length; k++)
         {
             m.put(nodes[ k ].getKey(), nodes[ k ]);
@@ -1256,7 +1146,7 @@
         assertTrue(!m.keySetByValue().containsAll(c2));
         m  = new BinaryTree();
         c1 = new LinkedList();
-        c1.add(new Integer(-55));
+        c1.add(Integer.valueOf(-55));
         try
         {
             m.keySetByValue().addAll(c1);
@@ -1330,12 +1220,7 @@
         assertTrue(m.size() == 0);
     }
 
-    /**
-     * test valuesByValue() method
-     */
-
-    public void testValuesByValue()
-    {
+    public void testValuesByValue() {
         testValuesByValue(new BinaryTree());
         BinaryTree    m       = new BinaryTree();
         LocalTestNode nodes[] = makeLocalNodes();
@@ -1472,8 +1357,7 @@
     }
 
     /* ********** START helper methods ********** */
-    private void testKeySet(final Map m)
-    {
+    private static void testKeySet(final Map m) {
         Set s = m.keySet();
 
         assertEquals(m.size(), s.size());
@@ -1506,7 +1390,7 @@
         }
         for (int k = 0; k < m.size(); k++)
         {
-            assertTrue(s.contains(new Integer(k)));
+            assertTrue(s.contains(Integer.valueOf(k)));
         }
         int count = 0;
 
@@ -1699,8 +1583,7 @@
         assertTrue(s.hashCode() == hs.hashCode());
     }
 
-    private void testKeySetByValue(final BinaryTree m)
-    {
+    private static void testKeySetByValue(final BinaryTree m) {
         Set s = m.keySetByValue();
 
         assertEquals(m.size(), s.size());
@@ -1733,7 +1616,7 @@
         }
         for (int k = 0; k < m.size(); k++)
         {
-            assertTrue(s.contains(new Integer(k)));
+            assertTrue(s.contains(Integer.valueOf(k)));
         }
         int count = 0;
 
@@ -1922,8 +1805,7 @@
         assertTrue(s.hashCode() == hs.hashCode());
     }
 
-    private void testValues(Map m)
-    {
+    private static void testValues(Map m) {
         Collection s = m.values();
 
         assertEquals(m.size(), s.size());
@@ -2140,8 +2022,7 @@
         assertTrue(!hs.equals(s));
     }
 
-    private void testValuesByValue(BinaryTree m)
-    {
+    private static void testValuesByValue(BinaryTree m) {
         Collection s = m.valuesByValue();
 
         assertEquals(m.size(), s.size());
@@ -2325,8 +2206,7 @@
         assertTrue(!hs.equals(s));
     }
 
-    private void testEntrySet(Map m)
-    {
+    private static void testEntrySet(Map m) {
         Set s = m.entrySet();
 
         assertEquals(m.size(), s.size());
@@ -2539,8 +2419,7 @@
         assertTrue(s.hashCode() == hs.hashCode());
     }
 
-    private void testEntrySetByValue(BinaryTree m)
-    {
+    private static void testEntrySetByValue(BinaryTree m) {
         Set s = m.entrySetByValue();
 
         assertEquals(m.size(), s.size());
@@ -2763,17 +2642,4 @@
         }
         return nodes;
     }
-
-    /* **********  END  helper methods ********** */
-
-    /**
-     * Method main
-     *
-     * @param unused_args
-     */
-
-    public static void main(final String unused_args[])
-    {
-        junit.textui.TestRunner.run(TestBinaryTree.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/util/TestBitField.java b/src/testcases/org/apache/poi/util/TestBitField.java
index 26f6414..ef55ab7 100644
--- a/src/testcases/org/apache/poi/util/TestBitField.java
+++ b/src/testcases/org/apache/poi/util/TestBitField.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +14,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
@@ -27,66 +25,32 @@
  * @author Marc Johnson
  * @author Glen Stampoultzis (gstamp@iprimus.com.au)
  */
-
-public class TestBitField
-    extends TestCase
-{
+public final class TestBitField extends TestCase {
     private static BitField bf_multi  = BitFieldFactory.getInstance(0x3F80);
     private static BitField bf_single = BitFieldFactory.getInstance(0x4000);
 
-    /**
-     * Constructor TestBitField
-     *
-     * @param name
-     */
-
-    public TestBitField(String name)
-    {
-        super(name);
-    }
-
-    /**
-     * test the getValue() method
-     */
-
-    public void testGetValue()
-    {
+    public void testGetValue() {
         assertEquals(bf_multi.getValue(-1), 127);
         assertEquals(bf_multi.getValue(0), 0);
         assertEquals(bf_single.getValue(-1), 1);
         assertEquals(bf_single.getValue(0), 0);
     }
 
-    /**
-     * test the getShortValue() method
-     */
-
-    public void testGetShortValue()
-    {
+    public void testGetShortValue() {
         assertEquals(bf_multi.getShortValue(( short ) -1), ( short ) 127);
         assertEquals(bf_multi.getShortValue(( short ) 0), ( short ) 0);
         assertEquals(bf_single.getShortValue(( short ) -1), ( short ) 1);
         assertEquals(bf_single.getShortValue(( short ) 0), ( short ) 0);
     }
 
-    /**
-     * test the getRawValue() method
-     */
-
-    public void testGetRawValue()
-    {
+    public void testGetRawValue() {
         assertEquals(bf_multi.getRawValue(-1), 0x3F80);
         assertEquals(bf_multi.getRawValue(0), 0);
         assertEquals(bf_single.getRawValue(-1), 0x4000);
         assertEquals(bf_single.getRawValue(0), 0);
     }
 
-    /**
-     * test the getShortRawValue() method
-     */
-
-    public void testGetShortRawValue()
-    {
+    public void testGetShortRawValue() {
         assertEquals(bf_multi.getShortRawValue(( short ) -1),
                      ( short ) 0x3F80);
         assertEquals(bf_multi.getShortRawValue(( short ) 0), ( short ) 0);
@@ -95,12 +59,7 @@
         assertEquals(bf_single.getShortRawValue(( short ) 0), ( short ) 0);
     }
 
-    /**
-     * test the isSet() method
-     */
-
-    public void testIsSet()
-    {
+    public void testIsSet() {
         assertTrue(!bf_multi.isSet(0));
         for (int j = 0x80; j <= 0x3F80; j += 0x80)
         {
@@ -110,12 +69,7 @@
         assertTrue(bf_single.isSet(0x4000));
     }
 
-    /**
-     * test the isAllSet() method
-     */
-
-    public void testIsAllSet()
-    {
+    public void testIsAllSet() {
         for (int j = 0; j < 0x3F80; j += 0x80)
         {
             assertTrue(!bf_multi.isAllSet(j));
@@ -125,12 +79,7 @@
         assertTrue(bf_single.isAllSet(0x4000));
     }
 
-    /**
-     * test the setValue() method
-     */
-
-    public void testSetValue()
-    {
+    public void testSetValue() {
         for (int j = 0; j < 128; j++)
         {
             assertEquals(bf_multi.getValue(bf_multi.setValue(0, j)), j);
@@ -149,12 +98,7 @@
         assertEquals(bf_single.setValue(0x4000, 2), 0);
     }
 
-    /**
-     * test the setShortValue() method
-     */
-
-    public void testSetShortValue()
-    {
+    public void testSetShortValue() {
         for (int j = 0; j < 128; j++)
         {
             assertEquals(bf_multi
@@ -181,8 +125,7 @@
                      ( short ) 0);
     }
 
-    public void testByte()
-    {
+    public void testByte() {
         assertEquals(1, BitFieldFactory.getInstance(1).setByteBoolean(( byte ) 0, true));
         assertEquals(2, BitFieldFactory.getInstance(2).setByteBoolean(( byte ) 0, true));
         assertEquals(4, BitFieldFactory.getInstance(4).setByteBoolean(( byte ) 0, true));
@@ -208,64 +151,34 @@
         assertEquals(false, BitFieldFactory.getInstance(0x40).isSet(clearedBit));
     }
 
-    /**
-     * test the clear() method
-     */
-
-    public void testClear()
-    {
+    public void testClear() {
         assertEquals(bf_multi.clear(-1), 0xFFFFC07F);
         assertEquals(bf_single.clear(-1), 0xFFFFBFFF);
     }
 
-    /**
-     * test the clearShort() method
-     */
-
-    public void testClearShort()
-    {
+    public void testClearShort() {
         assertEquals(bf_multi.clearShort(( short ) -1), ( short ) 0xC07F);
         assertEquals(bf_single.clearShort(( short ) -1), ( short ) 0xBFFF);
     }
 
-    /**
-     * test the set() method
-     */
-
-    public void testSet()
-    {
+    public void testSet() {
         assertEquals(bf_multi.set(0), 0x3F80);
         assertEquals(bf_single.set(0), 0x4000);
     }
 
-    /**
-     * test the setShort() method
-     */
-
-    public void testSetShort()
-    {
+    public void testSetShort() {
         assertEquals(bf_multi.setShort(( short ) 0), ( short ) 0x3F80);
         assertEquals(bf_single.setShort(( short ) 0), ( short ) 0x4000);
     }
 
-    /**
-     * test the setBoolean() method
-     */
-
-    public void testSetBoolean()
-    {
+    public void testSetBoolean() {
         assertEquals(bf_multi.set(0), bf_multi.setBoolean(0, true));
         assertEquals(bf_single.set(0), bf_single.setBoolean(0, true));
         assertEquals(bf_multi.clear(-1), bf_multi.setBoolean(-1, false));
         assertEquals(bf_single.clear(-1), bf_single.setBoolean(-1, false));
     }
 
-    /**
-     * test the setShortBoolean() method
-     */
-
-    public void testSetShortBoolean()
-    {
+    public void testSetShortBoolean() {
         assertEquals(bf_multi.setShort(( short ) 0),
                      bf_multi.setShortBoolean(( short ) 0, true));
         assertEquals(bf_single.setShort(( short ) 0),
@@ -275,16 +188,4 @@
         assertEquals(bf_single.clearShort(( short ) -1),
                      bf_single.setShortBoolean(( short ) -1, false));
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println("Testing util.BitField functionality");
-        junit.textui.TestRunner.run(TestBitField.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/util/TestByteField.java b/src/testcases/org/apache/poi/util/TestByteField.java
index 2afeb06..2c3c499 100644
--- a/src/testcases/org/apache/poi/util/TestByteField.java
+++ b/src/testcases/org/apache/poi/util/TestByteField.java
@@ -15,46 +15,27 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
-import junit.framework.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
 
-import java.io.*;
+import junit.framework.TestCase;
 
 /**
  * Title:        Unit test for ByteField class
  * Description:  Unit test for ByteField class
  * @author       Marc Johnson (mjohnson at apache dot org)
  */
+public final class TestByteField extends TestCase {
 
-public class TestByteField
-    extends TestCase
-{
-
-    /**
-     * Constructor
-     *
-     * @param name
-     */
-
-    public TestByteField(String name)
-    {
-        super(name);
-    }
-
-    static private final byte[] _test_array =
+    private static final byte[] _test_array =
     {
         Byte.MIN_VALUE, ( byte ) -1, ( byte ) 0, ( byte ) 1, Byte.MAX_VALUE
     };
 
-    /**
-     * Test constructors.
-     */
-
-    public void testConstructors()
-    {
+    public void testConstructors() {
         try
         {
             new ByteField(-1);
@@ -114,12 +95,7 @@
         }
     }
 
-    /**
-     * Test set() methods
-     */
-
-    public void testSet()
-    {
+    public void testSet() {
         ByteField field = new ByteField(0);
         byte[]    array = new byte[ 1 ];
 
@@ -134,12 +110,7 @@
         }
     }
 
-    /**
-     * Test readFromBytes
-     */
-
-    public void testReadFromBytes()
-    {
+    public void testReadFromBytes() {
         ByteField field = new ByteField(1);
         byte[]    array = new byte[ 1 ];
 
@@ -162,15 +133,7 @@
         }
     }
 
-    /**
-     * Test readFromStream
-     *
-     * @exception IOException
-     */
-
-    public void testReadFromStream()
-        throws IOException
-    {
+    public void testReadFromStream() throws IOException {
         ByteField field  = new ByteField(0);
         byte[]    buffer = new byte[ _test_array.length ];
 
@@ -184,12 +147,7 @@
         }
     }
 
-    /**
-     * test writeToBytes
-     */
-
-    public void testWriteToBytes()
-    {
+    public void testWriteToBytes() {
         ByteField field = new ByteField(0);
         byte[]    array = new byte[ 1 ];
 
@@ -200,16 +158,4 @@
             assertEquals("testing ", _test_array[ j ], array[ 0 ]);
         }
     }
-
-    /**
-     * Main
-     *
-     * @param ignored_args
-     */
-
-    public static void main(String [] ignored_args)
-    {
-        System.out.println("Testing util.ByteField functionality");
-        junit.textui.TestRunner.run(TestByteField.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/util/TestIntList.java b/src/testcases/org/apache/poi/util/TestIntList.java
index c67377e..1037c2e 100644
--- a/src/testcases/org/apache/poi/util/TestIntList.java
+++ b/src/testcases/org/apache/poi/util/TestIntList.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,39 +14,19 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
-import junit.framework.*;
+import junit.framework.TestCase;
 
 /**
  * Class to test IntList
  *
  * @author Marc Johnson
  */
+public final class TestIntList extends TestCase {
 
-public class TestIntList
-    extends TestCase
-{
-
-    /**
-     * Constructor TestIntList
-     *
-     * @param name
-     */
-
-    public TestIntList(String name)
-    {
-        super(name);
-    }
-
-    /**
-     * test the various IntListconstructors
-     */
-
-    public void testConstructors()
-    {
+    public void testConstructors() {
         IntList list = new IntList();
 
         assertTrue(list.isEmpty());
@@ -61,12 +40,7 @@
         assertTrue(list3.isEmpty());
     }
 
-    /**
-     * test the add method
-     */
-
-    public void testAdd()
-    {
+    public void testAdd() {
         IntList list      = new IntList();
         int[]   testArray =
         {
@@ -144,12 +118,7 @@
         }
     }
 
-    /**
-     * test the addAll method
-     */
-
-    public void testAddAll()
-    {
+    public void testAddAll() {
         IntList list = new IntList();
 
         for (int j = 0; j < 5; j++)
@@ -223,12 +192,7 @@
         assertEquals(list.get(4), empty.get(14));
     }
 
-    /**
-     * test the clear method
-     */
-
-    public void testClear()
-    {
+    public void testClear() {
         IntList list = new IntList();
 
         for (int j = 0; j < 500; j++)
@@ -249,12 +213,7 @@
         }
     }
 
-    /**
-     * test the contains method
-     */
-
-    public void testContains()
-    {
+    public void testContains() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j += 2)
@@ -274,12 +233,7 @@
         }
     }
 
-    /**
-     * test the containsAll method
-     */
-
-    public void testContainsAll()
-    {
+    public void testContainsAll() {
         IntList list = new IntList();
 
         assertTrue(list.containsAll(list));
@@ -299,12 +253,7 @@
         assertTrue(!list.containsAll(list2));
     }
 
-    /**
-     * test the equals method
-     */
-
-    public void testEquals()
-    {
+    public void testEquals() {
         IntList list = new IntList();
 
         assertEquals(list, list);
@@ -328,12 +277,7 @@
         assertTrue(!list2.equals(list));
     }
 
-    /**
-     * test the get method
-     */
-
-    public void testGet()
-    {
+    public void testGet() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j++)
@@ -360,12 +304,7 @@
         }
     }
 
-    /**
-     * test the indexOf method
-     */
-
-    public void testIndexOf()
-    {
+    public void testIndexOf() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j++)
@@ -385,12 +324,7 @@
         }
     }
 
-    /**
-     * test the isEmpty method
-     */
-
-    public void testIsEmpty()
-    {
+    public void testIsEmpty() {
         IntList list1 = new IntList();
         IntList list2 = new IntList(1000);
         IntList list3 = new IntList(list1);
@@ -412,12 +346,7 @@
         assertTrue(list3.isEmpty());
     }
 
-    /**
-     * test the lastIndexOf method
-     */
-
-    public void testLastIndexOf()
-    {
+    public void testLastIndexOf() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j++)
@@ -437,12 +366,7 @@
         }
     }
 
-    /**
-     * test the remove method
-     */
-
-    public void testRemove()
-    {
+    public void testRemove() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j++)
@@ -475,12 +399,7 @@
         }
     }
 
-    /**
-     * test the removeValue method
-     */
-
-    public void testRemoveValue()
-    {
+    public void testRemoveValue() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j++)
@@ -498,12 +417,7 @@
         }
     }
 
-    /**
-     * test the removeAll method
-     */
-
-    public void testRemoveAll()
-    {
+    public void testRemoveAll() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j++)
@@ -535,12 +449,7 @@
         assertTrue(listCopy.isEmpty());
     }
 
-    /**
-     * test the retainAll method
-     */
-
-    public void testRetainAll()
-    {
+    public void testRetainAll() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j++)
@@ -572,12 +481,7 @@
         assertTrue(listCopy.isEmpty());
     }
 
-    /**
-     * test the set method
-     */
-
-    public void testSet()
-    {
+    public void testSet() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j++)
@@ -605,12 +509,7 @@
         }
     }
 
-    /**
-     * test the size method
-     */
-
-    public void testSize()
-    {
+    public void testSize() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j++)
@@ -627,12 +526,7 @@
         }
     }
 
-    /**
-     * test the toArray method
-     */
-
-    public void testToArray()
-    {
+    public void testToArray() {
         IntList list = new IntList();
 
         for (int j = 0; j < 1000; j++)
@@ -672,16 +566,4 @@
             assertEquals(a5[ j ], list.get(j));
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param unused_args
-     */
-
-    public static void main(String [] unused_args)
-    {
-        System.out.println("Testing util.IntList functionality");
-        junit.textui.TestRunner.run(TestIntList.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/util/TestIntegerField.java b/src/testcases/org/apache/poi/util/TestIntegerField.java
index 861f411..a26f09c 100644
--- a/src/testcases/org/apache/poi/util/TestIntegerField.java
+++ b/src/testcases/org/apache/poi/util/TestIntegerField.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,46 +14,27 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
-import junit.framework.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
 
-import java.io.*;
+import junit.framework.TestCase;
 
 /**
  * Test IntegerField code
  *
  * @author  Marc Johnson (mjohnson at apache dot org)
  */
+public final class TestIntegerField extends TestCase {
 
-public class TestIntegerField
-    extends TestCase
-{
-
-    /**
-     * Constructor
-     *
-     * @param name
-     */
-
-    public TestIntegerField(String name)
-    {
-        super(name);
-    }
-
-    static private final int[] _test_array =
+    private static final int[] _test_array =
     {
         Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE
     };
 
-    /**
-     * Test constructors.
-     */
-
-    public void testConstructors()
-    {
+    public void testConstructors() {
         try
         {
             new IntegerField(-1);
@@ -117,12 +97,7 @@
         }
     }
 
-    /**
-     * Test set() methods
-     */
-
-    public void testSet()
-    {
+    public void testSet() {
         IntegerField field = new IntegerField(0);
         byte[]       array = new byte[ 4 ];
 
@@ -147,12 +122,7 @@
         }
     }
 
-    /**
-     * Test readFromBytes
-     */
-
-    public void testReadFromBytes()
-    {
+    public void testReadFromBytes() {
         IntegerField field = new IntegerField(1);
         byte[]       array = new byte[ 4 ];
 
@@ -178,15 +148,7 @@
         }
     }
 
-    /**
-     * Test readFromStream
-     *
-     * @exception IOException
-     */
-
-    public void testReadFromStream()
-        throws IOException
-    {
+    public void testReadFromStream() throws IOException {
         IntegerField field  = new IntegerField(0);
         byte[]       buffer = new byte[ _test_array.length * 4 ];
 
@@ -206,12 +168,7 @@
         }
     }
 
-    /**
-     * test writeToBytes
-     */
-
-    public void testWriteToBytes()
-    {
+    public void testWriteToBytes() {
         IntegerField field = new IntegerField(0);
         byte[]       array = new byte[ 4 ];
 
@@ -228,16 +185,4 @@
             assertEquals("testing ", _test_array[ j ], val);
         }
     }
-
-    /**
-     * Main
-     *
-     * @param args
-     */
-
-    public static void main(String [] args)
-    {
-        System.out.println("Testing util.IntegerField functionality");
-        junit.textui.TestRunner.run(TestIntegerField.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/util/TestLittleEndian.java b/src/testcases/org/apache/poi/util/TestLittleEndian.java
index 0ffcd18..4313e34 100644
--- a/src/testcases/org/apache/poi/util/TestLittleEndian.java
+++ b/src/testcases/org/apache/poi/util/TestLittleEndian.java
@@ -84,10 +84,8 @@
     {
         56, 50, -113, -4, -63, -64, -13, 63, 76, -32, -42, -35, 60, -43, 3, 64
     };
-    private static final byte[]   _nan_double_array =
-    {
-        (byte)0x00, (byte)0x00, (byte)0x3C, (byte)0x00, (byte)0x20, (byte)0x04, (byte)0xFF, (byte)0xFF
-    };
+	/** 0x7ff8000000000000 encoded in little endian order */
+	private static final byte[] _nan_double_array = HexRead.readFromString("00 00 00 00 00 00 F8 7F");
     private static final double[] _doubles      =
     {
         1.23456, 2.47912, Double.NaN
@@ -97,13 +95,13 @@
      * test the getDouble() method
      */
     public void testGetDouble() {
-        assertEquals(_doubles[0], LittleEndian.getDouble(_double_array), 0.000001 );
+        assertEquals(_doubles[0], LittleEndian.getDouble(_double_array, 0), 0.000001 );
         assertEquals(_doubles[1], LittleEndian.getDouble( _double_array, LittleEndian.DOUBLE_SIZE), 0.000001);
-        assertTrue(Double.isNaN(LittleEndian.getDouble(_nan_double_array)));
+        assertTrue(Double.isNaN(LittleEndian.getDouble(_nan_double_array, 0)));
 
-        double nan = LittleEndian.getDouble(_nan_double_array);
+        double nan = LittleEndian.getDouble(_nan_double_array, 0);
         byte[] data = new byte[8];
-        LittleEndian.putDouble(data, nan);
+        LittleEndian.putDouble(data, 0, nan);
         for ( int i = 0; i < data.length; i++ ) {
             assertEquals(data[i], _nan_double_array[i]);
         }
@@ -144,7 +142,7 @@
             (byte) 0x02,
         };
 
-        assertEquals(0xFFFFFFFFFFFFFF01L, LittleEndian.getLong(testdata));
+        assertEquals(0xFFFFFFFFFFFFFF01L, LittleEndian.getLong(testdata, 0));
         assertEquals(0x02FFFFFFFFFFFFFFL, LittleEndian.getLong(testdata, 1));
     }
 
@@ -194,7 +192,7 @@
     public void testPutDouble() {
         byte[] received = new byte[ LittleEndian.DOUBLE_SIZE + 1 ];
 
-        LittleEndian.putDouble(received, _doubles[0]);
+        LittleEndian.putDouble(received, 0, _doubles[0]);
         assertTrue(compareByteArrays(received, _double_array, 0, LittleEndian.DOUBLE_SIZE));
         LittleEndian.putDouble(received, 1, _doubles[1]);
         byte[] expected = new byte[ LittleEndian.DOUBLE_SIZE + 1 ];
@@ -224,7 +222,7 @@
 
         long testdata0 = 0xFFFFFFFFFFFFFF01L;
         long testdata1 = 0x02FFFFFFFFFFFFFFL;
-        LittleEndian.putLong(received, testdata0);
+        LittleEndian.putLong(received, 0, testdata0);
         assertTrue(compareByteArrays(received, expected, 0, LittleEndian.LONG_SIZE));
         LittleEndian.putLong(received, 1, testdata1);
         assertTrue(compareByteArrays(received, expected, 1, LittleEndian.LONG_SIZE));
diff --git a/src/testcases/org/apache/poi/util/TestLittleEndianStreams.java b/src/testcases/org/apache/poi/util/TestLittleEndianStreams.java
new file mode 100644
index 0000000..26f9b4c
--- /dev/null
+++ b/src/testcases/org/apache/poi/util/TestLittleEndianStreams.java
@@ -0,0 +1,80 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+package org.apache.poi.util;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.util.Arrays;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
+
+/**
+ * Class to test {@link LittleEndianInputStream} and {@link LittleEndianOutputStream}
+ *
+ * @author Josh Micich
+ */
+public final class TestLittleEndianStreams extends TestCase {
+
+	public void testRead() {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		LittleEndianOutput leo = new LittleEndianOutputStream(baos);
+		leo.writeInt(12345678);
+		leo.writeShort(12345);
+		leo.writeByte(123);
+		leo.writeShort(40000);
+		leo.writeByte(200);
+		leo.writeLong(1234567890123456789L);
+		leo.writeDouble(123.456);
+
+		LittleEndianInput lei = new LittleEndianInputStream(new ByteArrayInputStream(baos.toByteArray()));
+
+		assertEquals(12345678, lei.readInt());
+		assertEquals(12345, lei.readShort());
+		assertEquals(123, lei.readByte());
+		assertEquals(40000, lei.readUShort());
+		assertEquals(200, lei.readUByte());
+		assertEquals(1234567890123456789L, lei.readLong());
+		assertEquals(123.456, lei.readDouble(), 0.0);
+	}
+
+	/**
+	 * Up until svn r836101 {@link LittleEndianByteArrayInputStream#readFully(byte[], int, int)}
+	 * had an error which resulted in the data being read and written back to the source byte
+	 * array.
+	 */
+	public void testReadFully() {
+		byte[] srcBuf = HexRead.readFromString("99 88 77 66 55 44 33");
+		LittleEndianInput lei = new LittleEndianByteArrayInputStream(srcBuf);
+
+		// do initial read to increment the read index beyond zero
+		assertEquals(0x8899, lei.readUShort());
+
+		byte[] actBuf = new byte[4];
+		lei.readFully(actBuf);
+
+		if (actBuf[0] == 0x00 && srcBuf[0] == 0x77 && srcBuf[3] == 0x44) {
+			throw new AssertionFailedError("Identified bug in readFully() - source buffer was modified");
+		}
+
+		byte[] expBuf = HexRead.readFromString("77 66 55 44");
+		assertTrue(Arrays.equals(actBuf, expBuf));
+		assertEquals(0x33, lei.readUByte());
+		assertEquals(0, lei.available());
+	}
+}
diff --git a/src/testcases/org/apache/poi/util/TestPOILogFactory.java b/src/testcases/org/apache/poi/util/TestPOILogFactory.java
index 27fddab..115ec73 100644
--- a/src/testcases/org/apache/poi/util/TestPOILogFactory.java
+++ b/src/testcases/org/apache/poi/util/TestPOILogFactory.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,43 +14,23 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
 import junit.framework.TestCase;
 
-import java.io.IOException;
-
 /**
  * @author Marc Johnson (mjohnson at apache dot org)
  * @author Glen Stampoultzis (glens at apache.org)
  * @author Nicola Ken Barozzi (nicolaken at apache.org)
  */
+public final class TestPOILogFactory extends TestCase {
 
-public class TestPOILogFactory
-        extends TestCase
-{
-    /**
-     * Creates new TestPOILogFactory
-     *
-     * @param name
-     */
-
-    public TestPOILogFactory( String name )
-    {
-        super( name );
-    }
 
     /**
      * test log creation
-     *
-     * @exception IOException
      */
-
-    public void testLog()
-            throws IOException
-    {
+    public void testLog() {
         //NKB Testing only that logging classes use gives no exception
         //    Since logging can be disabled, no checking of logging
         //    output is done.
@@ -72,16 +51,4 @@
         l2.log( POILogger.DEBUG, "testing cat org.apache.poi.hdf.*:DEBUG" );
 
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param ignored_args
-     */
-
-    public static void main( String[] ignored_args )
-    {
-        System.out.println( "Testing basic util.POILogFactory functionality" );
-        junit.textui.TestRunner.run( TestPOILogFactory.class );
-    }
 }
diff --git a/src/testcases/org/apache/poi/util/TestPOILogger.java b/src/testcases/org/apache/poi/util/TestPOILogger.java
index 6dfa1d7..a3d34fa 100644
--- a/src/testcases/org/apache/poi/util/TestPOILogger.java
+++ b/src/testcases/org/apache/poi/util/TestPOILogger.java
@@ -15,7 +15,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
@@ -28,39 +27,20 @@
  * @author Marc Johnson (mjohnson at apache dot org)
  * @author Nicola Ken Barozzi (nicolaken at apache.org)
  */
-
-public class TestPOILogger
-        extends TestCase
-{
-    /**
-     * Constructor TestPOILogger
-     *
-     *
-     * @param s
-     *
-     */
-
-    public TestPOILogger( String s )
-    {
-        super( s );
-    }
+public final class TestPOILogger extends TestCase {
 
     /**
      * Test different types of log output.
-     *
-     * @exception Exception
      */
-    public void testVariousLogTypes()
-            throws Exception
-    {
+    public void testVariousLogTypes() {
         //NKB Testing only that logging classes use gives no exception
         //    Since logging can be disabled, no checking of logging
         //    output is done.
 
         POILogger log = POILogFactory.getLogger( "foo" );
 
-        log.log( POILogger.WARN, "Test = ", new Integer( 1 ) );
-        log.logFormatted( POILogger.ERROR, "Test param 1 = %, param 2 = %", "2", new Integer( 3 ) );
+        log.log( POILogger.WARN, "Test = ", Integer.valueOf( 1 ) );
+        log.logFormatted( POILogger.ERROR, "Test param 1 = %, param 2 = %", "2", Integer.valueOf( 3 ) );
         log.logFormatted( POILogger.ERROR, "Test param 1 = %, param 2 = %", new int[]{4, 5} );
         log.logFormatted( POILogger.ERROR,
                 "Test param 1 = %1.1, param 2 = %0.1", new double[]{4, 5.23} );
diff --git a/src/testcases/org/apache/poi/util/TestShortField.java b/src/testcases/org/apache/poi/util/TestShortField.java
index 999a735..dd93c1a 100644
--- a/src/testcases/org/apache/poi/util/TestShortField.java
+++ b/src/testcases/org/apache/poi/util/TestShortField.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +14,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
@@ -28,34 +26,15 @@
  *
  * @author  Marc Johnson (mjohnson at apache dot org)
  */
+public final class TestShortField extends TestCase {
 
-public class TestShortField
-    extends TestCase
-{
-
-    /**
-     * Constructor
-     *
-     * @param name
-     */
-
-    public TestShortField(String name)
-    {
-        super(name);
-    }
-
-    static private final short[] _test_array =
+    private static final short[] _test_array =
     {
         Short.MIN_VALUE, ( short ) -1, ( short ) 0, ( short ) 1,
         Short.MAX_VALUE
     };
 
-    /**
-     * Test constructors.
-     */
-
-    public void testConstructors()
-    {
+    public void testConstructors() {
         try
         {
             new ShortField(-1);
@@ -116,12 +95,7 @@
         }
     }
 
-    /**
-     * Test set() methods
-     */
-
-    public void testSet()
-    {
+    public void testSet() {
         ShortField field = new ShortField(0);
         byte[]     array = new byte[ 2 ];
 
@@ -140,12 +114,7 @@
         }
     }
 
-    /**
-     * Test readFromBytes
-     */
-
-    public void testReadFromBytes()
-    {
+    public void testReadFromBytes() {
         ShortField field = new ShortField(1);
         byte[]     array = new byte[ 2 ];
 
@@ -169,15 +138,7 @@
         }
     }
 
-    /**
-     * Test readFromStream
-     *
-     * @exception IOException
-     */
-
-    public void testReadFromStream()
-        throws IOException
-    {
+    public void testReadFromStream() throws IOException {
         ShortField field  = new ShortField(0);
         byte[]     buffer = new byte[ _test_array.length * 2 ];
 
@@ -195,12 +156,7 @@
         }
     }
 
-    /**
-     * test writeToBytes
-     */
-
-    public void testWriteToBytes()
-    {
+    public void testWriteToBytes() {
         ShortField field = new ShortField(0);
         byte[]     array = new byte[ 2 ];
 
@@ -215,16 +171,4 @@
             assertEquals("testing ", _test_array[ j ], val);
         }
     }
-
-    /**
-     * Main
-     *
-     * @param args
-     */
-
-    public static void main(String [] args)
-    {
-        System.out.println("Testing util.ShortField functionality");
-        junit.textui.TestRunner.run(TestShortField.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/util/TestShortList.java b/src/testcases/org/apache/poi/util/TestShortList.java
index aeae276..1605b51 100644
--- a/src/testcases/org/apache/poi/util/TestShortList.java
+++ b/src/testcases/org/apache/poi/util/TestShortList.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,39 +14,19 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
 
 package org.apache.poi.util;
 
-import junit.framework.*;
+import junit.framework.TestCase;
 
 /**
  * Class to test ShortList
  *
  * @author Marc Johnson
  */
+public final class TestShortList extends TestCase {
 
-public class TestShortList
-    extends TestCase
-{
-
-    /**
-     * Constructor TestShortList
-     *
-     * @param name
-     */
-
-    public TestShortList(String name)
-    {
-        super(name);
-    }
-
-    /**
-     * test the various ShortListconstructors
-     */
-
-    public void testConstructors()
-    {
+    public void testConstructors() {
         ShortList list = new ShortList();
 
         assertTrue(list.isEmpty());
@@ -61,12 +40,7 @@
         assertTrue(list3.isEmpty());
     }
 
-    /**
-     * test the add method
-     */
-
-    public void testAdd()
-    {
+    public void testAdd() {
         ShortList list      = new ShortList();
         short[]   testArray =
         {
@@ -144,12 +118,7 @@
         }
     }
 
-    /**
-     * test the addAll method
-     */
-
-    public void testAddAll()
-    {
+    public void testAddAll() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 5; j++)
@@ -223,12 +192,7 @@
         assertEquals(list.get(4), empty.get(14));
     }
 
-    /**
-     * test the clear method
-     */
-
-    public void testClear()
-    {
+    public void testClear() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 500; j++)
@@ -249,12 +213,7 @@
         }
     }
 
-    /**
-     * test the contains method
-     */
-
-    public void testContains()
-    {
+    public void testContains() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j += 2)
@@ -274,12 +233,7 @@
         }
     }
 
-    /**
-     * test the containsAll method
-     */
-
-    public void testContainsAll()
-    {
+    public void testContainsAll() {
         ShortList list = new ShortList();
 
         assertTrue(list.containsAll(list));
@@ -299,12 +253,7 @@
         assertTrue(!list.containsAll(list2));
     }
 
-    /**
-     * test the equals method
-     */
-
-    public void testEquals()
-    {
+    public void testEquals() {
         ShortList list = new ShortList();
 
         assertEquals(list, list);
@@ -328,12 +277,7 @@
         assertTrue(!list2.equals(list));
     }
 
-    /**
-     * test the get method
-     */
-
-    public void testGet()
-    {
+    public void testGet() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j++)
@@ -360,12 +304,7 @@
         }
     }
 
-    /**
-     * test the indexOf method
-     */
-
-    public void testIndexOf()
-    {
+    public void testIndexOf() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j++)
@@ -385,12 +324,7 @@
         }
     }
 
-    /**
-     * test the isEmpty method
-     */
-
-    public void testIsEmpty()
-    {
+    public void testIsEmpty() {
         ShortList list1 = new ShortList();
         ShortList list2 = new ShortList(1000);
         ShortList list3 = new ShortList(list1);
@@ -412,12 +346,7 @@
         assertTrue(list3.isEmpty());
     }
 
-    /**
-     * test the lastIndexOf method
-     */
-
-    public void testLastIndexOf()
-    {
+    public void testLastIndexOf() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j++)
@@ -437,12 +366,7 @@
         }
     }
 
-    /**
-     * test the remove method
-     */
-
-    public void testRemove()
-    {
+    public void testRemove() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j++)
@@ -476,12 +400,7 @@
         }
     }
 
-    /**
-     * test the removeValue method
-     */
-
-    public void testRemoveValue()
-    {
+    public void testRemoveValue() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j++)
@@ -499,12 +418,7 @@
         }
     }
 
-    /**
-     * test the removeAll method
-     */
-
-    public void testRemoveAll()
-    {
+    public void testRemoveAll() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j++)
@@ -536,12 +450,7 @@
         assertTrue(listCopy.isEmpty());
     }
 
-    /**
-     * test the retainAll method
-     */
-
-    public void testRetainAll()
-    {
+    public void testRetainAll() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j++)
@@ -573,12 +482,7 @@
         assertTrue(listCopy.isEmpty());
     }
 
-    /**
-     * test the set method
-     */
-
-    public void testSet()
-    {
+    public void testSet() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j++)
@@ -606,12 +510,7 @@
         }
     }
 
-    /**
-     * test the size method
-     */
-
-    public void testSize()
-    {
+    public void testSize() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j++)
@@ -628,12 +527,7 @@
         }
     }
 
-    /**
-     * test the toArray method
-     */
-
-    public void testToArray()
-    {
+    public void testToArray() {
         ShortList list = new ShortList();
 
         for (short j = 0; j < 1000; j++)
@@ -673,16 +567,4 @@
             assertEquals(a5[ j ], list.get(j));
         }
     }
-
-    /**
-     * main method to run the unit tests
-     *
-     * @param unused_args
-     */
-
-    public static void main(String [] unused_args)
-    {
-        System.out.println("Testing util.ShortList functionality");
-        junit.textui.TestRunner.run(TestShortList.class);
-    }
 }
diff --git a/src/testcases/org/apache/poi/util/TestStringUtil.java b/src/testcases/org/apache/poi/util/TestStringUtil.java
index b22439c..4f85929 100644
--- a/src/testcases/org/apache/poi/util/TestStringUtil.java
+++ b/src/testcases/org/apache/poi/util/TestStringUtil.java
@@ -1,4 +1,3 @@
-
 /* ====================================================================
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
@@ -15,13 +14,16 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 ==================================================================== */
-        
+
 package org.apache.poi.util;
 
-import junit.framework.*;
-
+import java.io.UnsupportedEncodingException;
 import java.text.NumberFormat;
 
+import org.apache.poi.util.StringUtil.StringsIterator;
+
+import junit.framework.TestCase;
+
 /**
  * Unit test for StringUtil
  *
@@ -29,62 +31,12 @@
  * @author  Glen Stampoultzis (glens at apache.org)
  * @author  Sergei Kozello (sergeikozello at mail.ru)
  */
-public class TestStringUtil
-        extends TestCase
-{
-    /**
-     * Creates new TestStringUtil
-     *
-     * @param name
-     */
-    public TestStringUtil( String name )
-    {
-        super( name );
-    }
-
-    /**
-     * test simple form of getFromUnicode
-     */
-    public void testSimpleGetFromUnicode()
-    {
-        byte[] test_data = new byte[32];
-        int index = 0;
-
-        for ( int k = 0; k < 16; k++ )
-        {
-            test_data[index++] = (byte) 0;
-            test_data[index++] = (byte) ( 'a' + k );
-        }
-
-        assertEquals( "abcdefghijklmnop",
-                StringUtil.getFromUnicodeBE( test_data ) );
-    }
-
-    /**
-     * test simple form of getFromUnicode with symbols with code below and more 127
-     */
-    public void testGetFromUnicodeSymbolsWithCodesMoreThan127()
-    {
-        byte[] test_data = new byte[]{0x04, 0x22,
-                                      0x04, 0x35,
-                                      0x04, 0x41,
-                                      0x04, 0x42,
-                                      0x00, 0x20,
-                                      0x00, 0x74,
-                                      0x00, 0x65,
-                                      0x00, 0x73,
-                                      0x00, 0x74,
-        };
-
-        assertEquals( "\u0422\u0435\u0441\u0442 test",
-                StringUtil.getFromUnicodeBE( test_data ) );
-    }
+public final class TestStringUtil extends TestCase {
 
     /**
      * test getFromUnicodeHigh for symbols with code below and more 127
      */
-    public void testGetFromUnicodeHighSymbolsWithCodesMoreThan127()
-    {
+    public void testGetFromUnicodeHighSymbolsWithCodesMoreThan127() {
         byte[] test_data = new byte[]{0x22, 0x04,
                                       0x35, 0x04,
                                       0x41, 0x04,
@@ -101,68 +53,7 @@
                 StringUtil.getFromUnicodeLE( test_data ) );
     }
 
-    /**
-     * Test more complex form of getFromUnicode
-     */
-    public void testComplexGetFromUnicode()
-    {
-        byte[] test_data = new byte[32];
-        int index = 0;
-        for ( int k = 0; k < 16; k++ )
-        {
-            test_data[index++] = (byte) 0;
-            test_data[index++] = (byte) ( 'a' + k );
-        }
-        assertEquals( "abcdefghijklmno",
-                StringUtil.getFromUnicodeBE( test_data, 0, 15 ) );
-        assertEquals( "bcdefghijklmnop",
-                StringUtil.getFromUnicodeBE( test_data, 2, 15 ) );
-        try
-        {
-            StringUtil.getFromUnicodeBE( test_data, -1, 16 );
-            fail( "Should have caught ArrayIndexOutOfBoundsException" );
-        }
-        catch ( ArrayIndexOutOfBoundsException ignored )
-        {
-            // as expected
-        }
-
-        try
-        {
-            StringUtil.getFromUnicodeBE( test_data, 32, 16 );
-            fail( "Should have caught ArrayIndexOutOfBoundsException" );
-        }
-        catch ( ArrayIndexOutOfBoundsException ignored )
-        {
-            // as expected
-        }
-
-        try
-        {
-            StringUtil.getFromUnicodeBE( test_data, 1, 16 );
-            fail( "Should have caught IllegalArgumentException" );
-        }
-        catch ( IllegalArgumentException ignored )
-        {
-            // as expected
-        }
-
-        try
-        {
-            StringUtil.getFromUnicodeBE( test_data, 1, -1 );
-            fail( "Should have caught IllegalArgumentException" );
-        }
-        catch ( IllegalArgumentException ignored )
-        {
-            // as expected
-        }
-    }
-
-    /**
-     * Test putCompressedUnicode
-     */
-    public void testPutCompressedUnicode() throws Exception
-    {
+    public void testPutCompressedUnicode() {
         byte[] output = new byte[100];
         byte[] expected_output =
                 {
@@ -170,7 +61,12 @@
                     (byte) 'o', (byte) ' ', (byte) 'W', (byte) 'o',
                     (byte) 'r', (byte) 'l', (byte) 'd', (byte) 0xAE
                 };
-        String input = new String( expected_output, StringUtil.getPreferredEncoding() );
+        String input;
+        try {
+            input = new String( expected_output, StringUtil.getPreferredEncoding() );
+        } catch (UnsupportedEncodingException e) {
+            throw new RuntimeException(e);
+        }
 
         StringUtil.putCompressedUnicode( input, output, 0 );
         for ( int j = 0; j < expected_output.length; j++ )
@@ -197,11 +93,7 @@
         }
     }
 
-    /**
-     * Test putUncompressedUnicode
-     */
-    public void testPutUncompressedUnicode()
-    {
+    public void testPutUncompressedUnicode() {
         byte[] output = new byte[100];
         String input = "Hello World";
         byte[] expected_output =
@@ -238,88 +130,73 @@
         }
     }
 
+    public void testFormat() {
 
-    public void testFormat()
-            throws Exception
-    {
-        assertEquals( "This is a test " + fmt( 1.2345, 2, 2 ),
-                StringUtil.format( "This is a test %2.2", new Object[]
-                {
-                    new Double( 1.2345 )
-                } ) );
-        assertEquals( "This is a test " + fmt( 1.2345, -1, 3 ),
-                StringUtil.format( "This is a test %.3", new Object[]
-                {
-                    new Double( 1.2345 )
-                } ) );
-        assertEquals( "This is a great test " + fmt( 1.2345, -1, 3 ),
-                StringUtil.format( "This is a % test %.3", new Object[]
-                {
-                    "great", new Double( 1.2345 )
-                } ) );
-        assertEquals( "This is a test 1",
-                StringUtil.format( "This is a test %", new Object[]
-                {
-                    new Integer( 1 )
-                } ) );
-        assertEquals( "This is a test 1",
-                StringUtil.format( "This is a test %", new Object[]
-                {
-                    new Integer( 1 ), new Integer( 1 )
-                } ) );
-        assertEquals( "This is a test 1.x",
-                StringUtil.format( "This is a test %1.x", new Object[]
-                {
-                    new Integer( 1 )
-                } ) );
-        assertEquals( "This is a test ?missing data?1.x",
-                StringUtil.format( "This is a test %1.x", new Object[]
-                {
-                } ) );
-        assertEquals( "This is a test %1.x",
-                StringUtil.format( "This is a test \\%1.x", new Object[]
-                {
-                } ) );
+        confirm("This is a test " + fmt(1.2345, 2, 2), "This is a test %2.2", new Double(1.2345));
+        confirm("This is a test " + fmt(1.2345, -1, 3), "This is a test %.3", new Double(1.2345));
+        confirm("This is a great test " + fmt(1.2345, -1, 3),
+                "This is a % test %.3", "great", new Double(1.2345));
+        confirm("This is a test 1", "This is a test %", Integer.valueOf(1));
+        confirm("This is a test 1", "This is a test %", Integer.valueOf(1), Integer.valueOf(1));
+        confirm("This is a test 1.x", "This is a test %1.x", Integer.valueOf(1));
+        confirm("This is a test ?missing data?1.x", "This is a test %1.x");
+        confirm("This is a test %1.x", "This is a test \\%1.x");
     }
 
+    private static void confirm(String expectedResult, String fmtString, Object ... params) {
+        String actualResult = StringUtil.format(fmtString, params);
+        assertEquals(expectedResult, actualResult);
+    }
 
-    private String fmt( double num, int minIntDigits, int maxFracDigitis )
-    {
+    private static String fmt(double num, int minIntDigits, int maxFracDigitis) {
         NumberFormat nf = NumberFormat.getInstance();
 
-        if ( minIntDigits != -1 )
-        {
-            nf.setMinimumIntegerDigits( minIntDigits );
+        if (minIntDigits != -1) {
+            nf.setMinimumIntegerDigits(minIntDigits);
         }
-        if ( maxFracDigitis != -1 )
-        {
-            nf.setMaximumFractionDigits( maxFracDigitis );
+        if (maxFracDigitis != -1) {
+            nf.setMaximumFractionDigits(maxFracDigitis);
         }
 
         return nf.format( num );
     }
+    
+    public void testStringsIterator() {
+       StringsIterator i;
 
+       
+       i = new StringsIterator(new String[0]);
+       assertFalse(i.hasNext());
+       try {
+          i.next();
+          fail();
+       } catch(ArrayIndexOutOfBoundsException e) {}
 
-    /**
-     * main
-     *
-     * @param ignored_args
-     */
-    public static void main( String[] ignored_args )
-    {
-        System.out.println( "Testing util.StringUtil functionality" );
-        junit.textui.TestRunner.run( TestStringUtil.class );
+       
+       i = new StringsIterator(new String[] {"1"});
+       assertTrue(i.hasNext());
+       assertEquals("1", i.next());
+       
+       assertFalse(i.hasNext());
+       try {
+          i.next();
+          fail();
+       } catch(ArrayIndexOutOfBoundsException e) {}
+
+       
+       i = new StringsIterator(new String[] {"1","2","3"});
+       assertTrue(i.hasNext());
+       assertEquals("1", i.next());
+       assertTrue(i.hasNext());
+       assertEquals("2", i.next());
+       assertTrue(i.hasNext());
+       assertEquals("3", i.next());
+       
+       assertFalse(i.hasNext());
+       try {
+          i.next();
+          fail();
+       } catch(ArrayIndexOutOfBoundsException e) {}
     }
-
-    /**
-     * @see junit.framework.TestCase#setUp()
-     */
-    protected void setUp() throws Exception
-    {
-        super.setUp();
-
-        // System.setProperty()
-    }
-
 }