Ticket #10134: 0001-Added-Disk-image-menu-register-unregister-disk-image.patch

src/apps/drivesetup/DiskView.cpp

@@ -7 +7 @@
 
 #include <stdio.h>
 
+#include <Application.h>
+#include <Bitmap.h>
 #include <DiskDeviceVisitor.h>
 #include <Catalog.h>
 #include <GroupLayout.h>
 #include <HashMap.h>
+#include <IconUtils.h>
 #include <LayoutItem.h>
 #include <Locale.h>
 #include <PartitioningInfo.h>
+#include <Path.h>
+#include <Resources.h>
 #include <String.h>
+#include <Volume.h>
+#include <VolumeRoster.h>
 
+#include "icons.h"
 #include "MainWindow.h"
 
 
@@ -34 +42 @@
 class PartitionView : public BView {
 public:
     PartitionView(const char* name, float weight, off_t offset,
-            int32 level, partition_id id)
+            int32 level, partition_id id, BPartition* partition)
         :
         BView(name, B_WILL_DRAW | B_SUPPORTS_LAYOUT | B_FULL_UPDATE_ON_RESIZE),
         fID(id),
@@ -63 +71 @@
         fGroupLayout->SetInsets(kLayoutInset, kLayoutInset + font.Size(),
             kLayoutInset, kLayoutInset);
 
-        SetExplicitMinSize(BSize(font.Size() + 6, 30));
+        SetExplicitMinSize(BSize(font.Size() + 20, 30));
+
+        fName = name;
+
+        BVolume volume;
+        partition->GetVolume(&volume);
+
+        BVolume boot;
+        BVolumeRoster().GetBootVolume(&boot);
+        fBoot = volume == boot;
+        fReadOnly = volume.IsReadOnly();
+        fShared = volume.IsShared();
+        fEncrypted = false;
+
+        BPath path;
+        partition->GetPath(&path);
+        
+        if (partition->Device()->IsFile()) {
+            fName = B_TRANSLATE("Virtual");
+            fVirtual = true;
+        } else
+            fVirtual = false;
+
+        const char* encrypter = dynamic_cast<MainWindow*>(Window())->EncryptionType(path.Path());
+        if (encrypter) {
+            fName = encrypter;
+            fEncrypted = true;
+        }
+        
+        if (partition->Parent() != NULL) {
+            partition->GetPath(&path);
+
+            encrypter = dynamic_cast<MainWindow*>(Window())->EncryptionType(path.Path());
+            if (encrypter) {
+                fName = encrypter;
+                fEncrypted = true;
+            }
+        }
+        
+        fUsed = 100.0 / ((float)volume.Capacity() / (volume.Capacity() - volume.FreeBytes()));
+        if (fUsed < 0)
+            fUsed = 100.0;
+
+        fIcon = new BBitmap(BRect(0, 0, 15, 15), B_RGBA32);
+
+        fBFS = BString(partition->ContentType()) == "Be File System";
+
+        if (fBoot)
+            BIconUtils::GetVectorIcon(kLeaf, sizeof(kLeaf), fIcon);
+        else if (fEncrypted)
+            BIconUtils::GetVectorIcon(kEncrypted, sizeof(kEncrypted), fIcon);
+        else if (fReadOnly)
+            BIconUtils::GetVectorIcon(kReadOnly, sizeof(kReadOnly), fIcon);
+        else if (fShared)
+            BIconUtils::GetVectorIcon(kShared, sizeof(kShared), fIcon);
+        else if (fVirtual)
+            BIconUtils::GetVectorIcon(kFile, sizeof(kFile), fIcon);
+        else
+            fIcon = NULL;
     }
 
     virtual void MouseDown(BPoint where)
@@ -94 +160 @@
 
         BRect b(Bounds());
         if (fSelected) {
-            SetHighColor(ui_color(B_KEYBOARD_NAVIGATION_COLOR));
+            if (fReadOnly)
+                SetHighColor(make_color(255, 128, 128));
+            else if (fBoot || fBFS)
+                SetHighColor(make_color(128, 255, 128));
+            else
+                SetHighColor(ui_color(B_KEYBOARD_NAVIGATION_COLOR));
             StrokeRect(b, B_SOLID_HIGH);
             b.InsetBy(1, 1);
             StrokeRect(b, B_SOLID_HIGH);
             b.InsetBy(1, 1);
-        } else if (fLevel > 0) {
+        } else if (fLevel >= 0) {
             StrokeRect(b, B_SOLID_HIGH);
             b.InsetBy(1, 1);
         }
 
+        if (CountChildren() == 0)
+            SetLowColor(make_color(255, 255, 255));
         FillRect(b, B_SOLID_LOW);
 
-        // prevent the text from moving when border width changes
+        if (fEncrypted && CountChildren() == 0) {
+            SetHighColor(make_color(128, 128, 128));
+            StrokeRect(b, B_SOLID_HIGH);
+            b.InsetBy(1, 1);
+            SetLowColor(make_color(224, 224, 0));
+            BRect e(BPoint(15, b.top), b.RightBottom());
+            e.InsetBy(1, 1);
+            FillRect(e, kStripes);
+        }
+
         if (!fSelected)
             b.InsetBy(1, 1);
+        
+        BRect used(b.LeftTop(), BSize(b.Width() / (100.0 / fUsed), b.Height()));
+
+        SetLowColor(make_color(240, 248, 255));
+
+        if (fReadOnly)
+            SetLowColor(make_color(255, 224, 224));
+        if (fBoot || fBFS)
+            SetLowColor(make_color(224, 255, 224));
+        if (CountChildren() == 0)
+            FillRect(used, B_SOLID_LOW);
+
+        if (fIcon && CountChildren() == 0) {
+            BPoint where = b.RightBottom() - BPoint(fIcon->Bounds().Width(), fIcon->Bounds().Height());
+            SetDrawingMode(B_OP_OVER);
+            DrawBitmap(fIcon, where);
+            SetDrawingMode(B_OP_COPY);
+        }
 
         float width;
         BFont font;
@@ -134 +234 @@
         }
 
         BString name(Name());
+        if (fEncrypted && CountChildren() == 0)
+            name.SetTo(fName);
+        else if (fEncrypted)
+            name << " (" << fName << ")";
+        else if (fVirtual)
+            name << " (" << fName << ")";
         font.TruncateString(&name, B_TRUNCATE_END, width);
 
         SetHighColor(tint_color(LowColor(), B_DARKEN_4_TINT));
@@ -168 +274 @@
         fSelected = selected;
         Invalidate();
     }
+    
+    bool IsEncrypted() {
+        return fEncrypted;
+    }
 
 private:
     void _SetMouseOver(bool mouseOver)
@@ -186 +296 @@
     bool            fSelected;
     bool            fMouseOver;
     BGroupLayout*   fGroupLayout;
+    bool            fBoot;
+    bool            fReadOnly;
+    bool            fShared;
+    bool            fEncrypted;
+    bool            fVirtual;
+    float           fUsed;
+    const char*     fName;
+    bool            fBFS;
+    BBitmap*        fIcon;
 };
 
 
@@ -208 +327 @@
         else
             name = B_TRANSLATE("Device");
 
+        if (BString(device->ContentName()).Length() > 0)
+            name = device->ContentName();
+
         PartitionView* view = new PartitionView(name, 1.0,
-            device->Offset(), 0, device->ID());
+            device->Offset(), 0, device->ID(), device);
         fViewMap.Put(device->ID(), view);
         fView->GetLayout()->AddView(view);
         _AddSpaces(device, view);
@@ -242 +364 @@
         }
         partition_id id = partition->ID();
         PartitionView* view = new PartitionView(name.String(), scale, offset,
-            level, id);
+            level, id, partition);
         view->SetSelected(id == fSelectedPartition);
         PartitionView* parent = fViewMap.Get(partition->Parent()->ID());
         BGroupLayout* layout = parent->GroupLayout();
@@ -296 +418 @@
                 double scale = (double)size / parentSize;
                 partition_id id
                     = fSpaceIDMap.SpaceIDFor(partition->ID(), offset);
-                PartitionView* view = new PartitionView(B_TRANSLATE("<empty>"),
-                    scale, offset, parentView->Level() + 1, id);
+                PartitionView* view = new PartitionView(B_TRANSLATE("<empty or unknown>"),
+                    scale, offset, parentView->Level() + 1, id, partition);
 
                 fViewMap.Put(id, view);
                 BGroupLayout* layout = parentView->GroupLayout();
@@ -434 +556 @@
 DiskView::SetDiskCount(int32 count)
 {
     fDiskCount = count;
+    if (count == 1) {
+        BMessage message(MSG_SELECTED_PARTITION_ID);
+        message.AddInt32("partition_id", 0);
+        Window()->PostMessage(&message);
+    }
 }
 
 

src/apps/drivesetup/Jamfile

@@ -15 +15 @@
     PartitionList.cpp
     Support.cpp
 
-    : be localestub libcolumnlistview.a libshared.a
+    : be localestub tracker libcolumnlistview.a libshared.a
         $(TARGET_LIBSUPC++)
     : DriveSetup.rdef
 ;

src/apps/drivesetup/MainWindow.cpp

@@ -13 +13 @@
 
 #include "MainWindow.h"
 
+#include <errno.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <Alert.h>
+#include <AppFileInfo.h>
 #include <Application.h>
 #include <Catalog.h>
 #include <ColumnListView.h>
 #include <ColumnTypes.h>
+#include <ControlLook.h>
 #include <Debug.h>
 #include <DiskDevice.h>
+#include <DiskDeviceRoster.h>
 #include <DiskDeviceVisitor.h>
 #include <DiskDeviceTypes.h>
 #include <DiskSystem.h>
+#include <IconUtils.h>
+#include <LayoutBuilder.h>
 #include <Locale.h>
 #include <MenuItem.h>
 #include <MenuBar.h>
@@ -67 +73 @@
     MSG_EJECT                   = 'ejct',
     MSG_SURFACE_TEST            = 'sfct',
     MSG_RESCAN                  = 'rscn',
+    MSG_REGISTER                = 'regi',
+    MSG_UNREGISTER              = 'unrg',
+    MSG_SAVE                    = 'save',
+    MSG_WRITE                   = 'writ',
+    MSG_OPEN_DISKPROBE          = 'opdp',
+    MSG_UPDATE_STATUS           = 'upst',
+    MSG_COMPLETE                = 'comp',
 
     MSG_PARTITION_ROW_SELECTED  = 'prsl',
 };
@@ -207 +220 @@
     fCurrentPartitionID(-1),
     fSpaceIDMap()
 {
+    SetSizeLimits(300, 8192, 270, 8192);
+    UpdateSizeLimits();
+
     fMenuBar = new BMenuBar(Bounds(), "root menu");
 
     // create all the menu items
@@ -235 +251 @@
     fMountAllMenuItem = new BMenuItem(B_TRANSLATE("Mount all"),
         new BMessage(MSG_MOUNT_ALL), 'M', B_SHIFT_KEY);
 
+    fOpenDiskProbeMenuItem = new BMenuItem(B_TRANSLATE("Open with DiskProbe"),
+        new BMessage(MSG_OPEN_DISKPROBE));
+
+    fRegisterMenuItem = new BMenuItem(
+        B_TRANSLATE("Register disk image" B_UTF8_ELLIPSIS),
+        new BMessage(MSG_REGISTER));
+    fUnRegisterMenuItem = new BMenuItem(
+        B_TRANSLATE("Unregister disk image"),
+        new BMessage(MSG_UNREGISTER));
+    fSaveMenuItem = new BMenuItem(
+        B_TRANSLATE("Save image" B_UTF8_ELLIPSIS),
+        new BMessage(MSG_SAVE));
+    fWriteMenuItem = new BMenuItem(
+        B_TRANSLATE("Write image" B_UTF8_ELLIPSIS),
+        new BMessage(MSG_WRITE));
+
     // Disk menu
     fDiskMenu = new BMenu(B_TRANSLATE("Disk"));
 
@@ -268 +300 @@
     fPartitionMenu->AddSeparatorItem();
 
     fPartitionMenu->AddItem(fMountAllMenuItem);
+
+    fPartitionMenu->AddSeparatorItem();
+
+    fPartitionMenu->AddItem(fOpenDiskProbeMenuItem);
     fMenuBar->AddItem(fPartitionMenu);
 
+    // Disk image menu
+    fDiskImageMenu = new BMenu(B_TRANSLATE("Disk image"));
+
+    fDiskImageMenu->AddItem(fRegisterMenuItem);
+    fDiskImageMenu->AddItem(fUnRegisterMenuItem);
+
+    fDiskImageMenu->AddSeparatorItem();
+
+    fDiskImageMenu->AddItem(fSaveMenuItem);
+    fDiskImageMenu->AddItem(fWriteMenuItem);
+
+    fMenuBar->AddItem(fDiskImageMenu);
+
     AddChild(fMenuBar);
 
     // Partition / Drives context menu
@@ -285 +334 @@
         new BMessage(MSG_MOUNT), 'M');
     fUnmountContextMenuItem = new BMenuItem(B_TRANSLATE("Unmount"),
         new BMessage(MSG_UNMOUNT), 'U');
+    fOpenDiskProbeContextMenuItem = new BMenuItem(B_TRANSLATE("Open with DiskProbe"),
+        new BMessage(MSG_OPEN_DISKPROBE));
     fFormatContextMenuItem = new BMenu(B_TRANSLATE("Format"));
 
     fContextMenu->AddItem(fCreateContextMenuItem);
@@ -294 +345 @@
     fContextMenu->AddSeparatorItem();
     fContextMenu->AddItem(fMountContextMenuItem);
     fContextMenu->AddItem(fUnmountContextMenuItem);
+    fContextMenu->AddSeparatorItem();
+    fContextMenu->AddItem(fOpenDiskProbeContextMenuItem);
     fContextMenu->SetTargetForItems(this);
 
     // add DiskView
@@ -317 +370 @@
     fListView->SetTarget(this);
     fListView->MakeFocus(true);
 
+    // add StatusView
+    r.top = r.bottom + 2;
+    r.bottom = Bounds().bottom + 40;
+    fStatusView = new BView(r, "StatusView", B_FOLLOW_LEFT_RIGHT | B_FOLLOW_BOTTOM, 0);
+    fStatusView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
+    AddChild(fStatusView);
+
+    // add StatusBar
+    r = fStatusView->Bounds();
+    r.right = r.right - 15;
+    r.InsetBy(2, -1);
+    fStatusBar = new BStatusBar(r, "StatusBar");
+    fStatusBar->SetResizingMode(B_FOLLOW_ALL);
+    fStatusView->AddChild(fStatusBar);
+
+    fFileOpen = NULL;
+
+    fNotification = new BNotification(B_INFORMATION_NOTIFICATION);
+    fNotification->SetGroup(BString(B_TRANSLATE_SYSTEM_NAME("DriveSetup")));
+
+    app_info info;
+    be_roster->GetAppInfo("application/x-vnd.Haiku-DriveSetup", &info);
+    BBitmap icon(BRect(0, 0, 32, 32), B_RGBA32);
+    BNode node(&info.ref);
+    BIconUtils::GetVectorIcon(&node, "BEOS:ICON", &icon);
+    fNotification->SetIcon(&icon);
+
     status_t status = fDiskDeviceRoster.StartWatching(BMessenger(this));
     if (status != B_OK) {
         fprintf(stderr, "Failed to start watching for device changes: %s\n",
@@ -339 +419 @@
 }
 
 
+const char*
+MainWindow::EncryptionType(const char* path)
+{
+    char buffer[16];
+    BString encrypter;
+    BFile(path, B_READ_ONLY).ReadAt(0, &buffer, 11);
+    encrypter.Append(buffer);
+
+    if (encrypter.FindFirst("-FVE-FS-") >= 0) {
+        return B_TRANSLATE("BitLocker encrypted");
+    } else if (encrypter.FindFirst("PGPGUARD") >= 0) {
+        return B_TRANSLATE("PGP encrypted");
+    } else if (encrypter.FindFirst("SafeBoot") >= 0) {
+        return B_TRANSLATE("SafeBoot encrypted");
+    } else if (encrypter.FindFirst("LUKS") >= 0) {
+        return B_TRANSLATE("LUKS encrypted");
+    }
+
+    return NULL;
+}
+
+
+status_t
+MainWindow::RegisterFileDiskDevice(const char* fileName)
+{
+    BString message;
+
+    struct stat st;
+    if (lstat(fileName, &st) != 0) {
+        status_t error = errno;
+
+        message.SetTo(B_TRANSLATE("Failed to stat() %s"));
+        message.ReplaceFirst("%s", fileName);
+        BAlert* alert = new BAlert("error", message.String(), B_TRANSLATE("OK"), NULL, NULL,
+            B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return error;
+    }
+
+    if (!S_ISREG(st.st_mode)) {
+        message.SetTo(B_TRANSLATE("%s is not a regular file."));
+        message.ReplaceFirst("%s", fileName);
+        BAlert* alert = new BAlert("error", message.String(), B_TRANSLATE("OK"), NULL, NULL,
+            B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return B_BAD_VALUE;
+    }
+
+    // register the file
+    BDiskDeviceRoster roster;
+    partition_id id = roster.RegisterFileDevice(fileName);
+    if (id < 0) {
+        message.SetTo(B_TRANSLATE("Failed to register file disk device: %s"));
+        message.ReplaceFirst("%s", fileName);
+        BAlert* alert = new BAlert("error", message.String(), B_TRANSLATE("OK"), NULL, NULL,
+            B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return id;
+    }
+
+    fNotification->SetTitle(BString(B_TRANSLATE("Disk image")));
+    fNotification->SetContent(BString(B_TRANSLATE("Disk image has been mounted.")));
+    fNotification->Send();
+
+    return B_OK;
+}
+
+
+status_t
+MainWindow::UnRegisterFileDiskDevice(const char* fileNameOrID)
+{
+    BString message;
+
+    // try to parse the parameter as ID
+    char* numberEnd;
+    partition_id id = strtol(fileNameOrID, &numberEnd, 0);
+    BDiskDeviceRoster roster;
+    if (id >= 0 && numberEnd != fileNameOrID && *numberEnd == '\0') {
+        BDiskDevice device;
+        if (roster.GetDeviceWithID(id, &device) == B_OK && device.IsFile()) {
+            status_t error = roster.UnregisterFileDevice(id);
+            if (error != B_OK) {
+                message.SetTo(B_TRANSLATE("Failed to unregister file disk device."));
+                BAlert* alert = new BAlert("error", message.String(), B_TRANSLATE("OK"), NULL, NULL,
+                    B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+                alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+                alert->Go(NULL);
+                return error;
+            }
+
+            fNotification->SetTitle(BString(B_TRANSLATE("Disk image")));
+            fNotification->SetContent(BString(B_TRANSLATE("Disk image has been removed.")));
+            fNotification->Send();
+
+            return B_OK;
+        } else {
+            message.SetTo(B_TRANSLATE("No file disk device found with the given ID, trying file %s"));
+            message.ReplaceFirst("%s", fileNameOrID);
+            BAlert* alert = new BAlert("error", message.String(), B_TRANSLATE("OK"), NULL, NULL,
+                B_WIDTH_FROM_WIDEST, B_WARNING_ALERT);
+            alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+            alert->Go(NULL);
+        }
+    }
+
+    // the parameter must be a file name -- stat() it
+    struct stat st;
+    if (lstat(fileNameOrID, &st) != 0) {
+        status_t error = errno;
+        message.SetTo(B_TRANSLATE("Failed to stat() \"%s\""));
+        message.ReplaceFirst("%s", fileNameOrID);
+        BAlert* alert = new BAlert("error", message.String(), B_TRANSLATE("OK"), NULL, NULL,
+            B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return error;
+    }
+
+    // remember the volume and node ID, so we can identify the file
+    // NOTE: There's a race condition -- we would need to open the file and
+    // keep it open to avoid it.
+    dev_t volumeID = st.st_dev;
+    ino_t nodeID = st.st_ino;
+
+    // iterate through all file disk devices and try to find a match
+    BDiskDevice device;
+    while (roster.GetNextDevice(&device) == B_OK) {
+        if (!device.IsFile())
+            continue;
+
+        // get file path and stat it, same for the device path
+        BPath path;
+        bool isFilePath = true;
+        if ((device.GetFilePath(&path) == B_OK && lstat(path.Path(), &st) == 0
+                && volumeID == st.st_dev && nodeID == st.st_ino)
+            || (isFilePath = false, false)
+            || (device.GetPath(&path) == B_OK && lstat(path.Path(), &st) == 0
+                && volumeID == st.st_dev && nodeID == st.st_ino)) {
+            status_t error = roster.UnregisterFileDevice(device.ID());
+            if (error != B_OK) {
+                message.SetTo(B_TRANSLATE("Failed to unregister file disk device %s"));
+                message.ReplaceFirst("%s", fileNameOrID);
+                BAlert* alert = new BAlert("error", message.String(), B_TRANSLATE("OK"), NULL, NULL,
+                    B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+                alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+                alert->Go(NULL);
+                return error;
+            }
+
+            fNotification->SetTitle(BString(B_TRANSLATE("Disk image")));
+            fNotification->SetContent(BString(B_TRANSLATE("Disk image has been removed.")));
+            fNotification->Send();
+
+            return B_OK;
+        }
+    }
+
+    message.SetTo(B_TRANSLATE("%s does not refer to a file disk device."));
+    message.ReplaceFirst("%s", fileNameOrID);
+    BAlert* alert = new BAlert("error", message.String(), B_TRANSLATE("OK"), NULL, NULL,
+        B_WIDTH_FROM_WIDEST, B_WARNING_ALERT);
+    alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+    alert->Go(NULL);
+    return B_BAD_VALUE;
+}
+
+
+int32
+MainWindow::SaveDiskImage(void* data)
+{
+    BMessage* msg = (BMessage*)data;
+    const char* sourcepath;
+    const char* targetpath;
+    const char* targetfolder;
+    int32 partitionID;
+    BMessenger messenger;
+
+    msg->FindString("source", &sourcepath);
+    msg->FindString("target", &targetpath);
+    msg->FindString("targetfolder", &targetfolder);
+    msg->FindInt32("partitionID", &partitionID);
+    msg->FindMessenger("messenger", &messenger);
+
+    BFile source(sourcepath, B_READ_ONLY);
+    BFile target(targetpath, B_READ_WRITE | B_CREATE_FILE);
+    BAlert* alert;
+
+    if (source.InitCheck() != B_OK) {
+        alert = new BAlert("error", B_TRANSLATE("Cannot init source volume."), 
+            B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return -1;
+    }
+
+    if (target.InitCheck() != B_OK) {
+        alert = new BAlert("error", B_TRANSLATE("Cannot init target file."), 
+            B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return -1;
+    }
+    
+    BDirectory* targetdir = new BDirectory(targetfolder);
+    node_ref node;
+    targetdir->GetNodeRef(&node);
+    BVolume volume(node.device);
+
+    if (volume.InitCheck()) {
+        alert = new BAlert("error", B_TRANSLATE("Cannot init target volume."), 
+            B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return -1;
+    }
+
+    if (volume.IsReadOnly()) {
+        alert = new BAlert("error", B_TRANSLATE("Target volume is read only."), 
+            B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return -1;
+    }
+
+    BPartition *partition;
+    BDiskDevice device;
+
+    BDiskDeviceRoster().GetPartitionWithID(partitionID, &device, &partition);
+
+    if (volume.FreeBytes() < partition->Size()) {
+        alert = new BAlert("error", B_TRANSLATE("There is no enugth free space on target device."), 
+            B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return -1;
+    }
+
+    size_t bufsize = partition->BlockSize();
+    off_t sourcesize, targetsize;
+    ssize_t targetbytes = 0;
+
+    source.GetSize(&sourcesize);
+    BMessage* message = new BMessage(MSG_UPDATE_STATUS);
+    message->AddFloat("maximumvalue", (float)sourcesize);
+    message->AddFloat("currentvalue", 0);
+    message->AddFloat("delta", 0);
+    message->AddString("statustext", "");
+
+    BString statustext;
+    statustext << B_TRANSLATE("Creating disk image") << ": " << targetpath;
+
+    char* buffer = new char[bufsize];
+    while (true) {
+        ssize_t bytes = source.Read(buffer, bufsize);
+
+        if (bytes > 0) {
+            target.Write(buffer, (size_t)bytes);
+            target.GetSize(&targetsize);
+                
+            targetbytes += bytes;
+
+            message->SetFloat("currentvalue", (float)targetbytes);
+            message->SetFloat("delta", (float)bytes);
+            message->SetString("statustext", statustext);
+            messenger.SendMessage(message);
+        } else
+            break;
+    }
+
+    message = new BMessage(MSG_COMPLETE);
+    message->AddString("status", B_TRANSLATE("Disk image successfully created."));
+    messenger.SendMessage(message);
+    
+    return 0;
+}
+
+
+int32
+MainWindow::WriteDiskImage(void* data)
+{
+    BMessage* msg = (BMessage*)data;
+    const char* sourcepath;
+    const char* targetpath;
+    BMessenger messenger;
+
+    msg->FindString("source", &sourcepath);
+    msg->FindString("target", &targetpath);
+    msg->FindMessenger("messenger", &messenger);
+
+    BFile source(sourcepath, B_READ_ONLY);
+    BFile target(targetpath, B_READ_WRITE);
+    BAlert* alert;
+
+    if (target.InitCheck() != B_OK) {
+        alert = new BAlert("error", B_TRANSLATE("Cannot init target partition."), 
+            B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return -1;
+    }
+
+    BPartition *partition;
+    BDiskDevice device;
+
+    BDiskDeviceRoster().GetPartitionForPath(targetpath, &device, &partition);
+
+    if (partition->IsReadOnly()) {
+        alert = new BAlert("error", B_TRANSLATE("Target partition is read only."), 
+            B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return -1;
+    }
+
+    off_t size;
+    source.GetSize(&size);
+
+    if (partition->Size() < size) {
+        alert = new BAlert("error", B_TRANSLATE("The target partition is smaller than the image file."), 
+            B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_FROM_WIDEST, B_STOP_ALERT);
+        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
+        alert->Go(NULL);
+        return -1;
+    }
+
+    size_t bufsize = partition->BlockSize();
+    off_t sourcesize;
+    ssize_t targetbytes = 0;
+
+    source.GetSize(&sourcesize);
+    BMessage* message = new BMessage(MSG_UPDATE_STATUS);
+    message->AddFloat("maximumvalue", (float)sourcesize);
+    message->AddFloat("currentvalue", 0);
+    message->AddFloat("delta", 0);
+    message->AddString("statustext", "");
+
+    BString statustext;
+    statustext << B_TRANSLATE("Writing image to disk") << ": " << targetpath;
+
+    char* buffer = new char[bufsize];
+    while (true) {
+        ssize_t bytes = source.Read(buffer, bufsize);
+
+        if (bytes > 0) {
+            target.Write(buffer, (size_t)bytes);
+            
+            targetbytes += bytes;
+
+            message->SetFloat("currentvalue", (float)targetbytes);
+            message->SetFloat("delta", (float)bytes);
+            message->SetString("statustext", statustext);
+            messenger.SendMessage(message);
+        } else
+            break;
+    }
+
+    message = new BMessage(MSG_COMPLETE);
+    message->AddString("status", B_TRANSLATE("Disk image successfully written to the target."));
+    messenger.SendMessage(message);
+    
+    return 0;
+}
+
+
 void
 MainWindow::MessageReceived(BMessage* message)
 {
@@ -429 +876 @@
                     true, false, true);
             break;
         }
+        case MSG_REGISTER:
+        {
+            entry_ref entryRef;
+            message->FindRef("refs", &entryRef);
+            BEntry entry(&entryRef);
+            BPath path;
+            if (entry.GetPath(&path) == B_OK) {
+                RegisterFileDiskDevice(path.Path());
+                break;
+            }
+            fFileOpen = new BFilePanel(B_OPEN_PANEL, new BMessenger(this), 
+                NULL, B_FILE_NODE, false, new BMessage(MSG_REGISTER), NULL, true);
+            fFileOpen->Show();
+            break;
+        }
+        case MSG_UNREGISTER:
+        {
+            BPath path;
+            fCurrentDisk->GetPath(&path);
+            UnRegisterFileDiskDevice(path.Path());
+            break;
+        }
+        case MSG_WRITE:
+        {
+            entry_ref entryRef;
+            message->FindRef("refs", &entryRef);
+            BEntry entry(&entryRef);
+            BPath path;
+            if (entry.GetPath(&path) == B_OK) {
+                BMessage* msg = new BMessage();
+
+                PartitionListRow* row = dynamic_cast<PartitionListRow*>(fListView->CurrentSelection());
+
+                msg->AddString("source", path.Path());
+                msg->AddString("target", row->DevicePath());
+                msg->AddMessenger("messenger", BMessenger(this));
+            
+                fStatusView->MoveBy(0, -40);
+                fListView->ResizeBy(0, -40);
+
+                thread_id write_thread = spawn_thread(WriteDiskImage, "WriteDiskImage", 
+                    B_LOW_PRIORITY, (void*)msg);
+                resume_thread(write_thread);
+            } else {
+                fFileOpen = new BFilePanel(B_OPEN_PANEL, new BMessenger(this), 
+                    NULL, B_FILE_NODE, false, new BMessage(MSG_WRITE), NULL, true);
+                fFileOpen->Show();
+            }
+            break;
+        }
+        case MSG_SAVE:
+        {
+            PartitionListRow* row = dynamic_cast<PartitionListRow*>(fListView->CurrentSelection());
+
+            fFileOpen = new BFilePanel(B_SAVE_PANEL, new BMessenger(this), 
+                NULL, B_FILE_NODE, false, NULL, NULL, true);
+            
+            const char* filename = "";
+            BStringField* field = (BStringField*)row->GetField(2);
+            filename = field->String();
+            fFileOpen->SetSaveText(filename);
+            fFileOpen->Show();
+            break;
+        }
+        case B_SAVE_REQUESTED:
+        {
+            BMessage* msg = new BMessage();
+
+            entry_ref entryRef;
+            message->FindRef("directory", &entryRef);
+            BEntry entry(&entryRef);
+            BPath path;
+            entry.GetPath(&path);
+            msg->AddString("targetfolder", path.Path());
+            const char* name;
+            message->FindString("name", &name);
+            path.Append(name);
+
+            PartitionListRow* row = dynamic_cast<PartitionListRow*>(fListView->CurrentSelection());
+            
+            msg->AddString("source", row->DevicePath());
+            msg->AddString("target", path.Path());
+            msg->AddInt32("partitionID", row->ID());
+            msg->AddMessenger("messenger", BMessenger(this));
+            
+            fStatusView->MoveBy(0, -40);
+            fListView->ResizeBy(0, -40);
+            
+            thread_id save_thread = spawn_thread(SaveDiskImage, "SaveDiskImage", B_LOW_PRIORITY, (void*)msg);
+            resume_thread(save_thread);
+
+            break;
+        }
+        case MSG_OPEN_DISKPROBE:
+        {
+            PartitionListRow* row = dynamic_cast<PartitionListRow*>(fListView->CurrentSelection());
+            const char* args[] = { row->DevicePath(), NULL };
+
+            be_roster->Launch("application/x-vnd.Haiku-DiskProbe", 1, (char**)args);
+
+            break;
+        }
+        case MSG_UPDATE_STATUS:
+        {
+            float maximumvalue, currentvalue, delta;
+            const char* statustext = "";
+            BString statusprogress;
+
+            message->FindFloat("maximumvalue", &maximumvalue);
+            message->FindFloat("currentvalue", &currentvalue);
+            message->FindFloat("delta", &delta);
+            message->FindString("statustext", &statustext);
+
+            statusprogress << (currentvalue / (1024 * 1024)) << " " << B_TRANSLATE("MiB") << " / ";
+            statusprogress << (maximumvalue / (1024 * 1024)) << " " << B_TRANSLATE("MiB");
+
+            fStatusBar->SetMaxValue(maximumvalue);
+            fStatusBar->Update(delta);
+            fStatusBar->SetText(statustext);
+            fStatusBar->SetTrailingText(statusprogress);
+
+            break;
+        }
+        case MSG_COMPLETE:
+        {
+            fStatusBar->Reset();
+            fStatusView->MoveBy(0, 40);
+            fListView->ResizeBy(0, 40);
+
+            const char* status = "";
+
+            message->FindString("status", &status);
+
+            fNotification->SetTitle(BString(B_TRANSLATE("Disk image")));
+            fNotification->SetContent(BString(status));
+            fNotification->Send();
+
+            break;
+        }
 
         case MSG_UPDATE_ZOOM_LIMITS:
             _UpdateWindowZoomLimits();
             break;
 
-        default:
+ 
+        default:
+            entry_ref ref;
+            int32 i = 0;
+
+            while (message->FindRef("refs", i++, &ref) == B_OK) {
+                BEntry entry(&ref, true);
+                BPath path(&entry);
+                BNode node(&entry);
+
+                if (node.IsFile()) {
+                    if (entry.GetPath(&path) == B_OK) {
+                        RegisterFileDiskDevice(path.Path());
+                    }
+                }
+            }
             BWindow::MessageReceived(message);
             break;
     }
@@ -642 +1243 @@
         fWipeMenuItem->SetEnabled(false);
         fEjectMenuItem->SetEnabled(false);
         fSurfaceTestMenuItem->SetEnabled(false);
+        fUnRegisterMenuItem->SetEnabled(false);
+        fSaveMenuItem->SetEnabled(false);
+        fWriteMenuItem->SetEnabled(false);
+        fOpenDiskProbeMenuItem->SetEnabled(false);
+        fOpenDiskProbeContextMenuItem->SetEnabled(false);
     } else {
 //      fWipeMenuItem->SetEnabled(true);
         fWipeMenuItem->SetEnabled(false);
@@ -649 +1255 @@
 //      fSurfaceTestMenuItem->SetEnabled(true);
         fSurfaceTestMenuItem->SetEnabled(false);
 
+        if (disk->IsFile())
+            fUnRegisterMenuItem->SetEnabled(true);
+        else
+            fUnRegisterMenuItem->SetEnabled(false);
+        
+        fSaveMenuItem->SetEnabled(true);
+        if (disk->IsReadOnly())
+            fWriteMenuItem->SetEnabled(false);
+        else
+            fWriteMenuItem->SetEnabled(true);
+
         // Create menu and items
         BPartition* parentPartition = NULL;
         if (selectedPartition <= -2) {
@@ -763 +1380 @@
             fFormatContextMenuItem->SetEnabled(false);
         }
 
+        fOpenDiskProbeMenuItem->SetEnabled(true);
+        fOpenDiskProbeContextMenuItem->SetEnabled(true);
+
         if (prepared)
             disk->CancelModifications();
 

src/apps/drivesetup/MainWindow.h

@@ -11 +11 @@
 
 
 #include <DiskDeviceRoster.h>
+#include <FilePanel.h>
+#include <Notification.h>
 #include <PopUpMenu.h>
+#include <StatusBar.h>
+#include <StringView.h>
 #include <Window.h>
 
 #include "Support.h"
@@ -48 +52 @@
             status_t            RestoreSettings(BMessage* archive);
             void                ApplyDefaultSettings();
 
+            status_t            RegisterFileDiskDevice(const char* fileName);
+            status_t            UnRegisterFileDiskDevice(const char* fileName);
+    static  int32               SaveDiskImage(void* data);
+    static  int32               WriteDiskImage(void* data);
+    const char*                 EncryptionType(const char* path);
+
 private:
             void                _ScanDrives();
 
@@ -89 +99 @@
 
             PartitionListView*  fListView;
             DiskView*           fDiskView;
+            BView*              fStatusView;
+            BStatusBar*         fStatusBar;
 
             SpaceIDMap          fSpaceIDMap;
 
@@ -97 +109 @@
 
             BMenu*              fPartitionMenu;
             BMenu*              fFormatMenu;
+            BMenu*              fDiskImageMenu;
 
             BMenuBar*           fMenuBar;
 
@@ -111 +124 @@
             BMenuItem*          fMountMenuItem;
             BMenuItem*          fUnmountMenuItem;
             BMenuItem*          fMountAllMenuItem;
+            BMenuItem*          fOpenDiskProbeMenuItem;
 
             BMenu*              fFormatContextMenuItem;
             BMenuItem*          fCreateContextMenuItem;
@@ -118 +132 @@
             BMenuItem*          fDeleteContextMenuItem;
             BMenuItem*          fMountContextMenuItem;
             BMenuItem*          fUnmountContextMenuItem;
+            BMenuItem*          fOpenDiskProbeContextMenuItem;
             BPopUpMenu*         fContextMenu;
+
+            BMenuItem*          fRegisterMenuItem;
+            BMenuItem*          fUnRegisterMenuItem;
+            BMenuItem*          fSaveMenuItem;
+            BMenuItem*          fWriteMenuItem;
+
+            BFilePanel*         fFileOpen;
+            
+            BNotification*      fNotification;
 };
 
 

src/apps/drivesetup/PartitionList.cpp

@@ -12 +12 @@
 
 #include "PartitionList.h"
 
+#include <stdio.h>
 #include <Catalog.h>
 #include <ColumnTypes.h>
+#include <DiskDevice.h>
+#include <File.h>
+#include <IconUtils.h>
 #include <Locale.h>
 #include <Path.h>
+#include <Volume.h>
+#include <VolumeRoster.h>
 
 #include <driver_settings.h>
 
 #include "Support.h"
 #include "MainWindow.h"
+#include "icons.h"
 
 
 #undef B_TRANSLATION_CONTEXT
@@ -35 +42 @@
     kVolumeNameColumn,
     kMountedAtColumn,
     kSizeColumn,
+    kFreeSizeColumn,
+    kBlockSizeColumn,
     kParametersColumn,
     kPartitionTypeColumn,
 };
@@ -208 +217 @@
 
     // Device icon
 
-    BBitmap* icon = NULL;
-    if (partition->IsDevice()) {
-        icon_size size = B_MINI_ICON;
-        icon = new BBitmap(BRect(0, 0, size - 1, size - 1), B_RGBA32);
-        if (partition->GetIcon(icon, size) != B_OK) {
-            delete icon;
-            icon = NULL;
-        }
+    BVolume volume;
+    partition->GetVolume(&volume);
+
+    BVolume boot;
+    BVolumeRoster().GetBootVolume(&boot);
+
+    bool fBoot;
+    bool fReadOnly;
+    bool fShared;
+    bool fEncrypted = false;
+
+    fBoot = volume == boot;
+    fReadOnly = volume.IsReadOnly();
+    fShared = volume.IsShared();
+
+    BString parameters;
+    if (fBoot) {
+        parameters += B_TRANSLATE("Boot");
+        parameters += ", ";
+    }
+
+    if (partition->Device()->IsFile()) {
+        parameters += B_TRANSLATE("Virtual");
+        parameters += ", ";
+    }
+
+    if (fReadOnly) {
+        parameters += B_TRANSLATE("Read only");
+        parameters += ", ";
+    }
+    if (volume.IsRemovable()) {
+        parameters += B_TRANSLATE("Removable");
+        parameters += ", ";
+    }
+    if (fShared) {
+        parameters += B_TRANSLATE("Shared");
+        parameters += ", ";
+    }
+    if (volume.KnowsMime()) {
+        parameters += B_TRANSLATE("Mimes");
+        parameters += ", ";
+    }
+    if (volume.KnowsAttr()) {
+        parameters += B_TRANSLATE("Attributes");
+        parameters += ", ";
+    }
+    if (volume.KnowsQuery()) {
+        parameters += B_TRANSLATE("Queries");
+        parameters += ", ";
     }
 
-    SetField(new BBitmapStringField(icon, path.Path()), kDeviceColumn);
+    const char* encrypter = dynamic_cast<MainWindow*>(be_app->WindowAt(0))->EncryptionType(path.Path());
+    if (encrypter) {
+        parameters.Append(encrypter);
+        parameters += ", ";
+        fEncrypted = true;
+    }
 
-    // File system & volume name
+    BBitmap *fIcon = new BBitmap(BRect(0, 0, 15, 15), B_RGBA32);
+ 
+    if (fBoot)
+        BIconUtils::GetVectorIcon(kLeaf, sizeof(kLeaf), fIcon);
+    else if (fEncrypted)
+        BIconUtils::GetVectorIcon(kEncrypted, sizeof(kEncrypted), fIcon);
+    else if (fReadOnly)
+        BIconUtils::GetVectorIcon(kReadOnly, sizeof(kReadOnly), fIcon);
+    else if (fShared)
+        BIconUtils::GetVectorIcon(kShared, sizeof(kShared), fIcon);
+    else if (partition->Device()->IsFile())
+        BIconUtils::GetVectorIcon(kFile, sizeof(kFile), fIcon);
+    else if (partition->IsDevice()) {
+        icon_size size = B_MINI_ICON;
+        fIcon = new BBitmap(BRect(0, 0, size - 1, size - 1), B_RGBA32);
+        if (partition->GetIcon(fIcon, size) != B_OK) {
+            delete fIcon;
+            fIcon = NULL;
+        }
+    } else
+        fIcon = NULL;
+ 
+    SetField(new BBitmapStringField(fIcon, path.Path()), kDeviceColumn);
+ 
+    // File system & volume name
 
     BString partitionType(partition->Type());
 
@@ -260 +339 @@
         char size[1024];
         SetField(new BStringField(string_for_size(partition->Size(), size,
             sizeof(size))), kSizeColumn);
-    } else {
+    } else
         SetField(new BStringField(kUnavailableString), kSizeColumn);
-    }
+
+    if (volume.FreeBytes() > 0) {
+        char size[1024];
+        SetField(new BStringField(string_for_size(volume.FreeBytes(), size, sizeof(size))), kFreeSizeColumn);
+    } else
+        SetField(new BStringField(kUnavailableString), kFreeSizeColumn);
+
+    char blocksize;
+    sprintf(&blocksize, "%" B_PRIu32, partition->BlockSize());
+    SetField(new BStringField(const_cast<const char*>(&blocksize)), kBlockSizeColumn);
 
     // Additional parameters
 
     if (partition->Parameters() != NULL) {
-        BString parameters;
-
         // check parameters
         void* handle = parse_driver_settings_string(partition->Parameters());
         if (handle != NULL) {
@@ -278 +364 @@
 
             delete_driver_settings(handle);
         }
-
-        SetField(new BStringField(parameters), kParametersColumn);
-    } else {
-        SetField(new BStringField(kUnavailableString), kParametersColumn);
     }
 
+    if (parameters.EndsWith(", "))
+        parameters.RemoveLast(", ");
+    SetField(new BStringField(parameters), kParametersColumn);
+
     // Partition type
 
     if (partitionType.IsEmpty())
@@ -304 +390 @@
     // TODO: design icon for spaces on partitions
     SetField(new BBitmapStringField(NULL, "-"), kDeviceColumn);
 
-    SetField(new BStringField(B_TRANSLATE("<empty>")), kFilesystemColumn);
+    SetField(new BStringField(B_TRANSLATE("<empty or unknown>")), kFilesystemColumn);
     SetField(new BStringField(kUnavailableString), kVolumeNameColumn);
 
     SetField(new BStringField(kUnavailableString), kMountedAtColumn);
@@ -342 +428 @@
         B_TRUNCATE_MIDDLE), kVolumeNameColumn);
     AddColumn(new PartitionColumn(B_TRANSLATE("Mounted at"), 100, 50, 500,
         B_TRUNCATE_MIDDLE), kMountedAtColumn);
-    AddColumn(new PartitionColumn(B_TRANSLATE("Size"), 100, 50, 500,
+    AddColumn(new PartitionColumn(B_TRANSLATE("Size"), 80, 50, 500,
         B_TRUNCATE_END, B_ALIGN_RIGHT), kSizeColumn);
+    AddColumn(new PartitionColumn(B_TRANSLATE("Free space"), 80, 50, 500,
+        B_TRUNCATE_END, B_ALIGN_RIGHT), kFreeSizeColumn);
+    AddColumn(new PartitionColumn(B_TRANSLATE("Block size"), 50, 50, 500,
+        B_TRUNCATE_END, B_ALIGN_RIGHT), kBlockSizeColumn);
     AddColumn(new PartitionColumn(B_TRANSLATE("Parameters"), 100, 50, 500,
         B_TRUNCATE_END), kParametersColumn);
     AddColumn(new PartitionColumn(B_TRANSLATE("Partition type"), 200, 50, 500,

new file src/apps/drivesetup/icons.h

@@ +1 @@
+const unsigned char kLeaf[] = {
+    0x6e, 0x63, 0x69, 0x66, 0x02, 0x05, 0x00, 0x02, 0x01, 0x06, 0x02, 0x38,
+    0xcc, 0x87, 0xbd, 0x08, 0x3d, 0x3d, 0xcc, 0x62, 0x39, 0x81, 0x95, 0x46,
+    0x09, 0x92, 0x4a, 0x99, 0x6b, 0x00, 0xff, 0xb1, 0x1b, 0xff, 0xff, 0xf9,
+    0xc7, 0x01, 0x06, 0x0d, 0xee, 0x1f, 0xbf, 0x03, 0x2f, 0x44, 0x2b, 0x4f,
+    0x2b, 0x48, 0x29, 0x4b, 0x24, 0x4a, 0x29, 0x53, 0x23, 0x50, 0x29, 0x53,
+    0x23, 0x54, 0x29, 0x54, 0x23, 0x54, 0x2e, 0x58, 0x26, 0x5a, 0x2e, 0x58,
+    0x5c, 0x30, 0x30, 0x58, 0x30, 0x58, 0x38, 0x5a, 0x3b, 0x54, 0x3b, 0x54,
+    0x35, 0x54, 0x35, 0x53, 0x35, 0x53, 0x3b, 0x50, 0x3a, 0x4a, 0x33, 0x4f,
+    0x35, 0x4b, 0x33, 0x48, 0x03, 0x0a, 0x00, 0x01, 0x00, 0x1a, 0x41, 0xcc,
+    0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0xcc, 0x0a, 0x43, 0xa6,
+    0x76, 0xcb, 0x99, 0xb5, 0x15, 0xff, 0x01, 0x17, 0x83, 0x00, 0x04, 0x0a,
+    0x00, 0x01, 0x00, 0x1a, 0x41, 0xcc, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x41, 0xcc, 0x0a, 0x43, 0xa6, 0x76, 0xcb, 0x99, 0xb5, 0x00, 0x15,
+    0x01, 0x17, 0x84, 0x00, 0x04, 0x0a, 0x01, 0x01, 0x00, 0x02, 0x41, 0xcc,
+    0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0xcc, 0x0a, 0x43, 0xa6,
+    0x76, 0xcb, 0x99, 0xb5
+};
+
+const unsigned char kEncrypted[] = {
+    0x6e, 0x63, 0x69, 0x66, 0x02, 0x05, 0x00, 0x03, 0xff, 0x00, 0x00, 0x03,
+    0x02, 0x04, 0x31, 0x22, 0xbd, 0x10, 0x22, 0xb6, 0x77, 0x22, 0x22, 0x31,
+    0x22, 0xb6, 0x77, 0x22, 0xbd, 0x10, 0x31, 0x40, 0xb6, 0x77, 0x40, 0xbd,
+    0x10, 0x40, 0x40, 0x31, 0x40, 0xbd, 0x10, 0x40, 0xb6, 0x77, 0x02, 0x03,
+    0x28, 0x37, 0x28, 0x37, 0x25, 0x33, 0xb6, 0xaa, 0xb6, 0xaa, 0xb5, 0x50,
+    0xb8, 0x07, 0xb8, 0x07, 0xb5, 0x50, 0x37, 0x28, 0xba, 0xe0, 0xb4, 0xe7,
+    0x38, 0x29, 0x02, 0x03, 0x3a, 0x2b, 0x3a, 0x2b, 0x3e, 0x2f, 0xbc, 0xdd,
+    0xbc, 0xdd, 0xbe, 0x34, 0xbb, 0x86, 0xbb, 0x84, 0xbe, 0x35, 0x2b, 0x3a,
+    0x2f, 0x3d, 0x2b, 0x3a, 0x02, 0x0a, 0x00, 0x03, 0x00, 0x01, 0x02, 0x12,
+    0x41, 0x95, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x95, 0x35,
+    0x40, 0x17, 0x64, 0x40, 0x17, 0x64, 0x01, 0x17, 0x83, 0x02, 0x04, 0x0a,
+    0x01, 0x03, 0x00, 0x01, 0x02, 0x02, 0x41, 0x95, 0x35, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x41, 0x95, 0x35, 0x40, 0x17, 0x64, 0x40, 0x17, 0x64
+};
+
+const unsigned char kReadOnly[] = {
+    0x6e, 0x63, 0x69, 0x66, 0x0f, 0x05, 0x01, 0x02, 0x00, 0x06, 0x03, 0x38,
+    0xd2, 0xf7, 0x3c, 0xd1, 0x63, 0xbf, 0x82, 0xb2, 0x3b, 0x84, 0xa9, 0x4b,
+    0x88, 0x50, 0x49, 0x10, 0xc9, 0x00, 0xff, 0xef, 0xa5, 0xbd, 0xff, 0xfc,
+    0xc0, 0xff, 0xff, 0xf8, 0x90, 0x02, 0x01, 0x06, 0x02, 0x3e, 0x49, 0x24,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0xaa, 0xaa, 0x49, 0x40, 0x00,
+    0x4a, 0x80, 0x00, 0xff, 0xff, 0xfc, 0xc0, 0x7c, 0xf1, 0xb7, 0x06, 0x02,
+    0x00, 0x16, 0x02, 0x3a, 0x55, 0xa6, 0xba, 0xc2, 0x29, 0x3f, 0x0d, 0xa3,
+    0x3e, 0x95, 0x86, 0x46, 0xc2, 0xeb, 0x47, 0xa1, 0xd6, 0x00, 0x01, 0xff,
+    0x9e, 0x02, 0x00, 0x06, 0x03, 0xb4, 0xa7, 0xac, 0x38, 0xfc, 0xa2, 0xbb,
+    0xf7, 0x7b, 0xb7, 0x86, 0xa6, 0x49, 0x3b, 0x6c, 0x47, 0x11, 0x63, 0x00,
+    0xff, 0xee, 0xd5, 0x8d, 0xdb, 0xab, 0x5f, 0xcf, 0xff, 0xee, 0xd5, 0x02,
+    0x00, 0x06, 0x02, 0x3d, 0x4d, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x40, 0x00, 0x00, 0x4a, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xea,
+    0xba, 0xff, 0xff, 0xf6, 0xe3, 0x02, 0x00, 0x06, 0x03, 0x00, 0x00, 0x00,
+    0x39, 0x0c, 0x30, 0xbb, 0xcf, 0x3c, 0x00, 0x00, 0x00, 0x4b, 0x60, 0x00,
+    0x46, 0x00, 0x00, 0x00, 0xff, 0xea, 0xee, 0xc6, 0xd1, 0x7c, 0x8a, 0xff,
+    0xda, 0x9f, 0xaa, 0x02, 0x00, 0x06, 0x02, 0xaa, 0xb1, 0xfb, 0x3a, 0x08,
+    0x1f, 0xbe, 0x8a, 0x26, 0xaf, 0x5e, 0x79, 0x4c, 0x50, 0x14, 0x46, 0xc6,
+    0xa1, 0x00, 0xff, 0xe3, 0xe8, 0xff, 0xf8, 0xa1, 0xb1, 0x02, 0x00, 0x06,
+    0x02, 0x3c, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
+    0x00, 0x4a, 0x40, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfb, 0xb5, 0x0d, 0x00,
+    0xf0, 0xab, 0x06, 0x02, 0x00, 0x06, 0x02, 0xb6, 0x6e, 0x92, 0x3a, 0x77,
+    0x41, 0xbf, 0xe2, 0x39, 0xbb, 0xd4, 0x8d, 0x4c, 0x06, 0x3f, 0x48, 0xc5,
+    0xf5, 0x00, 0xa5, 0x2a, 0x04, 0xff, 0xfd, 0xb4, 0x4b, 0x02, 0x00, 0x06,
+    0x02, 0x3b, 0x8e, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
+    0x00, 0x4a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc5, 0xb0, 0x3a, 0xff,
+    0xe9, 0xda, 0x71, 0x03, 0xe2, 0xc2, 0x55, 0x04, 0x00, 0x66, 0x03, 0x80,
+    0x00, 0x00, 0x02, 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x3c, 0x20, 0x00,
+    0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x48, 0xe0, 0x00,
+    0x00, 0xff, 0xab, 0xab, 0xff, 0xd9, 0x00, 0x00, 0x0c, 0x06, 0x0c, 0xae,
+    0xaa, 0xba, 0xb4, 0x0b, 0xc1, 0x4b, 0x33, 0xc5, 0xad, 0xb7, 0x5d, 0xc3,
+    0x71, 0xbd, 0xef, 0xc8, 0x05, 0xc1, 0x3e, 0xca, 0x02, 0xc4, 0xe0, 0x4f,
+    0x41, 0xc5, 0x07, 0x37, 0x4b, 0x39, 0x4a, 0x45, 0xc3, 0x3c, 0xc6, 0xd1,
+    0xc3, 0x6f, 0xca, 0x28, 0xbf, 0x80, 0xc1, 0x18, 0xbb, 0x1e, 0xc5, 0x1b,
+    0xbd, 0x3e, 0xbf, 0x07, 0xba, 0x06, 0x3a, 0xb8, 0xba, 0x06, 0x09, 0xae,
+    0xaa, 0x02, 0xb5, 0x7d, 0x43, 0xb9, 0xb9, 0xc5, 0xed, 0xb7, 0xbb, 0x49,
+    0xbb, 0xb7, 0x56, 0xbd, 0x75, 0xcb, 0x34, 0xc6, 0xf0, 0xc5, 0xc2, 0x4e,
+    0x4f, 0x51, 0x4b, 0xc9, 0xbb, 0xc4, 0x28, 0xca, 0x8e, 0xc3, 0xaf, 0x40,
+    0x34, 0x06, 0x06, 0xb2, 0x08, 0x31, 0x24, 0x53, 0x56, 0x29, 0x56, 0x25,
+    0x56, 0x2d, 0x53, 0x2e, 0x31, 0x26, 0x29, 0x0a, 0x06, 0x31, 0x24, 0xb8,
+    0xba, 0xb5, 0xb2, 0xb8, 0xba, 0xb7, 0x79, 0x31, 0x2e, 0xb6, 0x77, 0xb6,
+    0xec, 0xb6, 0x7c, 0xb6, 0x3c, 0x0a, 0x04, 0x33, 0x24, 0xb9, 0x69, 0xb5,
+    0xba, 0x4a, 0x27, 0x4d, 0x24, 0x08, 0x04, 0xba, 0x28, 0xb4, 0xd3, 0x30,
+    0x27, 0x30, 0x2b, 0xba, 0x28, 0xb8, 0x58, 0x06, 0x06, 0x2e, 0x0b, 0x53,
+    0x24, 0x50, 0x29, 0x50, 0x25, 0x50, 0x2d, 0x53, 0x2e, 0x4f, 0x4c, 0x29,
+    0x4c, 0x2d, 0x4c, 0x25, 0x4f, 0x24, 0x00, 0x03, 0xc4, 0xea, 0xb4, 0xd3,
+    0xc4, 0xea, 0xb4, 0xd3, 0xc4, 0x92, 0xb5, 0x17, 0x4b, 0x29, 0x4b, 0xb5,
+    0x9e, 0x4b, 0xb7, 0x8d, 0xc4, 0xea, 0xb8, 0x58, 0xc4, 0x92, 0xb8, 0x14,
+    0xc4, 0xea, 0xb8, 0x58, 0x06, 0x04, 0xee, 0x53, 0x24, 0x56, 0x29, 0x56,
+    0x25, 0x56, 0x2d, 0x53, 0x2e, 0x50, 0x29, 0x50, 0x2d, 0x50, 0x25, 0x0a,
+    0x04, 0xb9, 0x69, 0xb5, 0xba, 0xb9, 0x69, 0xb7, 0x71, 0x4a, 0x2b, 0x4a,
+    0x27, 0x0a, 0x04, 0xb9, 0x69, 0xb7, 0x71, 0x33, 0x2e, 0x4d, 0x2e, 0x4a,
+    0x2b, 0x0a, 0x0c, 0x48, 0x2a, 0x40, 0x22, 0x35, 0x2d, 0x2a, 0x22, 0x22,
+    0x2a, 0x2d, 0x35, 0x22, 0x40, 0x2a, 0x48, 0x35, 0x3d, 0x40, 0x48, 0x48,
+    0x40, 0x3d, 0x35, 0x0a, 0x0a, 0x00, 0x03, 0x02, 0x05, 0x07, 0x12, 0x40,
+    0x26, 0x8f, 0xbf, 0xa4, 0x83, 0x3f, 0xa4, 0x83, 0x40, 0x26, 0x8f, 0xc6,
+    0x03, 0xab, 0x4b, 0x1c, 0x95, 0x01, 0x17, 0x84, 0x00, 0x04, 0x0a, 0x04,
+    0x01, 0x03, 0x02, 0x40, 0x26, 0x8f, 0xbf, 0xa4, 0x83, 0x3f, 0xa4, 0x83,
+    0x40, 0x26, 0x8f, 0xc6, 0x03, 0xab, 0x4b, 0x1c, 0x95, 0x0a, 0x05, 0x01,
+    0x04, 0x02, 0x40, 0x26, 0x8f, 0xbf, 0xa4, 0x83, 0x3f, 0xa4, 0x83, 0x40,
+    0x26, 0x8f, 0xc6, 0x03, 0xab, 0x4b, 0x1c, 0x95, 0x0a, 0x08, 0x01, 0x09,
+    0x02, 0x40, 0x26, 0x8f, 0xbf, 0xa4, 0x83, 0x3f, 0xa4, 0x83, 0x40, 0x26,
+    0x8f, 0xc6, 0x03, 0xab, 0x4b, 0x1c, 0x95, 0x0a, 0x09, 0x01, 0x0a, 0x02,
+    0x40, 0x26, 0x8f, 0xbf, 0xa4, 0x83, 0x3f, 0xa4, 0x83, 0x40, 0x26, 0x8f,
+    0xc6, 0x03, 0xab, 0x4b, 0x1c, 0x95, 0x0a, 0x06, 0x01, 0x06, 0x02, 0x40,
+    0x26, 0x8f, 0xbf, 0xa4, 0x83, 0x3f, 0xa4, 0x83, 0x40, 0x26, 0x8f, 0xc6,
+    0x03, 0xab, 0x4b, 0x1c, 0x95, 0x0a, 0x07, 0x01, 0x08, 0x02, 0x40, 0x26,
+    0x8f, 0xbf, 0xa4, 0x83, 0x3f, 0xa4, 0x83, 0x40, 0x26, 0x8f, 0xc6, 0x03,
+    0xab, 0x4b, 0x1c, 0x95, 0x0a, 0x0c, 0x01, 0x0b, 0x30, 0x36, 0x36, 0x01,
+    0x17, 0x83, 0x22, 0x04, 0x0a, 0x0d, 0x01, 0x0b, 0x30, 0x34, 0x34, 0x01,
+    0x17, 0x83, 0x22, 0x04, 0x0a, 0x0e, 0x01, 0x0b, 0x20, 0x34, 0x34
+};
+
+const unsigned char kShared[] = {
+    0x6e, 0x63, 0x69, 0x66, 0x13, 0x04, 0x00, 0x4c, 0x03, 0xff, 0xcb, 0x9a,
+    0x01, 0xcd, 0x98, 0x66, 0xb2, 0x01, 0xcd, 0x99, 0x66, 0xb2, 0x01, 0xcd,
+    0x99, 0x66, 0xb2, 0x01, 0xcd, 0x99, 0x66, 0xb2, 0x01, 0xcd, 0x99, 0x66,
+    0xb2, 0x01, 0xcd, 0x99, 0x66, 0xb2, 0x01, 0xcd, 0x99, 0x66, 0xb2, 0x01,
+    0xcd, 0x98, 0x66, 0xb2, 0x04, 0xff, 0xf2, 0x04, 0xff, 0xf2, 0x04, 0xff,
+    0xf2, 0x04, 0xff, 0xf2, 0x05, 0x00, 0x04, 0xff, 0xb2, 0x01, 0xcd, 0x98,
+    0x66, 0xb2, 0x04, 0x00, 0x2b, 0x05, 0x00, 0x12, 0x06, 0x17, 0xeb, 0xff,
+    0xbe, 0xff, 0xbe, 0x3f, 0xc5, 0xdd, 0xb9, 0x18, 0xcb, 0xb1, 0xba, 0x52,
+    0xc4, 0xc9, 0xb8, 0xdc, 0xc4, 0x28, 0xb9, 0x72, 0xc2, 0xdc, 0xba, 0x19,
+    0xc1, 0xb3, 0xb9, 0xb6, 0xc2, 0x3c, 0xb9, 0xaf, 0xc1, 0xb3, 0xb9, 0xb6,
+    0xb7, 0xbb, 0xb9, 0xb6, 0xb7, 0xbb, 0xb9, 0xb6, 0xb6, 0x4f, 0xb9, 0xb6,
+    0xb7, 0x9b, 0xbc, 0x6c, 0xb5, 0xaa, 0xbc, 0x6c, 0xb7, 0x9b, 0xbc, 0x6c,
+    0xbb, 0x19, 0xbc, 0x6c, 0xbb, 0x19, 0xbc, 0x6c, 0xbb, 0xa1, 0xbc, 0x77,
+    0xbc, 0x21, 0xbd, 0x12, 0xbc, 0x21, 0xbc, 0x8e, 0xbc, 0x21, 0xbd, 0x12,
+    0xbb, 0xbf, 0xbe, 0x1b, 0xb3, 0xb8, 0xc5, 0xdf, 0xb3, 0xb8, 0xc5, 0xdf,
+    0xb2, 0x4b, 0xc7, 0x4d, 0xb5, 0x87, 0xc7, 0xb0, 0xb4, 0x90, 0xc8, 0xa7,
+    0xb5, 0x87, 0xc7, 0xb0, 0xb5, 0x8d, 0xc7, 0xb1, 0xb5, 0x24, 0xc8, 0x13,
+    0xb5, 0x24, 0xc8, 0x13, 0xb3, 0xb8, 0xc9, 0x80, 0xb8, 0x41, 0xc9, 0x52,
+    0xb6, 0x4f, 0xcb, 0x01, 0xb8, 0x41, 0xc9, 0x52, 0xb8, 0x96, 0xc8, 0xfa,
+    0xb8, 0x96, 0xc8, 0xfa, 0xb7, 0xaf, 0xca, 0x8b, 0xbc, 0x47, 0xc9, 0xcc,
+    0xba, 0xed, 0xcb, 0x75, 0xbc, 0x47, 0xc9, 0xcc, 0xbc, 0x8f, 0xc9, 0x86,
+    0xbc, 0x95, 0xc9, 0x88, 0xbc, 0x95, 0xc9, 0x88, 0xba, 0xef, 0xcb, 0x24,
+    0xbf, 0x80, 0xca, 0x68, 0xbd, 0xb0, 0xcc, 0x58, 0xbf, 0x80, 0xca, 0x68,
+    0x4d, 0xc5, 0x19, 0xc9, 0x55, 0xc0, 0x4f, 0xc8, 0xd0, 0xc1, 0x37, 0xc9,
+    0xd9, 0xbf, 0x66, 0xc9, 0x77, 0xbd, 0xda, 0xc9, 0xb8, 0xbf, 0x25, 0xc9,
+    0x77, 0xbd, 0xda, 0xca, 0x5f, 0xbd, 0x12, 0xca, 0x5f, 0xbd, 0x12, 0xca,
+    0xa4, 0xbc, 0x2f, 0x06, 0x09, 0xdf, 0xfb, 0x03, 0xc2, 0xd1, 0xba, 0x5d,
+    0xc2, 0xd1, 0xba, 0x5d, 0xc3, 0x09, 0xba, 0x68, 0xc4, 0x46, 0xbb, 0x84,
+    0xc4, 0x46, 0xba, 0xf9, 0xc4, 0x46, 0xbb, 0x84, 0xbb, 0xd1, 0xc4, 0x92,
+    0xbb, 0xc9, 0xc4, 0x92, 0xbb, 0xc9, 0xc6, 0x1a, 0xbb, 0xa0, 0x56, 0xbd,
+    0x7f, 0x56, 0xbc, 0x25, 0x56, 0xbd, 0x7f, 0xc8, 0x59, 0xbc, 0x67, 0xc8,
+    0xb7, 0xbc, 0x65, 0xc8, 0xb7, 0xbc, 0x65, 0xc8, 0x12, 0xbb, 0x65, 0xc4,
+    0x9e, 0xbb, 0x70, 0xc6, 0x28, 0x35, 0xc4, 0x57, 0xba, 0x94, 0xc2, 0xe9,
+    0xb9, 0xd4, 0xc3, 0x0d, 0xb9, 0xdc, 0xc2, 0xe9, 0xb9, 0xd4, 0x06, 0x08,
+    0xbe, 0xbf, 0xb7, 0x35, 0xbb, 0xe0, 0xbc, 0x6b, 0xbb, 0x99, 0xbc, 0x6b,
+    0xbb, 0x99, 0x3a, 0xbd, 0x11, 0xbf, 0xe8, 0xbc, 0xce, 0xbd, 0xe6, 0xbd,
+    0x78, 0xc1, 0x90, 0xbc, 0x40, 0xc2, 0xb9, 0xbc, 0x21, 0xc0, 0x2c, 0xbd,
+    0xdf, 0xc1, 0x61, 0xbd, 0x57, 0xbe, 0xf7, 0xbe, 0x68, 0xbb, 0x7b, 0xbe,
+    0xae, 0xbd, 0x7f, 0xbe, 0x8c, 0xbb, 0x99, 0xbd, 0xbf, 0xbb, 0xe2, 0xbc,
+    0x88, 0xbc, 0xac, 0xbc, 0xa4, 0xb9, 0x6e, 0xbc, 0x34, 0xb7, 0x9b, 0xbc,
+    0x6c, 0x06, 0x09, 0xfe, 0xbf, 0x03, 0xbf, 0xc5, 0xc3, 0xc5, 0xc0, 0x4f,
+    0xc4, 0xb6, 0xc0, 0x93, 0xc4, 0x4f, 0xc0, 0x0b, 0xc5, 0x1d, 0xbe, 0x07,
+    0xc6, 0xb8, 0xbe, 0x29, 0xc6, 0x2f, 0xbd, 0x39, 0xc7, 0x41, 0xbc, 0x28,
+    0xc8, 0xdc, 0xbc, 0x6b, 0xc8, 0x53, 0xbb, 0xe2, 0xc9, 0x67, 0xb9, 0xe0,
+    0xc9, 0xab, 0xba, 0x6a, 0xc9, 0xab, 0xb9, 0x57, 0xc9, 0xab, 0xb9, 0xbd,
+    0xca, 0x9b, 0xb9, 0x34, 0xca, 0x9b, 0xba, 0x46, 0xca, 0x9b, 0xbc, 0x47,
+    0xc9, 0xcc, 0xbb, 0x9b, 0xca, 0x76, 0xbc, 0x47, 0xc9, 0xcc, 0xc0, 0xfa,
+    0xc5, 0x1d, 0xc2, 0x0c, 0xc4, 0xb6, 0xc1, 0xa5, 0xc4, 0x70, 0xc1, 0x61,
+    0xc4, 0x70, 0x06, 0x09, 0xfe, 0xbf, 0x03, 0xbb, 0xc1, 0xc2, 0xf7, 0xbc,
+    0x4a, 0xc3, 0xe8, 0xbc, 0x8f, 0xc3, 0x81, 0xbc, 0x05, 0xc4, 0x4f, 0xba,
+    0x03, 0xc5, 0xeb, 0xba, 0x24, 0xc5, 0x61, 0xb9, 0x34, 0xc6, 0x73, 0xb8,
+    0x22, 0xc8, 0x0e, 0xb8, 0x67, 0xc7, 0x85, 0xb7, 0xdd, 0xc8, 0x99, 0xb5,
+    0xda, 0xc8, 0xdc, 0xb6, 0x64, 0xc8, 0xdc, 0xb5, 0x51, 0xc8, 0xdc, 0xb5,
+    0xb9, 0xc9, 0xcd, 0xb5, 0x3a, 0xc9, 0x97, 0xb6, 0x85, 0xca, 0x26, 0xb8,
+    0x42, 0xc8, 0xfe, 0xb7, 0x95, 0xc9, 0xa7, 0xb8, 0x42, 0xc8, 0xfe, 0x39,
+    0xc4, 0x4f, 0xbe, 0x07, 0xc3, 0xe8, 0xbd, 0xa0, 0xc3, 0xa2, 0x3a, 0xc3,
+    0xa2, 0x06, 0x09, 0xfe, 0xbf, 0x03, 0xba, 0x03, 0xc0, 0xf4, 0xba, 0x8c,
+    0xc1, 0xe5, 0xba, 0xd1, 0xc1, 0x7d, 0xba, 0x47, 0xc2, 0x4c, 0xb8, 0x45,
+    0xc3, 0xe8, 0xb8, 0x67, 0xc3, 0x5e, 0xb7, 0x76, 0xc4, 0x70, 0xb6, 0x64,
+    0xc6, 0x0c, 0xb6, 0xa9, 0xc5, 0x84, 0xb6, 0x20, 0xc6, 0x96, 0xb4, 0x1d,
+    0xc6, 0xda, 0xb5, 0x17, 0xc7, 0x53, 0xb3, 0xa1, 0xc6, 0x9f, 0xb3, 0xfa,
+    0xc7, 0xcb, 0xb3, 0x71, 0xc7, 0xcb, 0xb4, 0x83, 0xc7, 0xcb, 0xb6, 0x84,
+    0xc6, 0xfc, 0xb5, 0xd6, 0xc7, 0xa5, 0xb6, 0x84, 0xc6, 0xfc, 0xbb, 0x37,
+    0xc2, 0x4c, 0xbc, 0x4a, 0xc1, 0xe5, 0xbb, 0xe2, 0xc1, 0xa1, 0xbb, 0x9e,
+    0xc1, 0xa1, 0x02, 0x05, 0xbc, 0xb1, 0xbf, 0x15, 0xbc, 0xb1, 0xbf, 0x15,
+    0xbd, 0xa0, 0xbf, 0x36, 0xc0, 0x2c, 0xc0, 0x6c, 0xbf, 0xa4, 0xc0, 0x05,
+    0xc0, 0xb6, 0xc0, 0xd3, 0xc3, 0x20, 0xc1, 0xa1, 0xc2, 0xda, 0xc0, 0xd3,
+    0xc2, 0x52, 0xc1, 0x17, 0xc0, 0x72, 0xc1, 0x17, 0xc1, 0x66, 0xc1, 0x72,
+    0xbf, 0x5e, 0xc0, 0xb0, 0xbd, 0xe6, 0x41, 0xbe, 0x6f, 0xc0, 0x6c, 0x3a,
+    0xbf, 0xe2, 0x02, 0x02, 0xbd, 0x7f, 0xbe, 0x8c, 0xbe, 0xf7, 0xbf, 0x7c,
+    0xbe, 0xb4, 0xbe, 0x8c, 0xc3, 0x20, 0xbd, 0x9b, 0xc2, 0x52, 0xbe, 0x46,
+    0xc1, 0xeb, 0xbe, 0xcf, 0x02, 0x03, 0xc0, 0x2c, 0xc1, 0xc2, 0xc0, 0x93,
+    0xc1, 0xe5, 0xc1, 0x61, 0xc2, 0x08, 0xc2, 0xb9, 0xc2, 0x29, 0xc2, 0x52,
+    0xc1, 0xe5, 0xc3, 0x20, 0xc2, 0x6f, 0xc3, 0x41, 0xc3, 0x1a, 0xc3, 0x41,
+    0xc3, 0x1a, 0xc2, 0x73, 0xc2, 0xb3, 0x06, 0x08, 0xff, 0xaa, 0xb3, 0xfd,
+    0xc6, 0xa8, 0xb3, 0xc5, 0xc6, 0x54, 0xb4, 0x6c, 0xc6, 0x70, 0xb5, 0x83,
+    0xc5, 0x43, 0xb5, 0x4a, 0xc5, 0xb3, 0xb5, 0xba, 0xc4, 0xd4, 0xb6, 0x7e,
+    0xc4, 0x2b, 0xb5, 0xf3, 0xc4, 0x80, 0xb7, 0x09, 0xc3, 0xd8, 0xb8, 0xad,
+    0xc2, 0x51, 0xb8, 0x75, 0xc2, 0xc0, 0xb8, 0xe5, 0xc1, 0xe1, 0xb9, 0xa9,
+    0xc1, 0x1e, 0xba, 0x4e, 0xc0, 0xcc, 0xbb, 0x0e, 0xbf, 0x19, 0xb4, 0x18,
+    0xc5, 0xb4, 0x06, 0x08, 0xff, 0xaa, 0xb5, 0xb3, 0xc8, 0xa0, 0xb5, 0x7a,
+    0xc8, 0x4d, 0xb6, 0x22, 0xc8, 0x69, 0xb7, 0x37, 0xc7, 0x3a, 0xb7, 0x00,
+    0xc7, 0xaa, 0xb7, 0x6f, 0xc6, 0xcc, 0xb8, 0x34, 0xc6, 0x23, 0xb7, 0xa8,
+    0xc6, 0x77, 0xb8, 0xc0, 0xc5, 0xd0, 0xba, 0x62, 0xc4, 0x49, 0xba, 0x2b,
+    0xc4, 0xb9, 0xba, 0x9b, 0xc3, 0xd8, 0x35, 0xc3, 0x14, 0xbc, 0x5b, 0xc2,
+    0xe6, 0xbb, 0x95, 0xc2, 0x1a, 0xb5, 0xcd, 0xc7, 0xaa, 0x06, 0x08, 0xff,
+    0xe8, 0xb9, 0x19, 0xc9, 0x94, 0xb8, 0x9e, 0xc9, 0x22, 0xb9, 0x89, 0xc9,
+    0x5b, 0xba, 0x9f, 0xc8, 0x2f, 0xba, 0x68, 0xc8, 0x9d, 0xba, 0xd6, 0xc7,
+    0xbe, 0xbb, 0x9b, 0xc7, 0x17, 0xbb, 0x0f, 0xc7, 0x6b, 0xbc, 0x03, 0xc6,
+    0xd7, 0xbd, 0x6e, 0xc5, 0xa9, 0xbc, 0xe9, 0xc6, 0x2b, 0xbd, 0x9b, 0xc5,
+    0x7f, 0xbd, 0x29, 0xbb, 0x93, 0xc6, 0xdb, 0xbb, 0x05, 0xc6, 0xd7, 0xb9,
+    0x33, 0xc8, 0x9e, 0xb9, 0x33, 0xc8, 0x9e, 0xb9, 0x33, 0xc8, 0x9d, 0x06,
+    0x06, 0xff, 0x0e, 0xbc, 0xce, 0xca, 0x7b, 0xbb, 0xdb, 0xca, 0x48, 0xbd,
+    0x3e, 0xca, 0x43, 0xbe, 0x53, 0xc9, 0x15, 0xbe, 0x1b, 0xc9, 0x84, 0xbe,
+    0x8c, 0xc8, 0xa5, 0xbf, 0x4e, 0xc7, 0xfe, 0xbe, 0xc3, 0xc8, 0x51, 0xbf,
+    0xab, 0xc7, 0xc6, 0xc0, 0xf1, 0xc6, 0xbe, 0xc0, 0x6b, 0xc7, 0x38, 0xc1,
+    0x35, 0xc6, 0x81, 0xbf, 0xe0, 0xc6, 0x9f, 0xbc, 0xe8, 0xc9, 0x84, 0xbc,
+    0xe8, 0xc9, 0x84, 0xbc, 0xe9, 0xc9, 0x84, 0x02, 0x1e, 0xca, 0xe4, 0xbb,
+    0xfe, 0xca, 0xe4, 0xbc, 0x5f, 0xca, 0xe4, 0xbb, 0xb6, 0xca, 0xa6, 0xbb,
+    0x1a, 0xca, 0xd3, 0xbb, 0x6a, 0xca, 0x19, 0xba, 0x20, 0xc5, 0xec, 0xb8,
+    0xd4, 0xc8, 0x8c, 0xb9, 0x62, 0xc4, 0xd1, 0xb8, 0x99, 0xc4, 0x04, 0xb9,
+    0x39, 0xc4, 0x24, 0xb9, 0x1c, 0xc3, 0xfa, 0xb9, 0x3e, 0xc2, 0xdf, 0xb9,
+    0xca, 0xc3, 0x14, 0xb9, 0xb0, 0xc2, 0xa3, 0xb9, 0xaa, 0xc1, 0xaf, 0xb9,
+    0x70, 0xc2, 0x25, 0xb9, 0x6c, 0xc1, 0xaf, 0xb9, 0x70, 0xb7, 0xbb, 0xb9,
+    0x70, 0xb7, 0xbb, 0xb9, 0x70, 0xb6, 0xc9, 0xb9, 0x70, 0xb6, 0x1f, 0xbb,
+    0x4c, 0xb6, 0x1f, 0xba, 0x6b, 0xb6, 0x1f, 0xbb, 0xae, 0xb6, 0x7b, 0xbc,
+    0x44, 0xb6, 0x3e, 0xbc, 0x04, 0xb6, 0xa9, 0xbc, 0x76, 0xb7, 0x9b, 0xbc,
+    0xb2, 0xb7, 0x01, 0xbc, 0xb2, 0xb7, 0x9b, 0xbc, 0xb2, 0xbb, 0x19, 0xbc,
+    0xb2, 0xbb, 0x19, 0xbc, 0xb2, 0xbb, 0xb5, 0xbc, 0xbe, 0xbb, 0xdc, 0xbd,
+    0x0b, 0xbb, 0xd8, 0xbc, 0xda, 0xbb, 0xd1, 0xbd, 0x26, 0xbb, 0x84, 0xbd,
+    0xf5, 0xbb, 0x8d, 0xbd, 0xdc, 0xbb, 0x6d, 0xbe, 0x0b, 0xb3, 0x89, 0xc5,
+    0xaf, 0xb3, 0x89, 0xc5, 0xaf, 0xb3, 0x25, 0xc6, 0x11, 0x20, 0xc6, 0xcf,
+    0x20, 0xc6, 0x75, 0x20, 0xc7, 0x30, 0xb3, 0x68, 0xc7, 0xbf, 0xb3, 0x2c,
+    0xc7, 0x85, 0xb3, 0xb8, 0xc8, 0x10, 0xb4, 0xa8, 0xc8, 0x46, 0x23, 0xc8,
+    0x42, 0xb4, 0x5e, 0xc8, 0xc6, 0xb4, 0xce, 0xc9, 0xbb, 0xb4, 0x69, 0x58,
+    0xb5, 0x7d, 0xca, 0x78, 0x2d, 0xc9, 0xb5, 0xb6, 0xf5, 0xca, 0x98, 0xb8,
+    0x32, 0xc9, 0xc1, 0xb8, 0x38, 0xc9, 0xd9, 0xb8, 0x34, 0xc9, 0xcf, 0xb8,
+    0x65, 0xca, 0x5e, 0xb9, 0xb6, 0xca, 0xe6, 0xb8, 0xf3, 0xca, 0xc2, 0xba,
+    0x4f, 0xcb, 0x01, 0xbb, 0xd0, 0xca, 0x8a, 0xbb, 0x1f, 0xca, 0xf2, 0xbb,
+    0xd0, 0xca, 0x9f, 0xbb, 0xd9, 0xca, 0xc2, 0xbb, 0xd4, 0xca, 0xb3, 0xbb,
+    0xf5, 0xcb, 0x2c, 0xbc, 0xd8, 0xcb, 0x9c, 0xbc, 0x52, 0xcb, 0x7b, 0xbd,
+    0x8e, 0xcb, 0xca, 0xbf, 0xb2, 0xca, 0x97, 0xbe, 0xb9, 0xcb, 0x9f, 0xbf,
+    0xb0, 0xca, 0x99, 0xc5, 0x1f, 0xc5, 0x4a, 0xc5, 0x1f, 0xc5, 0x4a, 0xc5,
+    0x48, 0xc5, 0x21, 0xc9, 0x91, 0xc0, 0x71, 0xc9, 0x09, 0xc1, 0x5e, 0xc9,
+    0xda, 0xbf, 0xf1, 0xc9, 0xf4, 0xbf, 0x38, 0xc9, 0xf4, 0xbf, 0x99, 0xc9,
+    0xf4, 0xbe, 0xeb, 0xc9, 0xcc, 0xbe, 0x25, 0xc9, 0xe4, 0xbe, 0x98, 0xc9,
+    0xcc, 0xbe, 0x25, 0xca, 0x9a, 0xbd, 0x3a, 0xca, 0x9a, 0xbd, 0x3a, 0xca,
+    0x9a, 0xbd, 0x3a, 0x06, 0x35, 0xfb, 0xff, 0xbf, 0xfa, 0xbf, 0xaf, 0xfe,
+    0xbf, 0xea, 0xef, 0xff, 0xbf, 0xfe, 0x03, 0xca, 0x2d, 0xbc, 0xcf, 0xca,
+    0x41, 0xbc, 0x91, 0xca, 0x2d, 0xbc, 0xcf, 0xc9, 0x2c, 0xbd, 0xc0, 0xc9,
+    0x46, 0xbe, 0x41, 0xc9, 0x46, 0xbe, 0x41, 0xc9, 0x5d, 0xbe, 0xb2, 0xc9,
+    0x6c, 0xbf, 0x39, 0xc9, 0x6c, 0xbe, 0xfb, 0xc9, 0x6c, 0xbf, 0x88, 0xc9,
+    0x1a, 0xc0, 0x2c, 0xc9, 0x54, 0xbf, 0xc5, 0xc8, 0xb1, 0xc0, 0xe4, 0xc4,
+    0xbe, 0xc4, 0xe9, 0xc5, 0xd1, 0xc3, 0xd5, 0xc4, 0xbe, 0xc4, 0xe9, 0xbf,
+    0x4f, 0xca, 0x36, 0xbf, 0x4f, 0xca, 0x36, 0xbe, 0x7e, 0xcb, 0x17, 0xbc,
+    0xf9, 0xcb, 0x18, 0xbd, 0x8b, 0xcb, 0x3b, 0xbc, 0xa6, 0xcb, 0x02, 0xbc,
+    0x5d, 0xca, 0x9d, 0xbc, 0x6b, 0xca, 0xd5, 0xbc, 0x4b, 0xca, 0x5e, 0xbc,
+    0xc5, 0xc9, 0xb9, 0xbc, 0x71, 0xca, 0x0c, 0xbc, 0xc5, 0xc9, 0xb9, 0xbc,
+    0xc1, 0xc9, 0xb5, 0xbc, 0xc1, 0xc9, 0xb5, 0xbd, 0xce, 0xc8, 0xb0, 0xc1,
+    0xa6, 0xc4, 0xef, 0xc0, 0xa8, 0xc4, 0xc0, 0xc0, 0xdd, 0xc4, 0xf4, 0xbc,
+    0x18, 0xc9, 0x9b, 0xbc, 0x18, 0xc9, 0x9b, 0xbb, 0x77, 0xca, 0x5f, 0xb9,
+    0xcf, 0xca, 0x5f, 0xba, 0x79, 0xca, 0x7e, 0xb9, 0x41, 0xca, 0x45, 0xb8,
+    0xba, 0xc9, 0xae, 0xb8, 0xd5, 0xca, 0x00, 0xb8, 0xb5, 0xc9, 0x9f, 0xb8,
+    0xb3, 0xc9, 0x82, 0xb8, 0xb3, 0xc9, 0x91, 0xb8, 0xb3, 0xc9, 0x61, 0xb8,
+    0xce, 0xc9, 0x22, 0xb8, 0xbf, 0xc9, 0x40, 0xb9, 0x18, 0xc8, 0xd4, 0xb9,
+    0x70, 0xc8, 0x78, 0xb9, 0x6c, 0xc8, 0x71, 0xb9, 0x6c, 0xc8, 0x71, 0xba,
+    0x5c, 0xc7, 0x87, 0xbd, 0x6a, 0xc4, 0x8f, 0xbc, 0xcc, 0xc5, 0x2a, 0xbd,
+    0x82, 0xc4, 0x78, 0xbe, 0x01, 0xc4, 0x3f, 0xbc, 0xf5, 0xc3, 0xcd, 0xbd,
+    0x0a, 0xc4, 0x2f, 0xb8, 0xa8, 0xc8, 0x70, 0xb8, 0xa8, 0xc8, 0x70, 0xb8,
+    0x8b, 0xc8, 0x91, 0xb8, 0x62, 0xc8, 0xcd, 0xb8, 0x74, 0xc8, 0xaf, 0xb8,
+    0x62, 0xc8, 0xcd, 0xb8, 0x0f, 0xc9, 0x23, 0xb8, 0x0f, 0xc9, 0x23, 0xb6,
+    0xf9, 0xca, 0x16, 0xb5, 0x33, 0xc9, 0x5f, 0xb5, 0xac, 0xc9, 0xe1, 0xb5,
+    0x11, 0xc9, 0x3a, 0xb5, 0x01, 0x57, 0xb5, 0x01, 0xc9, 0x13, 0xb5, 0x01,
+    0xc8, 0xb5, 0xb5, 0x56, 0xc8, 0x43, 0xb5, 0x1d, 0xc8, 0x7c, 0xb5, 0x56,
+    0xc8, 0x43, 0xbb, 0x89, 0xc2, 0x71, 0xbb, 0x01, 0xc1, 0xb3, 0xba, 0xdb,
+    0xc2, 0x72, 0xb5, 0x5b, 0xc7, 0x84, 0xb5, 0x57, 0xc7, 0x80, 0xb5, 0x57,
+    0xc7, 0x80, 0xb4, 0xee, 0xc7, 0xe8, 0xb3, 0xc8, 0xc7, 0x60, 0xb4, 0x2e,
+    0xc7, 0xc5, 0xb3, 0x69, 0xc6, 0xff, 0xb3, 0xe8, 0xc6, 0x10, 0xb3, 0x75,
+    0xc6, 0x85, 0xb3, 0xe8, 0xc6, 0x10, 0xbb, 0xf9, 0xbe, 0x42, 0xbc, 0x67,
+    0xbd, 0x12, 0xbc, 0x67, 0xbd, 0x12, 0xbc, 0x67, 0xbc, 0x42, 0xbb, 0x1e,
+    0xbc, 0x29, 0xbb, 0x88, 0xbc, 0x31, 0xbb, 0x1e, 0xbc, 0x29, 0xb7, 0x9b,
+    0xbc, 0x29, 0xb7, 0x9b, 0xbc, 0x29, 0xb7, 0x47, 0xbc, 0x29, 0xb6, 0xde,
+    0xbb, 0xe7, 0xb7, 0x08, 0xbc, 0x12, 0xb6, 0xb1, 0xbb, 0xb7, 0xb6, 0xa9,
+    0xbb, 0x4c, 0xb6, 0xa9, 0xbb, 0x77, 0xb6, 0xa9, 0xba, 0xab, 0xb7, 0xbb,
+    0xb9, 0xf9, 0xb7, 0x1d, 0xb9, 0xf9, 0xb7, 0xbb, 0xb9, 0xf9, 0xc1, 0xb3,
+    0xb9, 0xf9, 0xc1, 0xb3, 0xb9, 0xf9, 0xc2, 0x13, 0xb9, 0xf6, 0xc2, 0xb8,
+    0xba, 0x52, 0xc2, 0x8f, 0xba, 0x38, 0xc2, 0xb8, 0xba, 0x52, 0xc2, 0xd8,
+    0xba, 0x68, 0xc4, 0x50, 0xb9, 0xac, 0xc4, 0x56, 0xb9, 0xa5, 0xc4, 0x56,
+    0xb9, 0xa5, 0xc4, 0x5c, 0xb9, 0xa0, 0xc5, 0xd0, 0xb9, 0x5a, 0xc4, 0xe4,
+    0xb9, 0x28, 0xc8, 0x3e, 0xb9, 0xde, 0xca, 0x30, 0x35, 0xc9, 0xb7, 0xba,
+    0x8c, 0xca, 0x4f, 0xbb, 0x94, 0xca, 0x59, 0xbb, 0xfe, 0xca, 0x59, 0xbb,
+    0xcb, 0xca, 0x59, 0xbc, 0x4b, 0x02, 0x07, 0xc3, 0x13, 0xbd, 0x34, 0xc3,
+    0xb9, 0xbc, 0x51, 0xc3, 0x8b, 0xbc, 0xca, 0xc4, 0x6e, 0xbb, 0xf7, 0xc3,
+    0xba, 0xbc, 0x15, 0xc5, 0x22, 0xbb, 0xd9, 0xc7, 0xe7, 0xbc, 0x7f, 0xc7,
+    0x14, 0xbb, 0xab, 0xc7, 0x40, 0xbc, 0x7f, 0xc5, 0xf5, 0xbd, 0xd9, 0xc6,
+    0x05, 0xbd, 0x51, 0xc5, 0xe7, 0xbe, 0x60, 0xc5, 0x5e, 0xbe, 0x16, 0xc5,
+    0x9b, 0xbe, 0x42, 0xc5, 0x22, 0xbd, 0xe8, 0xc4, 0xf5, 0xbd, 0x16, 0xc4,
+    0xf5, 0xbd, 0x60, 0xc4, 0xf5, 0xbc, 0xca, 0xc5, 0xc9, 0xbc, 0x51, 0xc5,
+    0x5e, 0xbc, 0x60, 0xc4, 0xb9, 0xbc, 0x6f, 0x06, 0x0b, 0xff, 0xee, 0x3f,
+    0xc9, 0x77, 0xbd, 0xda, 0xc9, 0x77, 0xbd, 0xda, 0xca, 0x5f, 0xbd, 0x12,
+    0xc9, 0x4a, 0xba, 0x63, 0xcb, 0x6e, 0xbb, 0x32, 0xc9, 0xb1, 0xbb, 0x32,
+    0xc8, 0x59, 0xbc, 0x67, 0xc8, 0xe3, 0xbc, 0x67, 0xc8, 0x59, 0xbc, 0xf0,
+    0xc7, 0x6a, 0xc0, 0x05, 0xc8, 0xe3, 0xbe, 0x46, 0xc7, 0x1a, 0xc0, 0x63,
+    0xc3, 0x2a, 0xc4, 0x32, 0xc1, 0xba, 0xc6, 0xb8, 0xc1, 0xba, 0xc6, 0xb8,
+    0xc0, 0xde, 0xc7, 0xa1, 0xbf, 0xe9, 0xc8, 0x99, 0xbd, 0xa0, 0xca, 0x9b,
+    0xbe, 0x2a, 0xca, 0x9b, 0xbd, 0x18, 0xca, 0x9b, 0xbd, 0x18, 0xcb, 0x47,
+    0xbc, 0x6c, 0xcb, 0x47, 0xbd, 0xc3, 0xcb, 0x47, 0xc1, 0x3f, 0xc8, 0x99,
+    0xbe, 0xf7, 0xca, 0xe0, 0xc3, 0x87, 0xc6, 0x51, 0xc9, 0xb1, 0xbf, 0x36,
+    0xc9, 0x8e, 0xc0, 0xd3, 0xc9, 0xd2, 0xbd, 0x9b, 0x02, 0x1c, 0xca, 0xd7,
+    0xbd, 0xfc, 0xca, 0xec, 0xbd, 0xbd, 0xca, 0xd7, 0xbd, 0xfc, 0xca, 0x53,
+    0xbe, 0xe5, 0xca, 0x53, 0xbe, 0xe5, 0xca, 0x53, 0xbe, 0xe5, 0xca, 0x24,
+    0xbf, 0x73, 0xca, 0x24, 0xbf, 0x73, 0xca, 0x3b, 0xbf, 0xe3, 0xca, 0x18,
+    0xc0, 0x64, 0xca, 0x18, 0x41, 0xca, 0x18, 0xc0, 0xb3, 0xc9, 0xc5, 0x44,
+    0xca, 0x00, 0x43, 0xc9, 0x5b, 0xc2, 0x10, 0xc5, 0x6a, 0xc6, 0x15, 0xc6,
+    0x7c, 0xc5, 0x02, 0xc5, 0x6a, 0xc6, 0x15, 0xbf, 0xfa, 0xcb, 0x62, 0xbf,
+    0xfa, 0xcb, 0x62, 0xbf, 0x28, 0xcc, 0x43, 0xbd, 0xa5, 0xcc, 0x43, 0xbe,
+    0x35, 0xcc, 0x67, 0xbd, 0x51, 0xcc, 0x2f, 0xbd, 0x07, 0xcb, 0xca, 0xbd,
+    0x17, 0xcc, 0x01, 0x39, 0xcb, 0x89, 0xbc, 0xc3, 0xca, 0xc7, 0xbc, 0x6d,
+    0xcb, 0x1a, 0xbc, 0x22, 0xcb, 0x8a, 0xba, 0x79, 0xcb, 0x8a, 0xbb, 0x25,
+    0xcb, 0xaa, 0xb9, 0xec, 0xcb, 0x70, 0xb8, 0xc4, 0x5b, 0xb8, 0xdf, 0xca,
+    0xd3, 0xb8, 0xbf, 0xca, 0x73, 0xb8, 0xba, 0xca, 0x4f, 0xb8, 0xba, 0xca,
+    0x4f, 0xb7, 0xa3, 0xcb, 0x40, 0xb5, 0xdd, 0xca, 0x89, 0xb6, 0x56, 0xcb,
+    0x0c, 0xb5, 0xbc, 0xca, 0x66, 0xb5, 0x2a, 0xc9, 0xe9, 0xb5, 0x2a, 0xca,
+    0x13, 0xb5, 0x2a, 0xc9, 0xb4, 0xb6, 0x03, 0xc8, 0xab, 0xb6, 0x03, 0xc8,
+    0xab, 0xb5, 0x9a, 0xc9, 0x14, 0xbc, 0xa5, 0xbf, 0x6e, 0xbc, 0xa5, 0xbf,
+    0x6e, 0xbc, 0xa5, 0xbf, 0x6e, 0xbd, 0x11, 0xbe, 0x3f, 0xbd, 0x11, 0xbe,
+    0x3f, 0xbd, 0x11, 0xbd, 0x6d, 0xbb, 0xc8, 0xbd, 0x54, 0xbc, 0x34, 0x3a,
+    0xbb, 0xc8, 0xbd, 0x54, 0xb8, 0x13, 0xbe, 0x34, 0xb8, 0x13, 0xbe, 0x34,
+    0xb7, 0xbf, 0xbe, 0x34, 0xb7, 0x56, 0xbd, 0xf2, 0xb7, 0x80, 0xbe, 0x1d,
+    0xb7, 0x29, 0x3b, 0xb7, 0x21, 0xbd, 0x57, 0xb7, 0x21, 0xbd, 0x82, 0xb7,
+    0x21, 0xbc, 0xb6, 0xb8, 0x34, 0xbc, 0x04, 0xb7, 0x95, 0xbc, 0x04, 0xb8,
+    0x34, 0xbc, 0x04, 0xc4, 0xfb, 0xba, 0xd7, 0xc4, 0xfb, 0xba, 0xd7, 0xc4,
+    0xfb, 0xba, 0xd7, 0xc5, 0x02, 0xba, 0xd1, 0xc5, 0x02, 0xba, 0xd1, 0xc5,
+    0x07, 0xba, 0xcc, 0xc6, 0x7b, 0xba, 0x86, 0xc5, 0x8e, 0xba, 0x54, 0x57,
+    0xbb, 0x09, 0xca, 0xda, 0xbc, 0x8a, 0xca, 0x63, 0xbb, 0xb7, 0xca, 0xfa,
+    0xbc, 0xc1, 0xcb, 0x04, 0xbd, 0x29, 0xcb, 0x04, 0x39, 0xcb, 0x04, 0xbd,
+    0x75, 0x11, 0x0a, 0x00, 0x01, 0x11, 0x00, 0x0a, 0x01, 0x01, 0x00, 0x00,
+    0x0a, 0x02, 0x01, 0x01, 0x00, 0x0a, 0x03, 0x01, 0x02, 0x00, 0x0a, 0x04,
+    0x01, 0x03, 0x00, 0x0a, 0x05, 0x01, 0x04, 0x00, 0x0a, 0x06, 0x01, 0x05,
+    0x00, 0x0a, 0x07, 0x01, 0x06, 0x00, 0x0a, 0x08, 0x01, 0x07, 0x00, 0x0a,
+    0x09, 0x01, 0x08, 0x00, 0x0a, 0x0a, 0x01, 0x09, 0x00, 0x0a, 0x0b, 0x01,
+    0x0a, 0x00, 0x0a, 0x0c, 0x01, 0x0b, 0x00, 0x0a, 0x0d, 0x01, 0x0c, 0x00,
+    0x0a, 0x0e, 0x02, 0x0d, 0x0e, 0x00, 0x0a, 0x0f, 0x01, 0x0f, 0x00, 0x0a,
+    0x10, 0x01, 0x10, 0x00
+};
+
+const unsigned char kFile[] = {
+    0x6e, 0x63, 0x69, 0x66, 0x04, 0x02, 0x00, 0x06, 0x03, 0x39, 0x9e, 0x0f,
+    0x3d, 0x9c, 0x0a, 0xbf, 0x82, 0xb2, 0x3b, 0x84, 0xa9, 0x4b, 0x88, 0x50,
+    0x48, 0x70, 0xc9, 0x00, 0xa5, 0xb1, 0xff, 0xbc, 0xea, 0xf1, 0xff, 0xff,
+    0xb3, 0xb8, 0xff, 0x05, 0x01, 0x02, 0x01, 0x06, 0x02, 0x3e, 0x49, 0x24,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0xaa, 0xaa, 0x49, 0x40, 0x00,
+    0x4a, 0x30, 0x00, 0xff, 0xc0, 0xd5, 0xff, 0x7c, 0x89, 0x6e, 0xff, 0x04,
+    0x01, 0x92, 0x04, 0x06, 0x06, 0xae, 0x0b, 0xb4, 0x0b, 0xbf, 0x4d, 0x33,
+    0xc3, 0xaf, 0xb7, 0x5d, 0xc1, 0x73, 0xbd, 0xef, 0xc6, 0x07, 0xc1, 0x3e,
+    0xc8, 0x04, 0xca, 0x28, 0xbd, 0x82, 0xc1, 0x18, 0xb9, 0x20, 0xc5, 0x1b,
+    0xbb, 0x40, 0xbf, 0x07, 0xb8, 0x08, 0x3a, 0xb6, 0xbc, 0x06, 0x05, 0xae,
+    0x02, 0xb5, 0x7d, 0x3e, 0xb9, 0xb9, 0xc3, 0xef, 0xb7, 0xbb, 0x44, 0xbb,
+    0xb7, 0x51, 0xbd, 0x75, 0xc9, 0x36, 0xca, 0x8e, 0xc1, 0xb1, 0x40, 0x2f,
+    0x0a, 0x09, 0x3b, 0x59, 0x3d, 0x5b, 0xbf, 0xcd, 0xc9, 0x3e, 0x45, 0x5b,
+    0xc5, 0x16, 0xc5, 0xf1, 0x60, 0x46, 0x5b, 0x43, 0x5d, 0x45, 0x44, 0x51,
+    0x0a, 0x04, 0x5a, 0x42, 0x5e, 0x3f, 0x5a, 0x3d, 0x57, 0x40, 0x05, 0x0a,
+    0x03, 0x02, 0x02, 0x03, 0x00, 0x0a, 0x01, 0x01, 0x01, 0x10, 0x01, 0x17,
+    0x84, 0x00, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x00, 0x0a, 0x01, 0x01, 0x00,
+    0x10, 0x01, 0x17, 0x84, 0x00, 0x04, 0x0a, 0x00, 0x01, 0x00, 0x00
+};