From f6b8ba3597d051b8f05647ce3fe80d870f805f57 Mon Sep 17 00:00:00 2001
From: Rebecca Wallander <sakcheen@gmail.com>
Date: Thu, 6 Jul 2023 00:04:46 +0200
Subject: [PATCH] Add A2R flux format support

---
 .../.idea/runConfigurations/Aaru.xml          |    2 +-
 Aaru.CommonTypes                              |    2 +-
 Aaru.Images/A2R/A2R.cs                        |   91 +
 Aaru.Images/A2R/Constants.cs                  |   71 +
 Aaru.Images/A2R/Enums.cs                      |   50 +
 Aaru.Images/A2R/Helpers.cs                    |  165 +
 Aaru.Images/A2R/Identify.cs                   |   57 +
 Aaru.Images/A2R/Properties.cs                 |   84 +
 Aaru.Images/A2R/Read.cs                       |  495 ++
 Aaru.Images/A2R/Structs.cs                    |  132 +
 Aaru.Images/A2R/Write.cs                      |  338 +
 Aaru.Images/Authors.cs                        |    5 +-
 .../Localization/Localization.Designer.cs     | 6780 +++++------------
 Aaru.Images/Localization/Localization.resx    |    3 +
 Aaru.Images/SuperCardPro/Read.cs              |   13 +-
 Aaru.Images/SuperCardPro/Write.cs             |    2 +-
 Aaru/Commands/Image/Convert.cs                |    2 +-
 17 files changed, 3448 insertions(+), 4844 deletions(-)
 create mode 100644 Aaru.Images/A2R/A2R.cs
 create mode 100644 Aaru.Images/A2R/Constants.cs
 create mode 100644 Aaru.Images/A2R/Enums.cs
 create mode 100644 Aaru.Images/A2R/Helpers.cs
 create mode 100644 Aaru.Images/A2R/Identify.cs
 create mode 100644 Aaru.Images/A2R/Properties.cs
 create mode 100644 Aaru.Images/A2R/Read.cs
 create mode 100644 Aaru.Images/A2R/Structs.cs
 create mode 100644 Aaru.Images/A2R/Write.cs

diff --git a/.idea/.idea.Aaru/.idea/runConfigurations/Aaru.xml b/.idea/.idea.Aaru/.idea/runConfigurations/Aaru.xml
index b0f2bb7b9..79ecc7a6c 100644
--- a/.idea/.idea.Aaru/.idea/runConfigurations/Aaru.xml
+++ b/.idea/.idea.Aaru/.idea/runConfigurations/Aaru.xml
@@ -1,6 +1,6 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Aaru" type="DotNetProject" factoryName=".NET Project">
-    <option name="EXE_PATH" value="$PROJECT_DIR$/Aaru/bin/Debug/net7.0/aaru.exe" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/Aaru/bin/Debug/net7.0/aaru" />
     <option name="PROGRAM_PARAMETERS" value="formats" />
     <option name="WORKING_DIRECTORY" value="$USER_HOME$/Desktop" />
     <option name="PASS_PARENT_ENVS" value="1" />
diff --git a/Aaru.CommonTypes b/Aaru.CommonTypes
index a10f12ebf..d007f1ac9 160000
--- a/Aaru.CommonTypes
+++ b/Aaru.CommonTypes
@@ -1 +1 @@
-Subproject commit a10f12ebf99ba888522ba9da32a65e50b48d143a
+Subproject commit d007f1ac9ac2a85c885c1be960107bd42fba5542
diff --git a/Aaru.Images/A2R/A2R.cs b/Aaru.Images/A2R/A2R.cs
new file mode 100644
index 000000000..b58fa529c
--- /dev/null
+++ b/Aaru.Images/A2R/A2R.cs
@@ -0,0 +1,91 @@
+// /***************************************************************************
+// Aaru Data Preservation Suite
+// ----------------------------------------------------------------------------
+//
+// Filename       : A2R.cs
+// Author(s)      : Rebecca Wallander <sakcheen@gmail.com>
+//
+// Component      : Disk image plugins.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Manages A2R flux images.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This library is free software; you can redistribute it and/or modify
+//     it under the terms of the GNU Lesser General Public License as
+//     published by the Free Software Foundation; either version 2.1 of the
+//     License, or (at your option) any later version.
+//
+//     This library is distributed in the hope that it will be useful, but
+//     WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//     Lesser General Public License for more details.
+//
+//     You should have received a copy of the GNU Lesser General Public
+//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2023 Rebecca Wallander
+// ****************************************************************************/
+
+// Version 2 documentation: https://web.archive.org/web/20200325131633/https://applesaucefdc.com/a2r/
+// Version 3 documentation: https://web.archive.org/web/20220526215820/https://applesaucefdc.com/a2r/
+
+using System.Collections.Generic;
+using System.IO;
+using Aaru.CommonTypes.Enums;
+using Aaru.CommonTypes.Interfaces;
+using Aaru.CommonTypes.Structs;
+
+namespace Aaru.DiscImages;
+
+/// <inheritdoc cref="Aaru.CommonTypes.Interfaces.IMediaImage" />
+/// <summary>Implements reading A2R flux images</summary>
+public sealed partial class A2R : IFluxImage, IMediaImage, IWritableImage, IWritableFluxImage
+{
+    ImageInfo                  _imageInfo;
+    Stream                     _a2rStream;
+    IFilter                    _a2rFilter;
+    FileStream                 _writingStream;
+    A2rHeader                  Header;
+    Dictionary<string, string> Meta;
+    InfoChunkV2                _infoChunkV2;
+    InfoChunkV3                _infoChunkV3;
+    List<StreamCapture>        _a2rCaptures;
+    uint                       _currentResolution;
+
+    // Offset from the start of the current RWCP to the next capture
+    uint _currentCaptureOffset = 16;
+
+    // 53 = A2R header, INFO header, INFO data
+    long _currentRwcpStart = 53;
+
+    public A2R()
+    {
+        _imageInfo = new ImageInfo
+        {
+            ReadableSectorTags    = new List<SectorTagType>(),
+            ReadableMediaTags     = new List<MediaTagType>(),
+            HasPartitions         = false,
+            HasSessions           = false,
+            Version               = null,
+            Application           = null,
+            ApplicationVersion    = null,
+            Creator               = null,
+            Comments              = null,
+            MediaManufacturer     = null,
+            MediaModel            = null,
+            MediaSerialNumber     = null,
+            MediaBarcode          = null,
+            MediaPartNumber       = null,
+            MediaSequence         = 0,
+            LastMediaSequence     = 0,
+            DriveManufacturer     = null,
+            DriveModel            = null,
+            DriveSerialNumber     = null,
+            DriveFirmwareRevision = null
+        };
+    }
+}
\ No newline at end of file
diff --git a/Aaru.Images/A2R/Constants.cs b/Aaru.Images/A2R/Constants.cs
new file mode 100644
index 000000000..5b7da91db
--- /dev/null
+++ b/Aaru.Images/A2R/Constants.cs
@@ -0,0 +1,71 @@
+// /***************************************************************************
+// Aaru Data Preservation Suite
+// ----------------------------------------------------------------------------
+//
+// Filename       : Constants.cs
+// Author(s)      : Rebecca Wallander <sakcheen@gmail.com>
+//
+// Component      : Disk image plugins.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Contains constants for A2R flux images.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This library is free software; you can redistribute it and/or modify
+//     it under the terms of the GNU Lesser General Public License as
+//     published by the Free Software Foundation; either version 2.1 of the
+//     License, or (at your option) any later version.
+//
+//     This library is distributed in the hope that it will be useful, but
+//     WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//     Lesser General Public License for more details.
+//
+//     You should have received a copy of the GNU Lesser General Public
+//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2023 Rebecca Wallander
+// ****************************************************************************/
+
+namespace Aaru.DiscImages;
+
+public sealed partial class A2R
+{
+    readonly byte[] _a2rV2Signature =
+    {
+        0x41, 0x32, 0x52, 0x32 // A2R2
+    };
+
+    readonly byte[] _a2rV3Signature =
+    {
+        0x41, 0x32, 0x52, 0x33 // A2R3
+    };
+
+    readonly byte[] _infoChunkSignature =
+    {
+        0x49, 0x4E, 0x46, 0x4F // INFO
+    };
+
+    readonly byte[] _rwcpChunkSignature =
+    {
+        0x52, 0x57, 0x43, 0x50 // RWCP
+    };
+
+    readonly byte[] _slvdChunkSignature =
+    {
+        0x53, 0x4C, 0x56, 0x44 // SLVD
+    };
+
+    readonly byte[] _metaChunkSignature =
+    {
+        0x4D, 0x45, 0x54, 0x41 // META
+    };
+
+    readonly byte[] _strmChunkSignature =
+    {
+        0x53, 0x54, 0x52, 0x4D // STRM
+    };
+}
\ No newline at end of file
diff --git a/Aaru.Images/A2R/Enums.cs b/Aaru.Images/A2R/Enums.cs
new file mode 100644
index 000000000..cfc85ac87
--- /dev/null
+++ b/Aaru.Images/A2R/Enums.cs
@@ -0,0 +1,50 @@
+// /***************************************************************************
+// Aaru Data Preservation Suite
+// ----------------------------------------------------------------------------
+//
+// Filename       : Enums.cs
+// Author(s)      : Rebecca Wallander <sakcheen@gmail.com>
+//
+// Component      : Disk image plugins.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Contains enumerations for A2R flux images.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This library is free software; you can redistribute it and/or modify
+//     it under the terms of the GNU Lesser General Public License as
+//     published by the Free Software Foundation; either version 2.1 of the
+//     License, or (at your option) any later version.
+//
+//     This library is distributed in the hope that it will be useful, but
+//     WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//     Lesser General Public License for more details.
+//
+//     You should have received a copy of the GNU Lesser General Public
+//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2023 Rebecca Wallander
+// ****************************************************************************/
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Aaru.DiscImages;
+
+public sealed partial class A2R
+{
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    public enum A2rDriveType : byte
+    {
+        SS_525_40trk_quarterStep = 0x1, DS_35_80trk_appleCLV = 0x2, DS_525_80trk = 0x3,
+        DS_525_40trk             = 0x4, DS_35_80trk          = 0x5, DS_8         = 0x6
+    }
+
+    public enum A2rDiskType : byte
+    {
+        _525 = 0x01, _35 = 0x2,
+    }
+}
\ No newline at end of file
diff --git a/Aaru.Images/A2R/Helpers.cs b/Aaru.Images/A2R/Helpers.cs
new file mode 100644
index 000000000..786e8a4fc
--- /dev/null
+++ b/Aaru.Images/A2R/Helpers.cs
@@ -0,0 +1,165 @@
+// /***************************************************************************
+// Aaru Data Preservation Suite
+// ----------------------------------------------------------------------------
+//
+// Filename       : Helpers.cs
+// Author(s)      : Rebecca Wallander <sakcheen@gmail.com>
+//
+// Component      : Disk image plugins.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Contains helpers for A2R flux images.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This library is free software; you can redistribute it and/or modify
+//     it under the terms of the GNU Lesser General Public License as
+//     published by the Free Software Foundation; either version 2.1 of the
+//     License, or (at your option) any later version.
+//
+//     This library is distributed in the hope that it will be useful, but
+//     WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//     Lesser General Public License for more details.
+//
+//     You should have received a copy of the GNU Lesser General Public
+//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2023 Rebecca Wallander
+// ****************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Aaru.CommonTypes;
+
+namespace Aaru.DiscImages;
+
+public sealed partial class A2R
+{
+    /// <summary>
+    /// Takes a Head, Track and Sub-Track representation, as well as the <c>MediaType</c>,
+    /// and converts it to the Track representation used by A2R.
+    /// </summary>
+    /// <param name="head">The head number</param>
+    /// <param name="track">The track number</param>
+    /// <param name="subTrack">The sub-track number</param>
+    /// <param name="mediaType">The media type of the image</param>
+    /// <returns>A2R format location</returns>
+    static long HeadTrackSubToA2rLocation(uint head, ushort track, byte subTrack, MediaType mediaType)
+    {
+        if(mediaType == MediaType.Apple32SS)
+            return head + (track * 4) + subTrack;
+
+        return head + (track * 2);
+    }
+
+    /// <summary>
+    /// Takes a Head, Track and Sub-Track representation, as well as the <c>A2rDriveType</c>,
+    /// and converts it to the Track representation used by A2R.
+    /// </summary>
+    /// <param name="head">The head number</param>
+    /// <param name="track">The track number</param>
+    /// <param name="subTrack">The sub-track number</param>
+    /// <param name="driveType">The drive type enum of the A2R image</param>
+    /// <returns>A2R format location</returns>
+    static long HeadTrackSubToA2rLocation(uint head, ushort track, byte subTrack, A2rDriveType driveType)
+    {
+        if(driveType == A2rDriveType.SS_525_40trk_quarterStep)
+            return head + (track * 4) + subTrack;
+
+        return head + (track * 2);
+    }
+
+    /// <summary>
+    /// Takes an A2R location and a <c>MediaType</c>, and converts it to a Head, Track and Sub-Track representation
+    /// used by the internal representation. The <c>MediaType</c> is needed because the track location is different
+    /// for different types of media sources.
+    /// </summary>
+    /// <param name="location">A2R format location</param>
+    /// <param name="mediaType"></param>
+    /// <param name="head">The head number</param>
+    /// <param name="track">The track number</param>
+    /// <param name="subTrack">The sub-track number</param>
+    static void A2rLocationToHeadTrackSub(uint location, MediaType mediaType, out uint head, out ushort track,
+                                          out byte subTrack)
+    {
+        if(mediaType == MediaType.Apple32SS)
+        {
+            head     = 0;
+            track    = (ushort)(location / 4);
+            subTrack = (byte)(location   % 4);
+
+            return;
+        }
+
+        head     = location % 2;
+        track    = (ushort)((location - head) / 2);
+        subTrack = 0;
+    }
+
+    /// <summary>
+    /// Takes a single number flux (uint length) and converts it to a flux in the
+    /// internal representation format (byte length)
+    /// </summary>
+    /// <param name="ticks">The <c>uint</c> flux representation</param>
+    /// <returns>The <c>byte[]</c> flux representation</returns>
+    static byte[] UInt32ToFluxRepresentation(uint ticks)
+    {
+        uint over = ticks / 255;
+
+        if(over == 0)
+            return new[]
+            {
+                (byte)ticks
+            };
+
+        byte[] expanded = new byte[over + 1];
+
+        Array.Fill(expanded, (byte)255, 0, (int)over);
+        expanded[^1] = (byte)(ticks % 255);
+
+        return expanded;
+    }
+
+    /// <summary>
+    /// Takes a flux representation in the internal format (byte length) and converts it to
+    /// an array of single number fluxes (uint length)
+    /// </summary>
+    /// <param name="flux">The <c>byte[]</c> flux representation</param>
+    /// <returns>The <c>uint</c> flux representation</returns>
+    static List<uint> FluxRepresentationsToUInt32List(IEnumerable<byte> flux)
+    {
+        List<uint> scpData = new();
+        uint       tick    = 0;
+
+        foreach(byte b in flux)
+        {
+            if(b == 255)
+                tick += 255;
+            else
+            {
+                tick += b;
+                scpData.Add(tick);
+                tick = 0;
+            }
+        }
+
+        return scpData;
+    }
+
+    /// <summary>
+    /// A2R has two types of flux capture types; "timing" and "xtiming". The only difference is the length of the
+    /// capture, with "timing" being about 1¼ revolutions. This function returns <c>true</c> if the flux buffer is "timing"
+    /// and <c>false</c> otherwise.
+    /// </summary>
+    /// <param name="resolution">The resolution of the flux capture</param>
+    /// <param name="buffer">The flux data</param>
+    /// <returns><c>true</c> if "timing", <c>false</c> if "xtiming"</returns>
+    static bool IsCaptureTypeTiming(ulong resolution, byte[] buffer) =>
+
+        // TODO: This is only accurate for 300rpm
+        buffer.Select(static x => (int)x).Sum() * (long)resolution is > 230000000000 and < 270000000000;
+}
\ No newline at end of file
diff --git a/Aaru.Images/A2R/Identify.cs b/Aaru.Images/A2R/Identify.cs
new file mode 100644
index 000000000..f31d559ae
--- /dev/null
+++ b/Aaru.Images/A2R/Identify.cs
@@ -0,0 +1,57 @@
+// /***************************************************************************
+// Aaru Data Preservation Suite
+// ----------------------------------------------------------------------------
+//
+// Filename       : Identify.cs
+// Author(s)      : Rebecca Wallander <sakcheen@gmail.com>
+//
+// Component      : Disk image plugins.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Identifies A2R flux images.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This library is free software; you can redistribute it and/or modify
+//     it under the terms of the GNU Lesser General Public License as
+//     published by the Free Software Foundation; either version 2.1 of the
+//     License, or (at your option) any later version.
+//
+//     This library is distributed in the hope that it will be useful, but
+//     WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//     Lesser General Public License for more details.
+//
+//     You should have received a copy of the GNU Lesser General Public
+//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2023 Rebecca Wallander
+// ****************************************************************************/
+
+using System.IO;
+using System.Linq;
+using Aaru.CommonTypes.Interfaces;
+using Aaru.Helpers;
+
+namespace Aaru.DiscImages;
+
+public sealed partial class A2R
+{
+    /// <inheritdoc />
+    public bool Identify(IFilter imageFilter)
+    {
+        Stream stream = imageFilter.GetDataForkStream();
+        stream.Seek(0, SeekOrigin.Begin);
+
+        if(stream.Length < 8)
+            return false;
+
+        byte[] hdr = new byte[4];
+
+        stream.EnsureRead(hdr, 0, 4);
+
+        return _a2rV2Signature.SequenceEqual(hdr) || _a2rV3Signature.SequenceEqual(hdr);
+    }
+}
\ No newline at end of file
diff --git a/Aaru.Images/A2R/Properties.cs b/Aaru.Images/A2R/Properties.cs
new file mode 100644
index 000000000..0ade183b7
--- /dev/null
+++ b/Aaru.Images/A2R/Properties.cs
@@ -0,0 +1,84 @@
+// /***************************************************************************
+// Aaru Data Preservation Suite
+// ----------------------------------------------------------------------------
+//
+// Filename       : Properties.cs
+// Author(s)      : Rebecca Wallander <sakcheen@gmail.com>
+//
+// Component      : Disk image plugins.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Contains properties for A2R flux images.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This library is free software; you can redistribute it and/or modify
+//     it under the terms of the GNU Lesser General Public License as
+//     published by the Free Software Foundation; either version 2.1 of the
+//     License, or (at your option) any later version.
+//
+//     This library is distributed in the hope that it will be useful, but
+//     WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//     Lesser General Public License for more details.
+//
+//     You should have received a copy of the GNU Lesser General Public
+//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2023 Rebecca Wallander
+// ****************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using Aaru.CommonTypes;
+using Aaru.CommonTypes.AaruMetadata;
+using Aaru.CommonTypes.Enums;
+using Aaru.CommonTypes.Structs;
+
+namespace Aaru.DiscImages;
+
+public sealed partial class A2R
+{
+    /// <inheritdoc />
+    public ImageInfo Info => _imageInfo;
+    /// <inheritdoc />
+    public string Name => Localization.A2R_Name;
+    /// <inheritdoc />
+    public Guid Id => new("7497c26a-fe44-4b50-a2e6-de50a9f3c13f");
+    /// <inheritdoc />
+    public string Author => Authors.RebeccaWallander;
+    /// <inheritdoc />
+    public string Format => "A2R";
+    /// <inheritdoc />
+    public List<DumpHardware> DumpHardware => null;
+    /// <inheritdoc />
+    public Metadata AaruMetadata => null;
+    /// <inheritdoc />
+    public IEnumerable<string> KnownExtensions => new[]
+    {
+        ".a2r"
+    };
+    /// <inheritdoc />
+    public IEnumerable<MediaTagType> SupportedMediaTags => null;
+    /// <inheritdoc />
+    public IEnumerable<MediaType> SupportedMediaTypes => new[]
+    {
+        // TODO: A2R supports a lot more formats, please add more whence tested.
+        MediaType.DOS_35_DS_DD_9, MediaType.DOS_35_HD, MediaType.DOS_525_DS_DD_9, MediaType.DOS_525_HD,
+        MediaType.Apple32SS,
+        MediaType.Unknown
+    };
+    /// <inheritdoc />
+    public IEnumerable<(string name, Type type, string description, object @default)> SupportedOptions =>
+        Array.Empty<(string name, Type type, string description, object @default)>();
+    /// <inheritdoc />
+    public IEnumerable<SectorTagType> SupportedSectorTags => Array.Empty<SectorTagType>();
+    /// <inheritdoc />
+    public bool IsWriting { get; private set; }
+    /// <inheritdoc />
+    public string ErrorMessage { get; private set; }
+    
+    bool IsWritingRwcps { get; set; }
+}
\ No newline at end of file
diff --git a/Aaru.Images/A2R/Read.cs b/Aaru.Images/A2R/Read.cs
new file mode 100644
index 000000000..93a2a9c46
--- /dev/null
+++ b/Aaru.Images/A2R/Read.cs
@@ -0,0 +1,495 @@
+// /***************************************************************************
+// Aaru Data Preservation Suite
+// ----------------------------------------------------------------------------
+//
+// Filename       : Read.cs
+// Author(s)      : Rebecca Wallander <sakcheen@gmail.com>
+//
+// Component      : Disk image plugins.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Reads A2R flux images.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This library is free software; you can redistribute it and/or modify
+//     it under the terms of the GNU Lesser General Public License as
+//     published by the Free Software Foundation; either version 2.1 of the
+//     License, or (at your option) any later version.
+//
+//     This library is distributed in the hope that it will be useful, but
+//     WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//     Lesser General Public License for more details.
+//
+//     You should have received a copy of the GNU Lesser General Public
+//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2023 Rebecca Wallander
+// ****************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Aaru.CommonTypes;
+using Aaru.CommonTypes.Enums;
+using Aaru.CommonTypes.Interfaces;
+using Aaru.Console;
+using Aaru.Helpers;
+
+namespace Aaru.DiscImages;
+
+public sealed partial class A2R
+{
+    /// <inheritdoc />
+    public ErrorNumber Open(IFilter imageFilter)
+    {
+        _a2rStream = imageFilter.GetDataForkStream();
+        _a2rStream.Seek(0, SeekOrigin.Begin);
+
+        _a2rFilter = imageFilter;
+
+        byte[] hdr = new byte[Marshal.SizeOf<A2rHeader>()];
+        _a2rStream.EnsureRead(hdr, 0, Marshal.SizeOf<A2rHeader>());
+
+        Header = Marshal.ByteArrayToStructureLittleEndian<A2rHeader>(hdr);
+
+        AaruConsole.DebugWriteLine("A2R plugin", "header.signature = \"{0}\"",
+                                   StringHandlers.CToString(Header.signature));
+
+        AaruConsole.DebugWriteLine("A2R plugin", "header.version = {0}", Header.version);
+        AaruConsole.DebugWriteLine("A2R plugin", "header.highBitTest = {0:X2}", Header.highBitTest);
+
+        AaruConsole.DebugWriteLine("A2R plugin", "header.lineTest = {0:X2} {1:X2} {2:X2}", Header.lineTest[0],
+                                   Header.lineTest[1], Header.lineTest[2]);
+
+        byte[] infoMagic = new byte[4];
+        _a2rStream.EnsureRead(infoMagic, 0, 4);
+
+        // There must be an INFO chunk after the header (at byte 16)
+        if(!_infoChunkSignature.SequenceEqual(infoMagic))
+            return ErrorNumber.UnrecognizedFormat;
+
+        _a2rStream.Seek(-4, SeekOrigin.Current);
+
+        switch(Header.version)
+        {
+            case 0x32:
+            {
+                byte[] infoChnk = new byte[Marshal.SizeOf<InfoChunkV2>()];
+                _a2rStream.EnsureRead(infoChnk, 0, Marshal.SizeOf<InfoChunkV2>());
+                _infoChunkV2 = Marshal.ByteArrayToStructureLittleEndian<InfoChunkV2>(infoChnk);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.header.chunkId = \"{0}\"",
+                                           StringHandlers.CToString(_infoChunkV2.header.chunkId));
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.header.chunkSize = {0}",
+                                           _infoChunkV2.header.chunkSize);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.version = {0}", _infoChunkV2.version);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.creator = \"{0}\"",
+                                           StringHandlers.CToString(_infoChunkV2.creator).TrimEnd());
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.diskType = {0}", _infoChunkV2.diskType);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.writeProtected = {0}", _infoChunkV2.writeProtected);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.synchronized = {0}", _infoChunkV2.synchronized);
+
+                _imageInfo.Creator = Encoding.ASCII.GetString(_infoChunkV2.creator).TrimEnd();
+
+                switch(_infoChunkV2.diskType)
+                {
+                    case A2rDiskType._35:
+                        _imageInfo.Heads           = 2;
+                        _imageInfo.Cylinders       = 80;
+                        _imageInfo.MediaType       = MediaType.AppleSonyDS;
+                        _imageInfo.SectorsPerTrack = 10;
+
+                        break;
+                    case A2rDiskType._525:
+                        _imageInfo.Heads     = 1;
+                        _imageInfo.Cylinders = 40;
+                        _imageInfo.MediaType = MediaType.Apple32SS;
+
+                        break;
+                    default: return ErrorNumber.OutOfRange;
+                }
+
+                break;
+            }
+            case 0x33:
+            {
+                byte[] infoChk = new byte[Marshal.SizeOf<InfoChunkV3>()];
+                _a2rStream.EnsureRead(infoChk, 0, Marshal.SizeOf<InfoChunkV3>());
+                _infoChunkV3 = Marshal.ByteArrayToStructureLittleEndian<InfoChunkV3>(infoChk);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.header.chunkId = \"{0}\"",
+                                           StringHandlers.CToString(_infoChunkV3.header.chunkId));
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.header.chunkSize = {0}",
+                                           _infoChunkV3.header.chunkSize);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.version = {0}", _infoChunkV3.version);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.creator = \"{0}\"",
+                                           StringHandlers.CToString(_infoChunkV3.creator).TrimEnd());
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.driveType = {0}", _infoChunkV3.driveType);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.writeProtected = {0}", _infoChunkV3.writeProtected);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.synchronized = {0}", _infoChunkV3.synchronized);
+
+                AaruConsole.DebugWriteLine("A2R plugin", "infoChunk.hardSectorCount = {0}",
+                                           _infoChunkV3.hardSectorCount);
+
+                _imageInfo.Creator = Encoding.ASCII.GetString(_infoChunkV3.creator).TrimEnd();
+
+                switch(_infoChunkV3.driveType)
+                {
+                    case A2rDriveType.SS_525_40trk_quarterStep:
+                        _imageInfo.Heads     = 1;
+                        _imageInfo.Cylinders = 40;
+                        _imageInfo.MediaType = MediaType.Apple32SS;
+
+                        break;
+                    case A2rDriveType.DS_35_80trk_appleCLV:
+                        _imageInfo.Heads           = 2;
+                        _imageInfo.Cylinders       = 80;
+                        _imageInfo.MediaType       = MediaType.AppleSonyDS;
+                        _imageInfo.SectorsPerTrack = 10;
+
+                        break;
+                    case A2rDriveType.DS_525_80trk:
+                        _imageInfo.Heads     = 2;
+                        _imageInfo.Cylinders = 80;
+                        _imageInfo.MediaType = MediaType.DOS_525_HD;
+
+                        break;
+                    case A2rDriveType.DS_525_40trk:
+                        _imageInfo.Heads           = 2;
+                        _imageInfo.Cylinders       = 40;
+                        _imageInfo.MediaType       = MediaType.DOS_525_DS_DD_9;
+                        _imageInfo.SectorsPerTrack = 9;
+
+                        break;
+                    case A2rDriveType.DS_35_80trk:
+                        _imageInfo.Heads           = 2;
+                        _imageInfo.Cylinders       = 80;
+                        _imageInfo.MediaType       = MediaType.DOS_35_HD;
+                        _imageInfo.SectorsPerTrack = 18;
+
+                        break;
+                    case A2rDriveType.DS_8:
+                        _imageInfo.Heads     = 2;
+                        _imageInfo.Cylinders = 40;
+
+                        break;
+                    default: return ErrorNumber.OutOfRange;
+                }
+
+                break;
+            }
+        }
+
+        _a2rCaptures = new List<StreamCapture>();
+
+        while(_a2rStream.Position < _a2rStream.Length)
+        {
+            byte[] chunkHdr = new byte[Marshal.SizeOf<ChunkHeader>()];
+            _a2rStream.EnsureRead(chunkHdr, 0, Marshal.SizeOf<ChunkHeader>());
+            ChunkHeader chunkHeader = Marshal.ByteArrayToStructureLittleEndian<ChunkHeader>(chunkHdr);
+            _a2rStream.Seek(-Marshal.SizeOf<ChunkHeader>(), SeekOrigin.Current);
+
+            switch(chunkHeader.chunkId)
+            {
+                case var rwcp when rwcp.SequenceEqual(_rwcpChunkSignature):
+                    byte[] rwcpBuffer = new byte[Marshal.SizeOf<RwcpChunkHeader>()];
+                    _a2rStream.EnsureRead(rwcpBuffer, 0, Marshal.SizeOf<RwcpChunkHeader>());
+                    RwcpChunkHeader rwcpChunk = Marshal.ByteArrayToStructureLittleEndian<RwcpChunkHeader>(rwcpBuffer);
+
+                    while(_a2rStream.ReadByte() == 0x43)
+                    {
+                        var capture = new StreamCapture
+                        {
+                            mark        = 0x43,
+                            captureType = (byte)_a2rStream.ReadByte()
+                        };
+
+                        byte[] location = new byte[2];
+                        _a2rStream.EnsureRead(location, 0, 2);
+                        capture.location = BitConverter.ToUInt16(location);
+
+                        A2rLocationToHeadTrackSub(capture.location, _imageInfo.MediaType, out capture.head,
+                                                  out capture.track, out capture.subTrack);
+
+                        if(capture.head + 1 > _imageInfo.Heads)
+                            _imageInfo.Heads = capture.head + 1;
+
+                        if(capture.track + 1 > _imageInfo.Cylinders)
+                            _imageInfo.Cylinders = (uint)(capture.track + 1);
+
+                        capture.numberOfIndexSignals = (byte)_a2rStream.ReadByte();
+                        capture.indexSignals         = new uint[capture.numberOfIndexSignals];
+
+                        for(int i = 0; capture.numberOfIndexSignals > i; i++)
+                        {
+                            byte[] index = new byte[4];
+                            _a2rStream.EnsureRead(index, 0, 4);
+                            capture.indexSignals[i] = BitConverter.ToUInt32(index);
+                        }
+
+                        byte[] dataSize = new byte[4];
+                        _a2rStream.EnsureRead(dataSize, 0, 4);
+                        capture.captureDataSize = BitConverter.ToUInt32(dataSize);
+
+                        capture.dataOffset = _a2rStream.Position;
+
+                        capture.resolution = rwcpChunk.resolution;
+
+                        _a2rCaptures.Add(capture);
+
+                        _a2rStream.Seek(capture.captureDataSize, SeekOrigin.Current);
+                    }
+
+                    break;
+                case var meta when meta.SequenceEqual(_metaChunkSignature):
+                    Meta = new Dictionary<string, string>();
+
+                    _a2rStream.Seek(Marshal.SizeOf<ChunkHeader>(), SeekOrigin.Current);
+
+                    byte[] metadataBuffer = new byte[chunkHeader.chunkSize];
+                    _a2rStream.EnsureRead(metadataBuffer, 0, (int)chunkHeader.chunkSize);
+
+                    string metaData = Encoding.UTF8.GetString(metadataBuffer);
+
+                    string[] metaFields = metaData.Split('\n');
+
+                    foreach(string field in metaFields)
+                    {
+                        string[] keyValue = field.Split('\t');
+
+                        if(keyValue.Length == 2)
+                            Meta.Add(keyValue[0], keyValue[1]);
+                    }
+
+                    if(Meta.TryGetValue("image_date", out string imageDate))
+                        _imageInfo.CreationTime = DateTime.Parse(imageDate);
+
+                    if(Meta.TryGetValue("title", out string title))
+                        _imageInfo.MediaTitle = title;
+
+                    break;
+                case var slvd when slvd.SequenceEqual(_slvdChunkSignature): return ErrorNumber.NotImplemented;
+                case var strm when strm.SequenceEqual(_strmChunkSignature):
+                    byte[] strmBuffer = new byte[Marshal.SizeOf<ChunkHeader>()];
+                    _a2rStream.EnsureRead(strmBuffer, 0, Marshal.SizeOf<ChunkHeader>());
+                    ChunkHeader strmChunk = Marshal.ByteArrayToStructureLittleEndian<ChunkHeader>(strmBuffer);
+
+                    long end = strmChunk.chunkSize + _a2rStream.Position - 1;
+
+                    while(_a2rStream.Position < end)
+                    {
+                        var capture = new StreamCapture
+                        {
+                            indexSignals         = new uint[1],
+                            location             = (byte)_a2rStream.ReadByte(),
+                            captureType          = (byte)_a2rStream.ReadByte(),
+                            resolution           = 125000,
+                            numberOfIndexSignals = 1
+                        };
+
+                        A2rLocationToHeadTrackSub(capture.location, _imageInfo.MediaType, out capture.head,
+                                                  out capture.track, out capture.subTrack);
+
+                        if(capture.head + 1 > _imageInfo.Heads)
+                            _imageInfo.Heads = capture.head + 1;
+
+                        if(capture.track + 1 > _imageInfo.Cylinders)
+                            _imageInfo.Cylinders = (uint)(capture.track + 1);
+
+                        byte[] dataSize = new byte[4];
+                        _a2rStream.EnsureRead(dataSize, 0, 4);
+                        capture.captureDataSize = BitConverter.ToUInt32(dataSize);
+
+                        byte[] index = new byte[4];
+                        _a2rStream.EnsureRead(index, 0, 4);
+                        capture.indexSignals[0] = BitConverter.ToUInt32(index);
+
+                        capture.dataOffset = _a2rStream.Position;
+
+                        _a2rCaptures.Add(capture);
+
+                        _a2rStream.Seek(capture.captureDataSize, SeekOrigin.Current);
+                    }
+
+                    _a2rStream.ReadByte();
+
+                    break;
+            }
+        }
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <inheritdoc />
+    public ErrorNumber CapturesLength(uint head, ushort track, byte subTrack, out uint length)
+    {
+        long index = HeadTrackSubToA2rLocation(head, track, subTrack, _imageInfo.MediaType);
+
+        length = (uint)_a2rCaptures.FindAll(capture => index == capture.location).Count;
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <inheritdoc />
+    public ErrorNumber ReadFluxIndexResolution(uint head, ushort track, byte subTrack, uint captureIndex,
+                                               out ulong resolution)
+    {
+        resolution = StreamCaptureAtIndex(head, track, subTrack, captureIndex).resolution;
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <inheritdoc />
+    public ErrorNumber ReadFluxDataResolution(uint head, ushort track, byte subTrack, uint captureIndex,
+                                              out ulong resolution)
+    {
+        resolution = StreamCaptureAtIndex(head, track, subTrack, captureIndex).resolution;
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <inheritdoc />
+    public ErrorNumber ReadFluxResolution(uint head, ushort track, byte subTrack, uint captureIndex,
+                                          out ulong indexResolution, out ulong dataResolution)
+    {
+        indexResolution = dataResolution = StreamCaptureAtIndex(head, track, subTrack, captureIndex).resolution;
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <inheritdoc />
+    public ErrorNumber ReadFluxCapture(uint head, ushort track, byte subTrack, uint captureIndex,
+                                       out ulong indexResolution, out ulong dataResolution, out byte[] indexBuffer,
+                                       out byte[] dataBuffer)
+    {
+        dataBuffer = indexBuffer = null;
+
+        ErrorNumber error =
+            ReadFluxResolution(head, track, subTrack, captureIndex, out indexResolution, out dataResolution);
+
+        if(error != ErrorNumber.NoError)
+            return error;
+
+        error = ReadFluxDataCapture(head, track, subTrack, captureIndex, out dataBuffer);
+
+        if(error != ErrorNumber.NoError)
+            return error;
+
+        error = ReadFluxIndexCapture(head, track, subTrack, captureIndex, out indexBuffer);
+
+        return error;
+    }
+
+    /// <inheritdoc />
+    public ErrorNumber ReadFluxIndexCapture(uint head, ushort track, byte subTrack, uint captureIndex,
+                                            out byte[] buffer)
+    {
+        buffer = null;
+
+        List<byte> tmpBuffer = new()
+        {
+            // A2R always starts at index signal
+            0
+        };
+
+        StreamCapture capture = StreamCaptureAtIndex(head, track, subTrack, captureIndex);
+
+        uint previousTicks = 0;
+
+        for(int i = 0; i < capture.numberOfIndexSignals; i++)
+        {
+            uint ticks = capture.indexSignals[i] - previousTicks;
+            tmpBuffer.AddRange(UInt32ToFluxRepresentation(ticks));
+
+            previousTicks = capture.indexSignals[i];
+        }
+
+        buffer = tmpBuffer.ToArray();
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <inheritdoc />
+    public ErrorNumber ReadFluxDataCapture(uint head, ushort track, byte subTrack, uint captureIndex, out byte[] buffer)
+    {
+        buffer = null;
+
+        StreamCapture capture = StreamCaptureAtIndex(head, track, subTrack, captureIndex);
+
+        if(capture.captureType == 2)
+            return ErrorNumber.NotImplemented;
+
+        Stream stream = _a2rFilter.GetDataForkStream();
+        var    br     = new BinaryReader(stream);
+
+        br.BaseStream.Seek(capture.dataOffset, SeekOrigin.Begin);
+        buffer = br.ReadBytes((int)capture.captureDataSize);
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <inheritdoc />
+    public ErrorNumber SubTrackLength(uint head, ushort track, out byte length)
+    {
+        length = 0;
+
+        List<StreamCapture> captures = _a2rCaptures.FindAll(c => c.head == head && c.track == track);
+
+        if(captures.Count <= 0)
+            return ErrorNumber.OutOfRange;
+
+        length = (byte)(captures.Max(static c => c.subTrack) + 1);
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <inheritdoc />
+    public ErrorNumber ReadMediaTag(MediaTagType tag, out byte[] buffer) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public ErrorNumber ReadSector(ulong sectorAddress, out byte[] buffer) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public ErrorNumber ReadSectorLong(ulong sectorAddress, out byte[] buffer) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public ErrorNumber ReadSectors(ulong sectorAddress, uint length, out byte[] buffer) =>
+        throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public ErrorNumber ReadSectorsLong(ulong sectorAddress, uint length, out byte[] buffer) =>
+        throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public ErrorNumber ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag, out byte[] buffer) =>
+        throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public ErrorNumber ReadSectorTag(ulong sectorAddress, SectorTagType tag, out byte[] buffer) =>
+        throw new NotImplementedException();
+
+    StreamCapture StreamCaptureAtIndex(uint head, ushort track, byte subTrack, uint captureIndex)
+    {
+        long index = HeadTrackSubToA2rLocation(head, track, subTrack, _imageInfo.MediaType);
+
+        return _a2rCaptures.FindAll(capture => index == capture.location)[(int)captureIndex];
+    }
+}
\ No newline at end of file
diff --git a/Aaru.Images/A2R/Structs.cs b/Aaru.Images/A2R/Structs.cs
new file mode 100644
index 000000000..d8eb8f81c
--- /dev/null
+++ b/Aaru.Images/A2R/Structs.cs
@@ -0,0 +1,132 @@
+// /***************************************************************************
+// Aaru Data Preservation Suite
+// ----------------------------------------------------------------------------
+//
+// Filename       : Structs.cs
+// Author(s)      : Rebecca Wallander <sakcheen@gmail.com>
+//
+// Component      : Disk image plugins.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Contains structures for A2R flux images.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This library is free software; you can redistribute it and/or modify
+//     it under the terms of the GNU Lesser General Public License as
+//     published by the Free Software Foundation; either version 2.1 of the
+//     License, or (at your option) any later version.
+//
+//     This library is distributed in the hope that it will be useful, but
+//     WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//     Lesser General Public License for more details.
+//
+//     You should have received a copy of the GNU Lesser General Public
+//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2023 Rebecca Wallander
+// ****************************************************************************/
+
+using System.Runtime.InteropServices;
+
+namespace Aaru.DiscImages;
+
+public sealed partial class A2R
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct A2rHeader
+    {
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
+        public byte[] signature;
+        public byte version;
+        public byte highBitTest; // Should always be 0xFF
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
+        public byte[] lineTest; // Should always be 0x0A 0x0D 0x0A
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct ChunkHeader
+    {
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
+        public byte[] chunkId;
+        public uint chunkSize;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct InfoChunkV2
+    {
+        public ChunkHeader header;
+        public byte        version;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
+        public byte[] creator;
+        public A2rDiskType diskType;
+        public byte        writeProtected;
+        public byte        synchronized;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct InfoChunkV3
+    {
+        public ChunkHeader header;
+        public byte        version;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
+        public byte[] creator;
+        public A2rDriveType driveType;
+        public byte         writeProtected;
+        public byte         synchronized;
+        public byte         hardSectorCount;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct RwcpChunkHeader
+    {
+        public ChunkHeader header;
+        public byte        version;
+        public uint        resolution;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 11)]
+        public byte[] reserved;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct StreamCapture
+    {
+        public byte   mark;
+        public byte   captureType;
+        public ushort location;
+        public byte   numberOfIndexSignals;
+        public uint[] indexSignals;
+        public uint   captureDataSize;
+        public long   dataOffset;
+        public uint   resolution;
+        public uint   head;
+        public ushort track;
+        public byte   subTrack;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct SlvdChunkHeader
+    {
+        public ChunkHeader header;
+        public byte        version;
+        public uint        resolution;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 11)]
+        public byte[] reserved;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct TrackHeader
+    {
+        public byte   mark;
+        public ushort location;
+        public byte   mirrorDistanceOutward;
+        public byte   mirrorDistanceInward;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
+        public byte[] reserved;
+        public byte   numberOfIndexSignals;
+        public uint[] indexSignals;
+        public uint   fluxDataSize;
+    }
+}
\ No newline at end of file
diff --git a/Aaru.Images/A2R/Write.cs b/Aaru.Images/A2R/Write.cs
new file mode 100644
index 000000000..fdcdeff78
--- /dev/null
+++ b/Aaru.Images/A2R/Write.cs
@@ -0,0 +1,338 @@
+// /***************************************************************************
+// Aaru Data Preservation Suite
+// ----------------------------------------------------------------------------
+//
+// Filename       : Write.cs
+// Author(s)      : Rebecca Wallander <sakcheen@gmail.com>
+//
+// Component      : Disk image plugins.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Writes A2R flux images.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This library is free software; you can redistribute it and/or modify
+//     it under the terms of the GNU Lesser General Public License as
+//     published by the Free Software Foundation; either version 2.1 of the
+//     License, or (at your option) any later version.
+//
+//     This library is distributed in the hope that it will be useful, but
+//     WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//     Lesser General Public License for more details.
+//
+//     You should have received a copy of the GNU Lesser General Public
+//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2023 Rebecca Wallander
+// ****************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Aaru.CommonTypes;
+using Aaru.CommonTypes.AaruMetadata;
+using Aaru.CommonTypes.Enums;
+using Aaru.CommonTypes.Structs;
+using Aaru.Helpers;
+
+namespace Aaru.DiscImages;
+
+public sealed partial class A2R
+{
+    /// <inheritdoc />
+    public bool Create(string path, MediaType mediaType, Dictionary<string, string> options, ulong sectors,
+                       uint sectorSize)
+    {
+        try
+        {
+            _writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
+        }
+        catch(IOException e)
+        {
+            ErrorMessage = string.Format(Localization.Could_not_create_new_image_file_exception_0, e.Message);
+
+            return false;
+        }
+
+        IsWriting    = true;
+        ErrorMessage = null;
+
+        Header.signature   = "A2R"u8.ToArray();
+        Header.version     = 0x33;
+        Header.highBitTest = 0xFF;
+        Header.lineTest    = "\n\r\n"u8.ToArray();
+
+        _infoChunkV3.driveType = mediaType switch
+        {
+            MediaType.DOS_525_DS_DD_9 => A2rDriveType.DS_525_40trk,
+            MediaType.Apple32SS       => A2rDriveType.SS_525_40trk_quarterStep,
+            MediaType.Unknown         => A2rDriveType.DS_35_80trk,
+            _                         => _infoChunkV3.driveType
+        };
+
+        return true;
+    }
+
+    /// <inheritdoc />
+    public bool Close()
+    {
+        if(!IsWriting)
+        {
+            ErrorMessage = Localization.Image_is_not_opened_for_writing;
+
+            return false;
+        }
+
+        _writingStream.Seek(0, SeekOrigin.Begin);
+
+        _writingStream.Write(Header.signature, 0, 3);
+        _writingStream.WriteByte(Header.version);
+        _writingStream.WriteByte(Header.highBitTest);
+        _writingStream.Write(Header.lineTest, 0, 3);
+
+        // First chunk needs to be an INFO chunk
+        WriteInfoChunk();
+
+        _writingStream.Seek(_currentRwcpStart, SeekOrigin.Begin);
+
+        WriteRwcpHeader();
+
+        _writingStream.Seek(0, SeekOrigin.End);
+        CloseRwcpChunk();
+
+        WriteMetaChunk();
+
+        _writingStream.Flush();
+        _writingStream.Close();
+
+        IsWriting    = false;
+        ErrorMessage = "";
+
+        return true;
+    }
+
+    /// <inheritdoc />
+    public bool SetImageInfo(ImageInfo imageInfo)
+    {
+        Meta = new Dictionary<string, string>();
+
+        _infoChunkV3.header.chunkId   = _infoChunkSignature;
+        _infoChunkV3.header.chunkSize = 37;
+        _infoChunkV3.version          = 1;
+
+        _infoChunkV3.creator =
+            Encoding.UTF8.GetBytes($"Aaru v{typeof(A2R).Assembly.GetName().Version?.ToString()}".PadRight(32, ' '));
+
+        _infoChunkV3.writeProtected  = 1;
+        _infoChunkV3.synchronized    = 1;
+        _infoChunkV3.hardSectorCount = 0;
+
+        Meta.Add("image_date", DateTime.Now.ToString("O"));
+        Meta.Add("title", imageInfo.MediaTitle);
+
+        return true;
+    }
+
+    /// <inheritdoc />
+    public bool SetGeometry(uint cylinders, uint heads, uint sectorsPerTrack) => true;
+
+    /// <inheritdoc />
+    public bool WriteSectorTag(byte[] data, ulong sectorAddress, SectorTagType tag) => false;
+
+    /// <inheritdoc />
+    public bool WriteSectorsTag(byte[] data, ulong sectorAddress, uint length, SectorTagType tag) => false;
+
+    /// <inheritdoc />
+    public bool SetDumpHardware(List<DumpHardware> dumpHardware) => false;
+
+    /// <inheritdoc />
+    public bool SetMetadata(Metadata metadata) => false;
+
+    /// <inheritdoc />
+    public bool WriteMediaTag(byte[] data, MediaTagType tag) => false;
+
+    /// <inheritdoc />
+    public bool WriteSector(byte[] data, ulong sectorAddress) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public bool WriteSectorLong(byte[] data, ulong sectorAddress) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public bool WriteSectors(byte[] data, ulong sectorAddress, uint length) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public bool WriteSectorsLong(byte[] data, ulong sectorAddress, uint length) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public ErrorNumber WriteFluxCapture(ulong indexResolution, ulong dataResolution, byte[] indexBuffer,
+                                        byte[] dataBuffer, uint head, ushort track, byte subTrack, uint captureIndex)
+    {
+        if(!IsWriting)
+        {
+            ErrorMessage = Localization.Tried_to_write_on_a_non_writable_image;
+
+            return ErrorNumber.WriteError;
+        }
+
+        // An RWCP chunk can only have one capture resolution. If the resolution changes we need to create a new chunk.
+        if(_currentResolution != dataResolution)
+        {
+            if(IsWritingRwcps)
+            {
+                CloseRwcpChunk();
+
+                _writingStream.Seek(_currentRwcpStart, SeekOrigin.Begin);
+                WriteRwcpHeader();
+
+                _currentRwcpStart     = _writingStream.Length;
+                _currentCaptureOffset = 16;
+            }
+
+            IsWritingRwcps = true;
+
+            _currentResolution = (uint)dataResolution;
+        }
+
+        _writingStream.Seek(_currentRwcpStart + _currentCaptureOffset + Marshal.SizeOf<ChunkHeader>(),
+                            SeekOrigin.Begin);
+
+        _writingStream.WriteByte(0x43);
+
+        _writingStream.WriteByte(IsCaptureTypeTiming(dataResolution, dataBuffer) ? (byte)1 : (byte)3);
+
+        _writingStream.
+            Write(BitConverter.GetBytes((ushort)HeadTrackSubToA2rLocation(head, track, subTrack, _infoChunkV3.driveType)),
+                  0, 2);
+
+        List<uint> a2rIndices = FluxRepresentationsToUInt32List(indexBuffer);
+
+        if(a2rIndices[0] == 0)
+            a2rIndices.RemoveAt(0);
+
+        _writingStream.WriteByte((byte)a2rIndices.Count);
+
+        long previousIndex = 0;
+
+        foreach(uint index in a2rIndices)
+        {
+            _writingStream.Write(BitConverter.GetBytes(index + previousIndex), 0, 4);
+            previousIndex += index;
+        }
+
+        _writingStream.Write(BitConverter.GetBytes(dataBuffer.Length), 0, 4);
+        _writingStream.Write(dataBuffer, 0, dataBuffer.Length);
+
+        _currentCaptureOffset += (uint)(9 + (a2rIndices.Count * 4) + dataBuffer.Length);
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <inheritdoc />
+    public ErrorNumber WriteFluxIndexCapture(ulong resolution, byte[] index, uint head, ushort track, byte subTrack,
+                                             uint captureIndex) => ErrorNumber.NoError;
+
+    /// <inheritdoc />
+    public ErrorNumber WriteFluxDataCapture(ulong resolution, byte[] data, uint head, ushort track, byte subTrack,
+                                            uint captureIndex) => ErrorNumber.NoError;
+
+    /// <summary>
+    /// writes the header to an RWCP chunk, up to and including the reserved bytes, to stream.
+    /// </summary>
+    /// <returns></returns>
+    ErrorNumber WriteRwcpHeader()
+    {
+        if(!IsWriting)
+        {
+            ErrorMessage = Localization.Tried_to_write_on_a_non_writable_image;
+
+            return ErrorNumber.WriteError;
+        }
+
+        _writingStream.Write(_rwcpChunkSignature, 0, 4);
+        _writingStream.Write(BitConverter.GetBytes(_currentCaptureOffset + 1), 0, 4);
+        _writingStream.WriteByte(1);
+        _writingStream.Write(BitConverter.GetBytes(_currentResolution), 0, 4);
+
+        byte[] reserved =
+        {
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        };
+
+        _writingStream.Write(reserved, 0, 11);
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <summary>
+    /// Writes the entire INFO chunk to stream.
+    /// </summary>
+    /// <returns></returns>
+    ErrorNumber WriteInfoChunk()
+    {
+        if(!IsWriting)
+        {
+            ErrorMessage = Localization.Tried_to_write_on_a_non_writable_image;
+
+            return ErrorNumber.WriteError;
+        }
+
+        _writingStream.Write(_infoChunkV3.header.chunkId, 0, 4);
+        _writingStream.Write(BitConverter.GetBytes(_infoChunkV3.header.chunkSize), 0, 4);
+        _writingStream.WriteByte(_infoChunkV3.version);
+        _writingStream.Write(_infoChunkV3.creator, 0, 32);
+        _writingStream.WriteByte((byte)_infoChunkV3.driveType);
+        _writingStream.WriteByte(_infoChunkV3.writeProtected);
+        _writingStream.WriteByte(_infoChunkV3.synchronized);
+        _writingStream.WriteByte(_infoChunkV3.hardSectorCount);
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <summary>
+    /// Writes the entire META chunk to stream.
+    /// </summary>
+    /// <returns></returns>
+    ErrorNumber WriteMetaChunk()
+    {
+        if(!IsWriting)
+        {
+            ErrorMessage = Localization.Tried_to_write_on_a_non_writable_image;
+
+            return ErrorNumber.WriteError;
+        }
+
+        _writingStream.Write(_metaChunkSignature, 0, 4);
+
+        byte[] metaString = Encoding.UTF8.GetBytes(Meta.Select(static m => $"{m.Key}\t{m.Value}").
+                                                        Aggregate(static (concat, str) => $"{concat}\n{str}") + '\n');
+
+        _writingStream.Write(BitConverter.GetBytes((uint)metaString.Length), 0, 4);
+        _writingStream.Write(metaString, 0, metaString.Length);
+
+        return ErrorNumber.NoError;
+    }
+
+    /// <summary>
+    /// Writes the closing byte to an RWCP chunk signaling its end, to stream.
+    /// </summary>
+    /// <returns></returns>
+    ErrorNumber CloseRwcpChunk()
+    {
+        if(!IsWriting)
+        {
+            ErrorMessage = Localization.Tried_to_write_on_a_non_writable_image;
+
+            return ErrorNumber.WriteError;
+        }
+
+        _writingStream.WriteByte(0x58);
+
+        return ErrorNumber.NoError;
+    }
+}
\ No newline at end of file
diff --git a/Aaru.Images/Authors.cs b/Aaru.Images/Authors.cs
index 30c623d4a..da2afed4c 100644
--- a/Aaru.Images/Authors.cs
+++ b/Aaru.Images/Authors.cs
@@ -33,6 +33,7 @@ namespace Aaru.DiscImages;
 [SuppressMessage("ReSharper", "InconsistentNaming")]
 static class Authors
 {
-    internal const string MichaelDruing = "Michael Drüing";
-    internal const string NataliaPortillo = "Natalia Portillo";
+    internal const string MichaelDruing    = "Michael Drüing";
+    internal const string NataliaPortillo  = "Natalia Portillo";
+    internal const string RebeccaWallander = "Rebecca Wallander";
 }
\ No newline at end of file
diff --git a/Aaru.Images/Localization/Localization.Designer.cs b/Aaru.Images/Localization/Localization.Designer.cs
index ee28d4437..85316b7ec 100644
--- a/Aaru.Images/Localization/Localization.Designer.cs
+++ b/Aaru.Images/Localization/Localization.Designer.cs
@@ -11,46 +11,32 @@ namespace Aaru.DiscImages {
     using System;
     
     
-    /// <summary>
-    ///   A strongly-typed resource class, for looking up localized strings, etc.
-    /// </summary>
-    // This class was auto-generated by the StronglyTypedResourceBuilder
-    // class via a tool like ResGen or Visual Studio.
-    // To add or remove a member, edit your .ResX file then rerun ResGen
-    // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     internal class Localization {
         
-        private static global::System.Resources.ResourceManager resourceMan;
+        private static System.Resources.ResourceManager resourceMan;
         
-        private static global::System.Globalization.CultureInfo resourceCulture;
+        private static System.Globalization.CultureInfo resourceCulture;
         
-        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
         internal Localization() {
         }
         
-        /// <summary>
-        ///   Returns the cached ResourceManager instance used by this class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Resources.ResourceManager ResourceManager {
+        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static System.Resources.ResourceManager ResourceManager {
             get {
-                if (object.ReferenceEquals(resourceMan, null)) {
-                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Aaru.DiscImages.Localization.Localization", typeof(Localization).Assembly);
+                if (object.Equals(null, resourceMan)) {
+                    System.Resources.ResourceManager temp = new System.Resources.ResourceManager("Aaru.DiscImages.Localization.Localization", typeof(Localization).Assembly);
                     resourceMan = temp;
                 }
                 return resourceMan;
             }
         }
         
-        /// <summary>
-        ///   Overrides the current thread's CurrentUICulture property for all
-        ///   resource lookups using this strongly typed resource class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Globalization.CultureInfo Culture {
+        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static System.Globalization.CultureInfo Culture {
             get {
                 return resourceCulture;
             }
@@ -59,8638 +45,5770 @@ internal Localization() {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to {0} ({1:P}% MODE 2 Form 1 are correct, {2} ({3:P}%) MODE 2 Form 2 are correct, {4} ({5:P}%) MODE 2 Form 2 have empty CRC.
-        /// </summary>
-        internal static string _0_1_MODE_2_Form_1_are_correct_2_3_MODE_2_Form_2_are_correct_4_5_MODE_2_Form_2_have_empty_CRC {
+        internal static string Took_0_ms_to_deinterleave_subchannel {
             get {
-                return ResourceManager.GetString("_0_1_MODE_2_Form_1_are_correct_2_3_MODE_2_Form_2_are_correct_4_5_MODE_2_Form_2_ha" +
-                        "ve_empty_CRC", resourceCulture);
+                return ResourceManager.GetString("Took_0_ms_to_deinterleave_subchannel", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to {0} ({1:P}% prefixes are correct, {2} ({3:P}%) prefixes have not been dumped, {4} ({5:P}%) prefixes have been written to image.
-        /// </summary>
-        internal static string _0_1_prefixes_are_correct_2_3_prefixes_have_not_been_dumped_4_5_prefixes_have_been_written_to_image {
+        internal static string Took_0_ms_to_sequentialize_subchannel {
             get {
-                return ResourceManager.GetString("_0_1_prefixes_are_correct_2_3_prefixes_have_not_been_dumped_4_5_prefixes_have_bee" +
-                        "n_written_to_image", resourceCulture);
+                return ResourceManager.GetString("Took_0_ms_to_sequentialize_subchannel", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to {0} ({1:P}% suffixes are correct, {2} ({3:P}%) suffixes have not been dumped, {4} ({5:P}%) suffixes have been written to image.
-        /// </summary>
-        internal static string _0_1_suffixes_are_correct_2_3_suffixes_have_not_been_dumped_4_5_suffixes_have_been_written_to_image {
+        internal static string Took_0_ms_to_transform_subchannel {
             get {
-                return ResourceManager.GetString("_0_1_suffixes_are_correct_2_3_suffixes_have_not_been_dumped_4_5_suffixes_have_bee" +
-                        "n_written_to_image", resourceCulture);
+                return ResourceManager.GetString("Took_0_ms_to_transform_subchannel", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to {0} bytes per sector.
-        /// </summary>
-        internal static string _0_bytes_per_sector {
+        internal static string Took_0_ms_to_desequentialize_subchannel {
             get {
-                return ResourceManager.GetString("_0_bytes_per_sector", resourceCulture);
+                return ResourceManager.GetString("Took_0_ms_to_desequentialize_subchannel", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to {0} is not an VMware extent..
-        /// </summary>
-        internal static string _0_is_not_an_VMware_extent {
+        internal static string Took_0_ms_to_interleave_subchannel {
             get {
-                return ResourceManager.GetString("_0_is_not_an_VMware_extent", resourceCulture);
+                return ResourceManager.GetString("Took_0_ms_to_interleave_subchannel", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to {0} sectors.
-        /// </summary>
-        internal static string _0_sectors {
+        internal static string Took_0_ms_to_untransform_subchannel {
             get {
-                return ResourceManager.GetString("_0_sectors", resourceCulture);
+                return ResourceManager.GetString("Took_0_ms_to_untransform_subchannel", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to {0} sectors in {1} grains in {2} tables.
-        /// </summary>
-        internal static string _0_sectors_in_1_grains_in_2_tables {
+        internal static string AaruFormat_Name {
             get {
-                return ResourceManager.GetString("_0_sectors_in_1_grains_in_2_tables", resourceCulture);
+                return ResourceManager.GetString("AaruFormat_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to {0} tracks.
-        /// </summary>
-        internal static string _0_tracks {
+        internal static string How_many_sectors_to_store_per_block_will_be_rounded_to_next_power_of_two {
             get {
-                return ResourceManager.GetString("_0_tracks", resourceCulture);
+                return ResourceManager.GetString("How_many_sectors_to_store_per_block_will_be_rounded_to_next_power_of_two", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to 2MG comments: {0}.
-        /// </summary>
-        internal static string _2MG_comments_0 {
+        internal static string Size_in_bytes_of_the_LZMA_dictionary {
             get {
-                return ResourceManager.GetString("_2MG_comments_0", resourceCulture);
+                return ResourceManager.GetString("Size_in_bytes_of_the_LZMA_dictionary", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to 2MG image contains a disk of type {0}.
-        /// </summary>
-        internal static string _2MG_image_contains_a_disk_of_type_0 {
+        internal static string Maximum_size_in_mebibytes_for_in_memory_DDT_If_image_needs_a_bigger_one_it_will_be_on_disk {
             get {
-                return ResourceManager.GetString("_2MG_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Maximum_size_in_mebibytes_for_in_memory_DDT_If_image_needs_a_bigger_one_it_will_b" +
+                        "e_on_disk", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to 5, 6 or 7.
-        /// </summary>
-        internal static string _5_6_or_7 {
+        internal static string Calculate_and_store_MD5_of_image_user_data {
             get {
-                return ResourceManager.GetString("_5_6_or_7", resourceCulture);
+                return ResourceManager.GetString("Calculate_and_store_MD5_of_image_user_data", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Aaru Format.
-        /// </summary>
-        internal static string AaruFormat_Name {
+        internal static string Calculate_and_store_SHA1_of_image_user_data {
             get {
-                return ResourceManager.GetString("AaruFormat_Name", resourceCulture);
+                return ResourceManager.GetString("Calculate_and_store_SHA1_of_image_user_data", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to AddressMark cylinder: {0}.
-        /// </summary>
-        internal static string AddressMark_cylinder_0 {
+        internal static string Calculate_and_store_SHA256_of_image_user_data {
             get {
-                return ResourceManager.GetString("AddressMark_cylinder_0", resourceCulture);
+                return ResourceManager.GetString("Calculate_and_store_SHA256_of_image_user_data", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to AddressMark head: {0}.
-        /// </summary>
-        internal static string AddressMark_head_0 {
+        internal static string Calculate_and_store_SpamSum_of_image_user_data {
             get {
-                return ResourceManager.GetString("AddressMark_head_0", resourceCulture);
+                return ResourceManager.GetString("Calculate_and_store_SpamSum_of_image_user_data", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to AddressMark sector number: {0}.
-        /// </summary>
-        internal static string AddressMark_sector_number_0 {
+        internal static string Store_only_unique_sectors_This_consumes_more_memory_and_is_slower_but_its_enabled_by_default {
             get {
-                return ResourceManager.GetString("AddressMark_sector_number_0", resourceCulture);
+                return ResourceManager.GetString("Store_only_unique_sectors_This_consumes_more_memory_and_is_slower_but_its_enabled" +
+                        "_by_default", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to AES encrypted images not yet supported.
-        /// </summary>
-        internal static string AES_encrypted_images_not_yet_supported {
+        internal static string Compress_user_data_blocks_Other_blocks_will_always_be_compressed {
             get {
-                return ResourceManager.GetString("AES_encrypted_images_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Compress_user_data_blocks_Other_blocks_will_always_be_compressed", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Alcohol 120% image describes a disc of type {0}.
-        /// </summary>
-        internal static string Alcohol_120_image_describes_a_disc_of_type_0 {
+        internal static string Memory_snapshot_0_bytes {
             get {
-                return ResourceManager.GetString("Alcohol_120_image_describes_a_disc_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Memory_snapshot_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Alcohol 120% Media Descriptor Structure.
-        /// </summary>
-        internal static string Alcohol120_Name {
+        internal static string Image_version_0_not_recognized {
             get {
-                return ResourceManager.GetString("Alcohol120_Name", resourceCulture);
+                return ResourceManager.GetString("Image_version_0_not_recognized", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to All tracks are same size? {0}.
-        /// </summary>
-        internal static string All_tracks_are_same_size_0 {
+        internal static string Index_not_found {
             get {
-                return ResourceManager.GetString("All_tracks_are_same_size_0", resourceCulture);
+                return ResourceManager.GetString("Index_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Anex86 Disk Image.
-        /// </summary>
-        internal static string Anex86_Name {
+        internal static string Index_at_0_contains_1_entries {
             get {
-                return ResourceManager.GetString("Anex86_Name", resourceCulture);
+                return ResourceManager.GetString("Index_at_0_contains_1_entries", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Apple 2IMG.
-        /// </summary>
-        internal static string Apple2Mg_Name {
+        internal static string Block_type_0_with_data_type_1_is_indexed_to_be_at_2 {
             get {
-                return ResourceManager.GetString("Apple2Mg_Name", resourceCulture);
+                return ResourceManager.GetString("Block_type_0_with_data_type_1_is_indexed_to_be_at_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Apple ][ Interleaved Disk Image.
-        /// </summary>
-        internal static string AppleDos_Name {
+        internal static string Incorrect_identifier_for_data_block_at_position_0 {
             get {
-                return ResourceManager.GetString("AppleDos_Name", resourceCulture);
+                return ResourceManager.GetString("Incorrect_identifier_for_data_block_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Apple NIB.
-        /// </summary>
-        internal static string AppleNib_Name {
+        internal static string Expected_block_with_data_type_0_at_position_1_but_found_data_type_2 {
             get {
-                return ResourceManager.GetString("AppleNib_Name", resourceCulture);
+                return ResourceManager.GetString("Expected_block_with_data_type_0_at_position_1_but_found_data_type_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ACT Apricot Disk Image.
-        /// </summary>
-        internal static string Apridisk_Name {
+        internal static string Found_data_block_type_0_at_position_1 {
             get {
-                return ResourceManager.GetString("Apridisk_Name", resourceCulture);
+                return ResourceManager.GetString("Found_data_block_type_0_at_position_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Arranger: {0}.
-        /// </summary>
-        internal static string Arranger_0 {
+        internal static string Invalid_compression_type_0_for_block_with_data_type_1_continuing {
             get {
-                return ResourceManager.GetString("Arranger_0", resourceCulture);
+                return ResourceManager.GetString("Invalid_compression_type_0_for_block_with_data_type_1_continuing", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Arranger is not set..
-        /// </summary>
-        internal static string Arranger_is_not_set {
+        internal static string Error_decompressing_block_should_be_0_bytes_but_got_1_bytes {
             get {
-                return ResourceManager.GetString("Arranger_is_not_set", resourceCulture);
+                return ResourceManager.GetString("Error_decompressing_block_should_be_0_bytes_but_got_1_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Arrived end of disk at cylinder {0}.
-        /// </summary>
-        internal static string Arrived_end_of_disk_at_cylinder_0 {
+        internal static string Took_0_seconds_to_decompress_block {
             get {
-                return ResourceManager.GetString("Arrived_end_of_disk_at_cylinder_0", resourceCulture);
+                return ResourceManager.GetString("Took_0_seconds_to_decompress_block", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Asia (NTSC).
-        /// </summary>
-        internal static string Asia_NTSC {
+        internal static string Found_unknown_compression_type_0_continuing {
             get {
-                return ResourceManager.GetString("Asia_NTSC", resourceCulture);
+                return ResourceManager.GetString("Found_unknown_compression_type_0_continuing", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Atari Lynx.
-        /// </summary>
-        internal static string AtariLynx_Name {
+        internal static string Incorrect_CRC_found_0_X16_found_expected_1_X16_continuing {
             get {
-                return ResourceManager.GetString("AtariLynx_Name", resourceCulture);
+                return ResourceManager.GetString("Incorrect_CRC_found_0_X16_found_expected_1_X16_continuing", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Australia.
-        /// </summary>
-        internal static string Australia {
+        internal static string Media_tag_type_0_duplicated_removing_previous_entry {
             get {
-                return ResourceManager.GetString("Australia", resourceCulture);
+                return ResourceManager.GetString("Media_tag_type_0_duplicated_removing_previous_entry", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Bank 1 size: {0} pages ({1} bytes).
-        /// </summary>
-        internal static string Bank_one_size_0_pages_1_bytes {
+        internal static string Decompressing_DDT {
             get {
-                return ResourceManager.GetString("Bank_one_size_0_pages_1_bytes", resourceCulture);
+                return ResourceManager.GetString("Decompressing_DDT", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Bank size: {0} bytes.
-        /// </summary>
-        internal static string Bank_size_0_bytes {
+        internal static string Error_decompressing_DDT_should_be_0_bytes_but_got_1_bytes {
             get {
-                return ResourceManager.GetString("Bank_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Error_decompressing_DDT_should_be_0_bytes_but_got_1_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Bank 0 size: {0} pages ({1} bytes).
-        /// </summary>
-        internal static string Bank_zero_size_0_pages_1_bytes {
+        internal static string Took_0_seconds_to_decompress_DDT {
             get {
-                return ResourceManager.GetString("Bank_zero_size_0_pages_1_bytes", resourceCulture);
+                return ResourceManager.GetString("Took_0_seconds_to_decompress_DDT", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Barcode: {0}.
-        /// </summary>
-        internal static string Barcode_0 {
+        internal static string Found_unsupported_compression_algorithm_0 {
             get {
-                return ResourceManager.GetString("Barcode_0", resourceCulture);
+                return ResourceManager.GetString("Found_unsupported_compression_algorithm_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Barcode not set..
-        /// </summary>
-        internal static string Barcode_not_set {
+        internal static string Geometry_set_to_0_cylinders_1_heads_2_sectors_per_track {
             get {
-                return ResourceManager.GetString("Barcode_not_set", resourceCulture);
+                return ResourceManager.GetString("Geometry_set_to_0_cylinders_1_heads_2_sectors_per_track", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to BAT not found, cannot continue..
-        /// </summary>
-        internal static string BAT_not_found_cannot_continue {
+        internal static string Found_metadata_block_at_position_0 {
             get {
-                return ResourceManager.GetString("BAT_not_found_cannot_continue", resourceCulture);
+                return ResourceManager.GetString("Found_metadata_block_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Beta.
-        /// </summary>
-        internal static string Beta {
+        internal static string Setting_media_sequence_as_0_of_1 {
             get {
-                return ResourceManager.GetString("Beta", resourceCulture);
+                return ResourceManager.GetString("Setting_media_sequence_as_0_of_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Bitmap is {0} sectors.
-        /// </summary>
-        internal static string Bitmap_is_0_sectors {
+        internal static string Setting_creator_0 {
             get {
-                return ResourceManager.GetString("Bitmap_is_0_sectors", resourceCulture);
+                return ResourceManager.GetString("Setting_creator_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to BlindWrite comments: {0}.
-        /// </summary>
-        internal static string BlindWrite_comments_0 {
+        internal static string Setting_comments_0 {
             get {
-                return ResourceManager.GetString("BlindWrite_comments_0", resourceCulture);
+                return ResourceManager.GetString("Setting_comments_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to BlindWrite image describes a disc of type {0}.
-        /// </summary>
-        internal static string BlindWrite_image_describes_a_disc_of_type_0 {
+        internal static string Setting_media_title_0 {
             get {
-                return ResourceManager.GetString("BlindWrite_image_describes_a_disc_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Setting_media_title_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to BlindWrite 4.
-        /// </summary>
-        internal static string BlindWrite4_Name {
+        internal static string Setting_media_manufacturer_0 {
             get {
-                return ResourceManager.GetString("BlindWrite4_Name", resourceCulture);
+                return ResourceManager.GetString("Setting_media_manufacturer_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to BlindWrite5 found unknown subchannel size: {0}.
-        /// </summary>
-        internal static string BlindWrite5_found_unknown_subchannel_size_0 {
+        internal static string Setting_media_model_0 {
             get {
-                return ResourceManager.GetString("BlindWrite5_found_unknown_subchannel_size_0", resourceCulture);
+                return ResourceManager.GetString("Setting_media_model_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to BlindWrite5 image ends after expected position. Probably new version with different data. Errors may occur..
-        /// </summary>
-        internal static string BlindWrite5_image_ends_after_expected_position_Probably_new_version_with_different_data_Errors_may_occur {
+        internal static string Setting_media_serial_number_0 {
             get {
-                return ResourceManager.GetString("BlindWrite5_image_ends_after_expected_position_Probably_new_version_with_differen" +
-                        "t_data_Errors_may_occur", resourceCulture);
+                return ResourceManager.GetString("Setting_media_serial_number_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to BlindWrite 5.
-        /// </summary>
-        internal static string BlindWrite5_Name {
+        internal static string Setting_media_barcode_0 {
             get {
-                return ResourceManager.GetString("BlindWrite5_Name", resourceCulture);
+                return ResourceManager.GetString("Setting_media_barcode_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (Block pattern decoder): Input data size: {0} bytes.
-        /// </summary>
-        internal static string Block_pattern_decoder_Input_data_size_0_bytes {
+        internal static string Setting_media_part_number_0 {
             get {
-                return ResourceManager.GetString("Block_pattern_decoder_Input_data_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Setting_media_part_number_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (Block pattern decoder): Output data size: {0} bytes.
-        /// </summary>
-        internal static string Block_pattern_decoder_Output_data_size_0_bytes {
+        internal static string Setting_drive_manufacturer_0 {
             get {
-                return ResourceManager.GetString("Block_pattern_decoder_Output_data_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Setting_drive_manufacturer_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (Block pattern decoder): Processed input: {0} bytes.
-        /// </summary>
-        internal static string Block_pattern_decoder_Processed_input_0_bytes {
+        internal static string Setting_drive_model_0 {
             get {
-                return ResourceManager.GetString("Block_pattern_decoder_Processed_input_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Setting_drive_model_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (Block pattern decoder): Processed Output: {0} bytes.
-        /// </summary>
-        internal static string Block_pattern_decoder_Processed_Output_0_bytes {
+        internal static string Setting_drive_serial_number_0 {
             get {
-                return ResourceManager.GetString("Block_pattern_decoder_Processed_Output_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Setting_drive_serial_number_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Block type {0} with data type {1} is indexed to be at {2}.
-        /// </summary>
-        internal static string Block_type_0_with_data_type_1_is_indexed_to_be_at_2 {
+        internal static string Setting_drive_firmware_revision_0 {
             get {
-                return ResourceManager.GetString("Block_type_0_with_data_type_1_is_indexed_to_be_at_2", resourceCulture);
+                return ResourceManager.GetString("Setting_drive_firmware_revision_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to BLU image contains a disk of type {0}.
-        /// </summary>
-        internal static string BLU_image_contains_a_disk_of_type_0 {
+        internal static string Incorrect_identifier_for_tracks_block_at_position_0 {
             get {
-                return ResourceManager.GetString("BLU_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Incorrect_identifier_for_tracks_block_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Basic Lisa Utility.
-        /// </summary>
-        internal static string Blu_Name {
+        internal static string Found_0_tracks_at_position_0 {
             get {
-                return ResourceManager.GetString("Blu_Name", resourceCulture);
+                return ResourceManager.GetString("Found_0_tracks_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Brazil.
-        /// </summary>
-        internal static string Brazil {
+        internal static string Found_CICM_XML_metadata_block_at_position_0 {
             get {
-                return ResourceManager.GetString("Brazil", resourceCulture);
+                return ResourceManager.GetString("Found_CICM_XML_metadata_block_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Breaking track processing and trying recovery of information..
-        /// </summary>
-        internal static string Breaking_track_processing_and_trying_recovery_of_information {
+        internal static string Exception_0_processing_CICM_XML_metadata_block {
             get {
-                return ResourceManager.GetString("Breaking_track_processing_and_trying_recovery_of_information", resourceCulture);
+                return ResourceManager.GetString("Exception_0_processing_CICM_XML_metadata_block", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Buffer must not be null..
-        /// </summary>
-        internal static string Buffer_must_not_be_null {
+        internal static string Found_dump_hardware_block_at_position_0 {
             get {
-                return ResourceManager.GetString("Buffer_must_not_be_null", resourceCulture);
+                return ResourceManager.GetString("Found_dump_hardware_block_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Building maps.
-        /// </summary>
-        internal static string Building_maps {
+        internal static string Found_tape_partition_block_at_position_0 {
             get {
-                return ResourceManager.GetString("Building_maps", resourceCulture);
+                return ResourceManager.GetString("Found_tape_partition_block_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Building offset map.
-        /// </summary>
-        internal static string Building_offset_map {
+        internal static string Found_tape_file_block_at_position_0 {
             get {
-                return ResourceManager.GetString("Building_offset_map", resourceCulture);
+                return ResourceManager.GetString("Found_tape_file_block_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Building offset, track and session maps.
-        /// </summary>
-        internal static string Building_offset_track_and_session_maps {
+        internal static string Incorrect_identifier_for_compact_disc_indexes_block_at_position_0 {
             get {
-                return ResourceManager.GetString("Building_offset_track_and_session_maps", resourceCulture);
+                return ResourceManager.GetString("Incorrect_identifier_for_compact_disc_indexes_block_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculate and store MD5 of image&apos;s user data.
-        /// </summary>
-        internal static string Calculate_and_store_MD5_of_image_user_data {
+        internal static string Found_0_compact_disc_indexes_at_position_0 {
             get {
-                return ResourceManager.GetString("Calculate_and_store_MD5_of_image_user_data", resourceCulture);
+                return ResourceManager.GetString("Found_0_compact_disc_indexes_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculate and store SHA1 of image&apos;s user data.
-        /// </summary>
-        internal static string Calculate_and_store_SHA1_of_image_user_data {
+        internal static string Could_not_find_user_data_deduplication_table {
             get {
-                return ResourceManager.GetString("Calculate_and_store_SHA1_of_image_user_data", resourceCulture);
+                return ResourceManager.GetString("Could_not_find_user_data_deduplication_table", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculate and store SHA256 of image&apos;s user data.
-        /// </summary>
-        internal static string Calculate_and_store_SHA256_of_image_user_data {
+        internal static string Image_created_on_0 {
             get {
-                return ResourceManager.GetString("Calculate_and_store_SHA256_of_image_user_data", resourceCulture);
+                return ResourceManager.GetString("Image_created_on_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculate and store SpamSum of image&apos;s user data.
-        /// </summary>
-        internal static string Calculate_and_store_SpamSum_of_image_user_data {
+        internal static string Image_last_written_on_0 {
             get {
-                return ResourceManager.GetString("Calculate_and_store_SpamSum_of_image_user_data", resourceCulture);
+                return ResourceManager.GetString("Image_last_written_on_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculated checksum = 0x{0:X8}, {1}.
-        /// </summary>
-        internal static string Calculated_checksum_equals_0_X8_1 {
+        internal static string This_image_has_a_corrupted_track_list_convert_will_fix_it {
             get {
-                return ResourceManager.GetString("Calculated_checksum_equals_0_X8_1", resourceCulture);
+                return ResourceManager.GetString("This_image_has_a_corrupted_track_list_convert_will_fix_it", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculated CRC does not coincide with stored one..
-        /// </summary>
-        internal static string Calculated_CRC_does_not_coincide_with_stored_one {
+        internal static string This_image_has_a_corrupted_track_list_a_best_effort_has_been_tried_but_may_require_manual_editing_or_redump {
             get {
-                return ResourceManager.GetString("Calculated_CRC_does_not_coincide_with_stored_one", resourceCulture);
+                return ResourceManager.GetString("This_image_has_a_corrupted_track_list_a_best_effort_has_been_tried_but_may_requir" +
+                        "e_manual_editing_or_redump", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculated CRC = 0x{0:X4}.
-        /// </summary>
-        internal static string Calculated_CRC_equals_0_X4 {
+        internal static string Optical_disc_track {
             get {
-                return ResourceManager.GetString("Calculated_CRC_equals_0_X4", resourceCulture);
+                return ResourceManager.GetString("Optical_disc_track", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculated CRC32: {0}.
-        /// </summary>
-        internal static string Calculated_CRC32_0 {
+        internal static string Checking_index_integrity_at_0 {
             get {
-                return ResourceManager.GetString("Calculated_CRC32_0", resourceCulture);
+                return ResourceManager.GetString("Checking_index_integrity_at_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculated data checksum = 0x{0:X8}.
-        /// </summary>
-        internal static string Calculated_data_checksum_equals_0_X8 {
+        internal static string Incorrect_index_identifier {
             get {
-                return ResourceManager.GetString("Calculated_data_checksum_equals_0_X8", resourceCulture);
+                return ResourceManager.GetString("Incorrect_index_identifier", resourceCulture);
+            }
+        }
+        
+        internal static string Expected_index_CRC_0_X16_but_got_1_X16 {
+            get {
+                return ResourceManager.GetString("Expected_index_CRC_0_X16_but_got_1_X16", resourceCulture);
+            }
+        }
+        
+        internal static string Verifying_data_block_type_0_at_position_1 {
+            get {
+                return ResourceManager.GetString("Verifying_data_block_type_0_at_position_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculated data CRC = 0x{0:X8}, {1}.
-        /// </summary>
-        internal static string Calculated_data_CRC_equals_0_X8_1 {
+        internal static string Expected_block_CRC_0_X16_but_got_1_X16 {
             get {
-                return ResourceManager.GetString("Calculated_data_CRC_equals_0_X8_1", resourceCulture);
+                return ResourceManager.GetString("Expected_block_CRC_0_X16_but_got_1_X16", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculated header checksum = 0x{0:X2}, {1}.
-        /// </summary>
-        internal static string Calculated_header_checksum_equals_0_X2_1 {
+        internal static string Verifying_deduplication_table_type_0_at_position_1 {
             get {
-                return ResourceManager.GetString("Calculated_header_checksum_equals_0_X2_1", resourceCulture);
+                return ResourceManager.GetString("Verifying_deduplication_table_type_0_at_position_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to calculated header crc = 0x{0:X4}.
-        /// </summary>
-        internal static string calculated_header_crc_equals_0_X4 {
+        internal static string Expected_DDT_CRC_0_but_got_1 {
             get {
-                return ResourceManager.GetString("calculated_header_crc_equals_0_X4", resourceCulture);
+                return ResourceManager.GetString("Expected_DDT_CRC_0_but_got_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculated MD5: {0}.
-        /// </summary>
-        internal static string Calculated_MD5_0 {
+        internal static string Track_block_at_0_contains_1_entries {
             get {
-                return ResourceManager.GetString("Calculated_MD5_0", resourceCulture);
+                return ResourceManager.GetString("Track_block_at_0_contains_1_entries", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculated SHA1: {0}.
-        /// </summary>
-        internal static string Calculated_SHA1_0 {
+        internal static string Ignored_field_type_0 {
             get {
-                return ResourceManager.GetString("Calculated_SHA1_0", resourceCulture);
+                return ResourceManager.GetString("Ignored_field_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculated tag checksum = 0x{0:X8}.
-        /// </summary>
-        internal static string Calculated_tag_checksum_equals_0_X8 {
+        internal static string Invalid_value_for_sectors_per_block_option {
             get {
-                return ResourceManager.GetString("Calculated_tag_checksum_equals_0_X8", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_sectors_per_block_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculating data checksum.
-        /// </summary>
-        internal static string Calculating_data_checksum {
+        internal static string Invalid_value_for_dictionary_option {
             get {
-                return ResourceManager.GetString("Calculating_data_checksum", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_dictionary_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Calculating tag checksum.
-        /// </summary>
-        internal static string Calculating_tag_checksum {
+        internal static string Invalid_value_for_max_ddt_size_option {
             get {
-                return ResourceManager.GetString("Calculating_tag_checksum", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_max_ddt_size_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Canada.
-        /// </summary>
-        internal static string Canada {
+        internal static string Invalid_value_for_md5_option {
             get {
-                return ResourceManager.GetString("Canada", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_md5_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot access NOACCESS extents 😉..
-        /// </summary>
-        internal static string Cannot_access_NOACCESS_extents {
+        internal static string Invalid_value_for_sha1_option {
             get {
-                return ResourceManager.GetString("Cannot_access_NOACCESS_extents", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_sha1_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot append to a non Aaru Format image.
-        /// </summary>
-        internal static string Cannot_append_to_a_non_Aaru_Format_image {
+        internal static string Invalid_value_for_sha256_option {
             get {
-                return ResourceManager.GetString("Cannot_append_to_a_non_Aaru_Format_image", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_sha256_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot append to an unknown image version {0}.
-        /// </summary>
-        internal static string Cannot_append_to_an_unknown_image_version_0 {
+        internal static string Invalid_value_for_spamsum_option {
             get {
-                return ResourceManager.GetString("Cannot_append_to_an_unknown_image_version_0", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_spamsum_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot create an opened image.
-        /// </summary>
-        internal static string Cannot_create_an_opened_image {
+        internal static string Invalid_value_for_deduplicate_option {
             get {
-                return ResourceManager.GetString("Cannot_create_an_opened_image", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_deduplicate_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot decode block header, cannot open..
-        /// </summary>
-        internal static string Cannot_decode_block_header_cannot_open {
+        internal static string Invalid_value_for_compress_option {
             get {
-                return ResourceManager.GetString("Cannot_decode_block_header_cannot_open", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_compress_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find bitmap.
-        /// </summary>
-        internal static string Cannot_find_bitmap {
+        internal static string Unsupported_media_format_0 {
             get {
-                return ResourceManager.GetString("Cannot_find_bitmap", resourceCulture);
+                return ResourceManager.GetString("Unsupported_media_format_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find cyl 0 hd 0, supposing only top head was dumped.
-        /// </summary>
-        internal static string Cannot_find_cyl_0_hd_0_supposing_only_top_head_was_dumped {
+        internal static string Got_a_shift_of_0_for_1_sectors_per_block {
             get {
-                return ResourceManager.GetString("Cannot_find_cyl_0_hd_0_supposing_only_top_head_was_dumped", resourceCulture);
+                return ResourceManager.GetString("Got_a_shift_of_0_for_1_sectors_per_block", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find cyl 0 hd 1, supposing only bottom head was dumped.
-        /// </summary>
-        internal static string Cannot_find_cyl_0_hd_1_supposing_only_bottom_head_was_dumped {
+        internal static string Could_not_create_new_image_file_exception_0 {
             get {
-                return ResourceManager.GetString("Cannot_find_cyl_0_hd_1_supposing_only_bottom_head_was_dumped", resourceCulture);
+                return ResourceManager.GetString("Could_not_create_new_image_file_exception_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find cyl 1, supposing double stepping.
-        /// </summary>
-        internal static string Cannot_find_cyl_1_supposing_double_stepping {
+        internal static string Cannot_append_to_a_non_Aaru_Format_image {
             get {
-                return ResourceManager.GetString("Cannot_find_cyl_1_supposing_double_stepping", resourceCulture);
+                return ResourceManager.GetString("Cannot_append_to_a_non_Aaru_Format_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find data blocks.
-        /// </summary>
-        internal static string Cannot_find_data_blocks {
+        internal static string Cannot_append_to_an_unknown_image_version_0 {
             get {
-                return ResourceManager.GetString("Cannot_find_data_blocks", resourceCulture);
+                return ResourceManager.GetString("Cannot_append_to_an_unknown_image_version_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find data file {0}.
-        /// </summary>
-        internal static string Cannot_find_data_file_0 {
+        internal static string Cannot_write_a_media_with_type_0_to_an_image_with_type_1 {
             get {
-                return ResourceManager.GetString("Cannot_find_data_file_0", resourceCulture);
+                return ResourceManager.GetString("Cannot_write_a_media_with_type_0_to_an_image_with_type_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find info block.
-        /// </summary>
-        internal static string Cannot_find_info_block {
+        internal static string Index_not_found_in_existing_image_cannot_continue {
             get {
-                return ResourceManager.GetString("Cannot_find_info_block", resourceCulture);
+                return ResourceManager.GetString("Index_not_found_in_existing_image_cannot_continue", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find local header.
-        /// </summary>
-        internal static string Cannot_find_local_header {
+        internal static string Trying_to_write_a_media_with_0_sectors_to_an_image_with_1_sectors_not_continuing {
             get {
-                return ResourceManager.GetString("Cannot_find_local_header", resourceCulture);
+                return ResourceManager.GetString("Trying_to_write_a_media_with_0_sectors_to_an_image_with_1_sectors_not_continuing", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find MBRs.
-        /// </summary>
-        internal static string Cannot_find_MBRs {
+        internal static string In_memory_DDT_0 {
             get {
-                return ResourceManager.GetString("Cannot_find_MBRs", resourceCulture);
+                return ResourceManager.GetString("In_memory_DDT_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find parent &quot;{0}&quot;..
-        /// </summary>
-        internal static string Cannot_find_parent_0 {
+        internal static string Tried_to_write_on_a_non_writable_image {
             get {
-                return ResourceManager.GetString("Cannot_find_parent_0", resourceCulture);
+                return ResourceManager.GetString("Tried_to_write_on_a_non_writable_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find tail. Multiple volumes are not supported or image is corrupt..
-        /// </summary>
-        internal static string Cannot_find_tail_Multiple_volumes_are_not_supported_or_image_is_corrupt {
+        internal static string Tried_to_write_past_image_size {
             get {
-                return ResourceManager.GetString("Cannot_find_tail_Multiple_volumes_are_not_supported_or_image_is_corrupt", resourceCulture);
+                return ResourceManager.GetString("Tried_to_write_past_image_size", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot open data file.
-        /// </summary>
-        internal static string Cannot_open_data_file {
+        internal static string Track_not_found {
             get {
-                return ResourceManager.GetString("Cannot_open_data_file", resourceCulture);
+                return ResourceManager.GetString("Track_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot read compressed CHD version 5.
-        /// </summary>
-        internal static string Cannot_read_compressed_CHD_version_5 {
+        internal static string Incorrect_data_size {
             get {
-                return ResourceManager.GetString("Cannot_read_compressed_CHD_version_5", resourceCulture);
+                return ResourceManager.GetString("Incorrect_data_size", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot skip blocks.
-        /// </summary>
-        internal static string Cannot_skip_blocks {
+        internal static string Unknown_long_sector_type_cannot_write {
             get {
-                return ResourceManager.GetString("Cannot_skip_blocks", resourceCulture);
+                return ResourceManager.GetString("Unknown_long_sector_type_cannot_write", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot write a media with type {0} to an image with type {1}.
-        /// </summary>
-        internal static string Cannot_write_a_media_with_type_0_to_an_image_with_type_1 {
+        internal static string Unsupported_feature {
             get {
-                return ResourceManager.GetString("Cannot_write_a_media_with_type_0_to_an_image_with_type_1", resourceCulture);
+                return ResourceManager.GetString("Unsupported_feature", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot write non-long sectors to CD images..
-        /// </summary>
-        internal static string Cannot_write_non_long_sectors_to_CD_images {
+        internal static string Image_is_not_opened_for_writing {
             get {
-                return ResourceManager.GetString("Cannot_write_non_long_sectors_to_CD_images", resourceCulture);
+                return ResourceManager.GetString("Image_is_not_opened_for_writing", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot write unwritten blocks.
-        /// </summary>
-        internal static string Cannot_write_unwritten_blocks {
+        internal static string Of_0_sectors_written_1_are_unique_2 {
             get {
-                return ResourceManager.GetString("Cannot_write_unwritten_blocks", resourceCulture);
+                return ResourceManager.GetString("Of_0_sectors_written_1_are_unique_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Can&apos;t cross tracks.
-        /// </summary>
-        internal static string Cant_cross_tracks {
+        internal static string Tag_type_0_is_null_skipping {
             get {
-                return ResourceManager.GetString("Cant_cross_tracks", resourceCulture);
+                return ResourceManager.GetString("Tag_type_0_is_null_skipping", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Can&apos;t find file containing {0}.
-        /// </summary>
-        internal static string Cant_find_file_containing_0 {
+        internal static string Writing_tag_type_0_to_position_1 {
             get {
-                return ResourceManager.GetString("Cant_find_file_containing_0", resourceCulture);
+                return ResourceManager.GetString("Writing_tag_type_0_to_position_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Can&apos;t find track {0}.
-        /// </summary>
-        internal static string Cant_find_track_0 {
+        internal static string Writing_geometry_block_to_position_0 {
             get {
-                return ResourceManager.GetString("Cant_find_track_0", resourceCulture);
+                return ResourceManager.GetString("Writing_geometry_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Can&apos;t find track containing {0}.
-        /// </summary>
-        internal static string Cant_find_track_containing_0 {
+        internal static string Writing_dump_hardware_block_to_position_0 {
             get {
-                return ResourceManager.GetString("Cant_find_track_containing_0", resourceCulture);
+                return ResourceManager.GetString("Writing_dump_hardware_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cartridge chip set: {0}.
-        /// </summary>
-        internal static string Cartridge_chip_set_0 {
+        internal static string Writing_CICM_XML_block_to_position_0 {
             get {
-                return ResourceManager.GetString("Cartridge_chip_set_0", resourceCulture);
+                return ResourceManager.GetString("Writing_CICM_XML_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cartridge ID: {0}.
-        /// </summary>
-        internal static string Cartridge_ID_0 {
+        internal static string Writing_checksum_block_to_position_0 {
             get {
-                return ResourceManager.GetString("Cartridge_ID_0", resourceCulture);
+                return ResourceManager.GetString("Writing_checksum_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cartridge type: {0}.
-        /// </summary>
-        internal static string Cartridge_type_0 {
+        internal static string Writing_tape_partitions_to_position_0 {
             get {
-                return ResourceManager.GetString("Cartridge_type_0", resourceCulture);
+                return ResourceManager.GetString("Writing_tape_partitions_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CD-TEXT binary file: {0}.
-        /// </summary>
-        internal static string CD_TEXT_binary_file_0 {
+        internal static string Writing_tape_files_to_position_0 {
             get {
-                return ResourceManager.GetString("CD_TEXT_binary_file_0", resourceCulture);
+                return ResourceManager.GetString("Writing_tape_files_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CD-TEXT binary file not set..
-        /// </summary>
-        internal static string CD_TEXT_binary_file_not_set {
+        internal static string Writing_user_data_DDT_to_position_0 {
             get {
-                return ResourceManager.GetString("CD_TEXT_binary_file_not_set", resourceCulture);
+                return ResourceManager.GetString("Writing_user_data_DDT_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CD-TEXT entry {0}.
-        /// </summary>
-        internal static string CD_TEXT_entry_0 {
+        internal static string Writing_CD_sector_prefix_block_to_position_0 {
             get {
-                return ResourceManager.GetString("CD_TEXT_entry_0", resourceCulture);
+                return ResourceManager.GetString("Writing_CD_sector_prefix_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CDRDAO comments: {0}.
-        /// </summary>
-        internal static string CDRDAO_comments_0 {
+        internal static string Took_0_seconds_to_compress_prefix {
             get {
-                return ResourceManager.GetString("CDRDAO_comments_0", resourceCulture);
+                return ResourceManager.GetString("Took_0_seconds_to_compress_prefix", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CDRDAO image describes a disc of type {0}.
-        /// </summary>
-        internal static string CDRDAO_image_describes_a_disc_of_type_0 {
+        internal static string Writing_CD_sector_suffix_block_to_position_0 {
             get {
-                return ResourceManager.GetString("CDRDAO_image_describes_a_disc_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Writing_CD_sector_suffix_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CDRDAO tocfile.
-        /// </summary>
-        internal static string Cdrdao_Name {
+        internal static string Took_0_seconds_to_compress_suffix {
             get {
-                return ResourceManager.GetString("Cdrdao_Name", resourceCulture);
+                return ResourceManager.GetString("Took_0_seconds_to_compress_suffix", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CDRWIN comments: {0}.
-        /// </summary>
-        internal static string CDRWIN_comments_0 {
+        internal static string _0_1_prefixes_are_correct_2_3_prefixes_have_not_been_dumped_4_5_prefixes_have_been_written_to_image {
             get {
-                return ResourceManager.GetString("CDRWIN_comments_0", resourceCulture);
+                return ResourceManager.GetString("_0_1_prefixes_are_correct_2_3_prefixes_have_not_been_dumped_4_5_prefixes_have_bee" +
+                        "n_written_to_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CDRWIN image describes a disc of type {0}.
-        /// </summary>
-        internal static string CDRWIN_image_describes_a_disc_of_type_0 {
+        internal static string _0_1_suffixes_are_correct_2_3_suffixes_have_not_been_dumped_4_5_suffixes_have_been_written_to_image {
             get {
-                return ResourceManager.GetString("CDRWIN_image_describes_a_disc_of_type_0", resourceCulture);
+                return ResourceManager.GetString("_0_1_suffixes_are_correct_2_3_suffixes_have_not_been_dumped_4_5_suffixes_have_bee" +
+                        "n_written_to_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CDRWin cuesheet.
-        /// </summary>
-        internal static string CdrWin_Name {
+        internal static string _0_1_MODE_2_Form_1_are_correct_2_3_MODE_2_Form_2_are_correct_4_5_MODE_2_Form_2_have_empty_CRC {
             get {
-                return ResourceManager.GetString("CdrWin_Name", resourceCulture);
+                return ResourceManager.GetString("_0_1_MODE_2_Form_1_are_correct_2_3_MODE_2_Form_2_are_correct_4_5_MODE_2_Form_2_ha" +
+                        "ve_empty_CRC", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to MAME Compressed Hunks of Data.
-        /// </summary>
-        internal static string Chd_Name {
+        internal static string Writing_CompactDisc_sector_prefix_DDT_to_position_0 {
             get {
-                return ResourceManager.GetString("Chd_Name", resourceCulture);
+                return ResourceManager.GetString("Writing_CompactDisc_sector_prefix_DDT_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CHD version 5 is not yet supported..
-        /// </summary>
-        internal static string CHD_version_5_is_not_yet_supported {
+        internal static string Writing_CompactDisc_sector_suffix_DDT_to_position_0 {
             get {
-                return ResourceManager.GetString("CHD_version_5_is_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Writing_CompactDisc_sector_suffix_DDT_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Checking index integrity at {0}.
-        /// </summary>
-        internal static string Checking_index_integrity_at_0 {
+        internal static string Writing_CD_sector_corrected_prefix_block_to_position_0 {
             get {
-                return ResourceManager.GetString("Checking_index_integrity_at_0", resourceCulture);
+                return ResourceManager.GetString("Writing_CD_sector_corrected_prefix_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Checksum: 0x{0:X4}.
-        /// </summary>
-        internal static string Checksum_0_X4 {
+        internal static string Writing_CD_sector_corrected_suffix_block_to_position_0 {
             get {
-                return ResourceManager.GetString("Checksum_0_X4", resourceCulture);
+                return ResourceManager.GetString("Writing_CD_sector_corrected_suffix_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to China.
-        /// </summary>
-        internal static string China {
+        internal static string Writing_CD_MODE2_subheaders_block_to_position_0 {
             get {
-                return ResourceManager.GetString("China", resourceCulture);
+                return ResourceManager.GetString("Writing_CD_MODE2_subheaders_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to China, Hong Kong.
-        /// </summary>
-        internal static string China_Hong_Kong {
+        internal static string Took_0_seconds_to_compress_MODE2_subheaders {
             get {
-                return ResourceManager.GetString("China_Hong_Kong", resourceCulture);
+                return ResourceManager.GetString("Took_0_seconds_to_compress_MODE2_subheaders", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CHR ROM size: {0} bytes.
-        /// </summary>
-        internal static string CHR_ROM_size_0_bytes {
+        internal static string Writing_CD_subchannel_block_to_position_0 {
             get {
-                return ResourceManager.GetString("CHR_ROM_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Writing_CD_subchannel_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CHS {0},{1},{2}: CRC mismatch: stored CRC=0x{3:x4}, calculated CRC=0x{4:x4}.
-        /// </summary>
-        internal static string CHS_0_1_2_CRC_mismatch_stored_CRC_3_X4_calculated_CRC_4_X4 {
+        internal static string Took_0_seconds_to_compress_subchannel {
             get {
-                return ResourceManager.GetString("CHS_0_1_2_CRC_mismatch_stored_CRC_3_X4_calculated_CRC_4_X4", resourceCulture);
+                return ResourceManager.GetString("Took_0_seconds_to_compress_subchannel", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Chunks compressed with KenCode are not yet supported..
-        /// </summary>
-        internal static string Chunks_compressed_with_KenCode_are_not_yet_supported {
+        internal static string Writing_DVD_CPI_MAI_block_to_position_0 {
             get {
-                return ResourceManager.GetString("Chunks_compressed_with_KenCode_are_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Writing_DVD_CPI_MAI_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Chunks compressed with lzfse are not yet supported..
-        /// </summary>
-        internal static string Chunks_compressed_with_lzfse_are_not_yet_supported {
+        internal static string Took_0_seconds_to_compress_CPI_MAI {
             get {
-                return ResourceManager.GetString("Chunks_compressed_with_lzfse_are_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Took_0_seconds_to_compress_CPI_MAI", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Chunks compressed with LZH are not yet supported..
-        /// </summary>
-        internal static string Chunks_compressed_with_LZH_are_not_yet_supported {
+        internal static string Writing_decrypted_DVD_title_key_block_to_position_0 {
             get {
-                return ResourceManager.GetString("Chunks_compressed_with_LZH_are_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Writing_decrypted_DVD_title_key_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Chunks compressed with StuffIt! are not yet supported..
-        /// </summary>
-        internal static string Chunks_compressed_with_StuffIt_are_not_yet_supported {
+        internal static string Took_0_seconds_to_compress_decrypted_DVD_title_keys {
             get {
-                return ResourceManager.GetString("Chunks_compressed_with_StuffIt_are_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Took_0_seconds_to_compress_decrypted_DVD_title_keys", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CisCopy image contains a disk of type {0}.
-        /// </summary>
-        internal static string CisCopy_image_contains_a_disk_of_type_0 {
+        internal static string Writing_tracks_to_position_0 {
             get {
-                return ResourceManager.GetString("CisCopy_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Writing_tracks_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CisCopy Disk Image (DC-File).
-        /// </summary>
-        internal static string CisCopy_Name {
+        internal static string Writing_compact_disc_indexes_to_position_0 {
             get {
-                return ResourceManager.GetString("CisCopy_Name", resourceCulture);
+                return ResourceManager.GetString("Writing_compact_disc_indexes_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CloneCD.
-        /// </summary>
-        internal static string CloneCd_Name {
+        internal static string Writing_apple_sector_tag_block_to_position_0 {
             get {
-                return ResourceManager.GetString("CloneCd_Name", resourceCulture);
+                return ResourceManager.GetString("Writing_apple_sector_tag_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (CloneCD plugin): Warning! Unknown CCD image version {0}, may not work!.
-        /// </summary>
-        internal static string CloneCD_plugin_Warning_Unknown_CCD_image_version_0_may_not_work {
+        internal static string Writing_metadata_to_position_0 {
             get {
-                return ResourceManager.GetString("CloneCD_plugin_Warning_Unknown_CCD_image_version_0_may_not_work", resourceCulture);
+                return ResourceManager.GetString("Writing_metadata_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cluster size must be a power of 2.
-        /// </summary>
-        internal static string Cluster_size_must_be_a_power_of_2 {
+        internal static string Writing_index_to_position_0 {
             get {
-                return ResourceManager.GetString("Cluster_size_must_be_a_power_of_2", resourceCulture);
+                return ResourceManager.GetString("Writing_index_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cluster size must be between 4 Kbytes and 64 Mbytes.
-        /// </summary>
-        internal static string Cluster_size_must_be_between_4_Kbytes_and_64_Mbytes {
+        internal static string Writing_header {
             get {
-                return ResourceManager.GetString("Cluster_size_must_be_between_4_Kbytes_and_64_Mbytes", resourceCulture);
+                return ResourceManager.GetString("Writing_header", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cluster size must be between 512 bytes and 64 Kbytes.
-        /// </summary>
-        internal static string Cluster_size_must_be_between_512_bytes_and_64_Kbytes {
+        internal static string Tried_to_set_geometry_on_a_media_that_doesnt_support_it {
             get {
-                return ResourceManager.GetString("Cluster_size_must_be_between_512_bytes_and_64_Kbytes", resourceCulture);
+                return ResourceManager.GetString("Tried_to_set_geometry_on_a_media_that_doesnt_support_it", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Comment.
-        /// </summary>
-        internal static string Comment {
+        internal static string Incorrect_tag_for_disk_type {
             get {
-                return ResourceManager.GetString("Comment", resourceCulture);
+                return ResourceManager.GetString("Incorrect_tag_for_disk_type", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Comment: &quot;{0}&quot;.
-        /// </summary>
-        internal static string Comment_0 {
+        internal static string Cant_find_track_0 {
             get {
-                return ResourceManager.GetString("Comment_0", resourceCulture);
+                return ResourceManager.GetString("Cant_find_track_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Comment header.
-        /// </summary>
-        internal static string Comment_header {
+        internal static string Incorrect_data_size_for_track_flags {
             get {
-                return ResourceManager.GetString("Comment_header", resourceCulture);
+                return ResourceManager.GetString("Incorrect_data_size_for_track_flags", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Comment not set..
-        /// </summary>
-        internal static string Comment_not_set {
+        internal static string Incorrect_data_size_for_subchannel {
             get {
-                return ResourceManager.GetString("Comment_not_set", resourceCulture);
+                return ResourceManager.GetString("Incorrect_data_size_for_subchannel", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Comment present, reading.
-        /// </summary>
-        internal static string Comment_present_reading {
+        internal static string Incorrect_data_size_for_CMI {
             get {
-                return ResourceManager.GetString("Comment_present_reading", resourceCulture);
+                return ResourceManager.GetString("Incorrect_data_size_for_CMI", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Composer: {0}.
-        /// </summary>
-        internal static string Composer_0 {
+        internal static string Incorrect_data_size_for_title_key {
             get {
-                return ResourceManager.GetString("Composer_0", resourceCulture);
+                return ResourceManager.GetString("Incorrect_data_size_for_title_key", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Composer is not set..
-        /// </summary>
-        internal static string Composer_is_not_set {
+        internal static string Incorrect_data_size_for_decrypted_title_key {
             get {
-                return ResourceManager.GetString("Composer_is_not_set", resourceCulture);
+                return ResourceManager.GetString("Incorrect_data_size_for_decrypted_title_key", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Compress user data blocks. Other blocks will always be compressed.
-        /// </summary>
-        internal static string Compress_user_data_blocks_Other_blocks_will_always_be_compressed {
+        internal static string Dont_know_how_to_write_sector_tag_type_0 {
             get {
-                return ResourceManager.GetString("Compress_user_data_blocks_Other_blocks_will_always_be_compressed", resourceCulture);
+                return ResourceManager.GetString("Dont_know_how_to_write_sector_tag_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Compressed CD/GD-ROM hunks are not yet supported.
-        /// </summary>
-        internal static string Compressed_CD_GD_ROM_hunks_are_not_yet_supported {
+        internal static string Tried_to_write_more_data_than_possible {
             get {
-                return ResourceManager.GetString("Compressed_CD_GD_ROM_hunks_are_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Tried_to_write_more_data_than_possible", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Compressed extents are not yet supported..
-        /// </summary>
-        internal static string Compressed_extents_are_not_yet_supported {
+        internal static string Alcohol120_Name {
             get {
-                return ResourceManager.GetString("Compressed_extents_are_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Alcohol120_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Compressed images are not supported..
-        /// </summary>
-        internal static string Compressed_images_are_not_supported {
+        internal static string The_disc_this_image_represents_contained_a_hidden_track_in_the_first_pregap_that_this_image_format_cannot_store_This_dump_is_therefore_incorrect {
             get {
-                return ResourceManager.GetString("Compressed_images_are_not_supported", resourceCulture);
+                return ResourceManager.GetString("The_disc_this_image_represents_contained_a_hidden_track_in_the_first_pregap_that_" +
+                        "this_image_format_cannot_store_This_dump_is_therefore_incorrect", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Compressed SaveDskF images are not supported..
-        /// </summary>
-        internal static string Compressed_SaveDskF_images_are_not_supported {
+        internal static string Track_0 {
             get {
-                return ResourceManager.GetString("Compressed_SaveDskF_images_are_not_supported", resourceCulture);
+                return ResourceManager.GetString("Track_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Compressed v5 hunks not yet supported.
-        /// </summary>
-        internal static string Compressed_v5_hunks_not_yet_supported {
+        internal static string printing_partition_map {
             get {
-                return ResourceManager.GetString("Compressed_v5_hunks_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("printing_partition_map", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Console type: {0}.
-        /// </summary>
-        internal static string Console_type_0 {
+        internal static string Partition_sequence_0 {
             get {
-                return ResourceManager.GetString("Console_type_0", resourceCulture);
+                return ResourceManager.GetString("Partition_sequence_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Contains features for Game Boy Color.
-        /// </summary>
-        internal static string Contains_features_for_Game_Boy_Color {
+        internal static string Partition_name_0 {
             get {
-                return ResourceManager.GetString("Contains_features_for_Game_Boy_Color", resourceCulture);
+                return ResourceManager.GetString("Partition_name_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Contains features for Super Game Boy.
-        /// </summary>
-        internal static string Contains_features_for_Super_Game_Boy {
+        internal static string Partition_description_0 {
             get {
-                return ResourceManager.GetString("Contains_features_for_Super_Game_Boy", resourceCulture);
+                return ResourceManager.GetString("Partition_description_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cooking sectors.
-        /// </summary>
-        internal static string Cooking_sectors {
+        internal static string Partition_type_0 {
             get {
-                return ResourceManager.GetString("Cooking_sectors", resourceCulture);
+                return ResourceManager.GetString("Partition_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Coprocessor: {0}.
-        /// </summary>
-        internal static string Coprocessor_0 {
+        internal static string Partition_starting_sector_0 {
             get {
-                return ResourceManager.GetString("Coprocessor_0", resourceCulture);
+                return ResourceManager.GetString("Partition_starting_sector_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CopyQM comments: {0}.
-        /// </summary>
-        internal static string CopyQM_comments_0 {
+        internal static string Partition_sectors_0 {
             get {
-                return ResourceManager.GetString("CopyQM_comments_0", resourceCulture);
+                return ResourceManager.GetString("Partition_sectors_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CopyQM image contains a disk of type {0}.
-        /// </summary>
-        internal static string CopyQM_image_contains_a_disk_of_type_0 {
+        internal static string Partition_starting_offset_0 {
             get {
-                return ResourceManager.GetString("CopyQM_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Partition_starting_offset_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sydex CopyQM.
-        /// </summary>
-        internal static string CopyQm_Name {
+        internal static string Partition_size_in_bytes_0 {
             get {
-                return ResourceManager.GetString("CopyQm_Name", resourceCulture);
+                return ResourceManager.GetString("Partition_size_in_bytes_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Copyright string: {0}.
-        /// </summary>
-        internal static string Copyright_string_0 {
+        internal static string Data_filename_0 {
             get {
-                return ResourceManager.GetString("Copyright_string_0", resourceCulture);
+                return ResourceManager.GetString("Data_filename_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CopyTape.
-        /// </summary>
-        internal static string CopyTape_Name {
+        internal static string Cannot_open_data_file {
             get {
-                return ResourceManager.GetString("CopyTape_Name", resourceCulture);
+                return ResourceManager.GetString("Cannot_open_data_file", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Correctly arrived end of image.
-        /// </summary>
-        internal static string Correctly_arrived_end_of_image {
+        internal static string Rebuilding_TOC {
             get {
-                return ResourceManager.GetString("Correctly_arrived_end_of_image", resourceCulture);
+                return ResourceManager.GetString("Rebuilding_TOC", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not create new image file, exception {0}.
-        /// </summary>
-        internal static string Could_not_create_new_image_file_exception_0 {
+        internal static string Alcohol_120_image_describes_a_disc_of_type_0 {
             get {
-                return ResourceManager.GetString("Could_not_create_new_image_file_exception_0", resourceCulture);
+                return ResourceManager.GetString("Alcohol_120_image_describes_a_disc_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not create subchannel file, exception {0}.
-        /// </summary>
-        internal static string Could_not_create_subchannel_file_exception_0 {
+        internal static string Incorrect_Alcohol_120_image_created_by_an_old_version_of_Aaru_Convert_image_to_correct_it {
             get {
-                return ResourceManager.GetString("Could_not_create_subchannel_file_exception_0", resourceCulture);
+                return ResourceManager.GetString("Incorrect_Alcohol_120_image_created_by_an_old_version_of_Aaru_Convert_image_to_co" +
+                        "rrect_it", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not find image for track {0}.
-        /// </summary>
-        internal static string Could_not_find_image_for_track_0 {
+        internal static string Unsupported_media_tag_0_for_medium_type_1 {
             get {
-                return ResourceManager.GetString("Could_not_find_image_for_track_0", resourceCulture);
+                return ResourceManager.GetString("Unsupported_media_tag_0_for_medium_type_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not find partclone BiTmAgIc, not continuing....
-        /// </summary>
-        internal static string Could_not_find_partclone_BiTmAgIc_not_continuing {
+        internal static string Cannot_write_non_long_sectors_to_CD_images {
             get {
-                return ResourceManager.GetString("Could_not_find_partclone_BiTmAgIc_not_continuing", resourceCulture);
+                return ResourceManager.GetString("Cannot_write_non_long_sectors_to_CD_images", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not find user data deduplication table..
-        /// </summary>
-        internal static string Could_not_find_user_data_deduplication_table {
+        internal static string Cant_find_track_containing_0 {
             get {
-                return ResourceManager.GetString("Could_not_find_user_data_deduplication_table", resourceCulture);
+                return ResourceManager.GetString("Cant_find_track_containing_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not parse property list..
-        /// </summary>
-        internal static string Could_not_parse_property_list {
+        internal static string Invalid_write_mode_for_this_sector {
             get {
-                return ResourceManager.GetString("Could_not_parse_property_list", resourceCulture);
+                return ResourceManager.GetString("Invalid_write_mode_for_this_sector", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not retrieve block chunks. Please fill an issue and send it to us..
-        /// </summary>
-        internal static string Could_not_retrieve_block_chunks {
+        internal static string Cant_cross_tracks {
             get {
-                return ResourceManager.GetString("Could_not_retrieve_block_chunks", resourceCulture);
+                return ResourceManager.GetString("Cant_cross_tracks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not retrieve block chunks array..
-        /// </summary>
-        internal static string Could_not_retrieve_block_chunks_array {
+        internal static string Invalid_subchannel_mode_for_this_sector {
             get {
-                return ResourceManager.GetString("Could_not_retrieve_block_chunks_array", resourceCulture);
+                return ResourceManager.GetString("Invalid_subchannel_mode_for_this_sector", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not retrieve Data.
-        /// </summary>
-        internal static string Could_not_retrieve_Data {
+        internal static string Unsupported_subchannel_type_0 {
             get {
-                return ResourceManager.GetString("Could_not_retrieve_Data", resourceCulture);
+                return ResourceManager.GetString("Unsupported_subchannel_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not retrieve Name.
-        /// </summary>
-        internal static string Could_not_retrieve_Name {
+        internal static string Trying_to_write_subchannel_to_track_0_that_does_not_have_subchannel {
             get {
-                return ResourceManager.GetString("Could_not_retrieve_Name", resourceCulture);
+                return ResourceManager.GetString("Trying_to_write_subchannel_to_track_0_that_does_not_have_subchannel", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Could not retrieve resource fork..
-        /// </summary>
-        internal static string Could_not_retrieve_resource_fork {
+        internal static string Unsupported_tag_type_0 {
             get {
-                return ResourceManager.GetString("Could_not_retrieve_resource_fork", resourceCulture);
+                return ResourceManager.GetString("Unsupported_tag_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CPCEMU Disk-File and Extended CPC Disk-File.
-        /// </summary>
-        internal static string Cpcdsk_Name {
+        internal static string Anex86_Name {
             get {
-                return ResourceManager.GetString("Cpcdsk_Name", resourceCulture);
+                return ResourceManager.GetString("Anex86_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CRC1: 0x{0:X8}.
-        /// </summary>
-        internal static string CRC1_0 {
+        internal static string MediaType_0 {
             get {
-                return ResourceManager.GetString("CRC1_0", resourceCulture);
+                return ResourceManager.GetString("MediaType_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to CRC2: 0x{0:X8}.
-        /// </summary>
-        internal static string CRC2_0 {
+        internal static string Unsupported_sector_size {
             get {
-                return ResourceManager.GetString("CRC2_0", resourceCulture);
+                return ResourceManager.GetString("Unsupported_sector_size", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Creator: &quot;{0}&quot;.
-        /// </summary>
-        internal static string Creator_0 {
+        internal static string Too_many_sectors {
             get {
-                return ResourceManager.GetString("Creator_0", resourceCulture);
+                return ResourceManager.GetString("Too_many_sectors", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cuesheet entry {0}.
-        /// </summary>
-        internal static string Cuesheet_entry_0 {
+        internal static string Writing_media_tags_is_not_supported {
             get {
-                return ResourceManager.GetString("Cuesheet_entry_0", resourceCulture);
+                return ResourceManager.GetString("Writing_media_tags_is_not_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Current position = {0}.
-        /// </summary>
-        internal static string Current_position_equals_0 {
+        internal static string Writing_sectors_with_tags_is_not_supported {
             get {
-                return ResourceManager.GetString("Current_position_equals_0", resourceCulture);
+                return ResourceManager.GetString("Writing_sectors_with_tags_is_not_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to cylinders = {0}.
-        /// </summary>
-        internal static string cylinders_equal_0 {
+        internal static string Too_many_cylinders {
             get {
-                return ResourceManager.GetString("cylinders_equal_0", resourceCulture);
+                return ResourceManager.GetString("Too_many_cylinders", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to D88 Disk Image.
-        /// </summary>
-        internal static string D88_Name {
+        internal static string Too_many_heads {
             get {
-                return ResourceManager.GetString("D88_Name", resourceCulture);
+                return ResourceManager.GetString("Too_many_heads", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Apple Disk Archival/Retrieval Tool.
-        /// </summary>
-        internal static string Dart_Name {
+        internal static string Too_many_sectors_per_track {
             get {
-                return ResourceManager.GetString("Dart_Name", resourceCulture);
+                return ResourceManager.GetString("Too_many_sectors_per_track", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Data: {0} sectors.
-        /// </summary>
-        internal static string Data_0_sectors {
+        internal static string Apple2Mg_Name {
             get {
-                return ResourceManager.GetString("Data_0_sectors", resourceCulture);
+                return ResourceManager.GetString("Apple2Mg_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Data: {0} sectors starting at sector {1}.
-        /// </summary>
-        internal static string Data_0_sectors_starting_at_sector_1 {
+        internal static string Detected_incorrect_endian_on_data_size_field_correcting {
             get {
-                return ResourceManager.GetString("Data_0_sectors_starting_at_sector_1", resourceCulture);
+                return ResourceManager.GetString("Detected_incorrect_endian_on_data_size_field_correcting", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Data encoding {0} is incorrect..
-        /// </summary>
-        internal static string Data_encoding_0_is_incorrect {
+        internal static string Unknown_creator_code_0 {
             get {
-                return ResourceManager.GetString("Data_encoding_0_is_incorrect", resourceCulture);
+                return ResourceManager.GetString("Unknown_creator_code_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Data encoding: 0x{0:X2}.
-        /// </summary>
-        internal static string Data_encoding_0_X2 {
+        internal static string _2MG_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("Data_encoding_0_X2", resourceCulture);
+                return ResourceManager.GetString("_2MG_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Data file {0} not found.
-        /// </summary>
-        internal static string Data_file_0_not_found {
+        internal static string _2MG_comments_0 {
             get {
-                return ResourceManager.GetString("Data_file_0_not_found", resourceCulture);
+                return ResourceManager.GetString("_2MG_comments_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Data filename: {0}.
-        /// </summary>
-        internal static string Data_filename_0 {
+        internal static string AppleDos_Name {
             get {
-                return ResourceManager.GetString("Data_filename_0", resourceCulture);
+                return ResourceManager.GetString("AppleDos_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Data path: {0}.
-        /// </summary>
-        internal static string Data_path_0 {
+        internal static string Incorrect_number_of_sectors_for_media {
             get {
-                return ResourceManager.GetString("Data_path_0", resourceCulture);
+                return ResourceManager.GetString("Incorrect_number_of_sectors_for_media", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Data size (in-image): {0}.
-        /// </summary>
-        internal static string Data_size_in_image_0 {
+        internal static string AppleNib_Name {
             get {
-                return ResourceManager.GetString("Data_size_in_image_0", resourceCulture);
+                return ResourceManager.GetString("AppleNib_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Decoding whole image.
-        /// </summary>
         internal static string Decoding_whole_image {
             get {
                 return ResourceManager.GetString("Decoding_whole_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Decompressing DDT....
-        /// </summary>
-        internal static string Decompressing_DDT {
-            get {
-                return ResourceManager.GetString("Decompressing_DDT", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Denmark.
-        /// </summary>
-        internal static string Denmark {
+        internal static string Got_0_tracks {
             get {
-                return ResourceManager.GetString("Denmark", resourceCulture);
+                return ResourceManager.GetString("Got_0_tracks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Detected DiskDupe DDI image with {0} tracks and {1} sectors per track..
-        /// </summary>
-        internal static string Detected_DiskDupe_DDI_image_with_0_tracks_and_1_sectors_per_track {
+        internal static string Using_DOS_skewing {
             get {
-                return ResourceManager.GetString("Detected_DiskDupe_DDI_image_with_0_tracks_and_1_sectors_per_track", resourceCulture);
+                return ResourceManager.GetString("Using_DOS_skewing", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Detected HD-Copy image with {0} tracks and {1} sectors per track..
-        /// </summary>
-        internal static string Detected_HD_Copy_image_with_0_tracks_and_1_sectors_per_track {
+        internal static string Using_ProDOS_skewing {
             get {
-                return ResourceManager.GetString("Detected_HD_Copy_image_with_0_tracks_and_1_sectors_per_track", resourceCulture);
+                return ResourceManager.GetString("Using_ProDOS_skewing", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Detected incorrect endian on data size field, correcting..
-        /// </summary>
-        internal static string Detected_incorrect_endian_on_data_size_field_correcting {
+        internal static string Hardware_sector_0_of_track_1_goes_to_logical_sector_2 {
             get {
-                return ResourceManager.GetString("Detected_incorrect_endian_on_data_size_field_correcting", resourceCulture);
+                return ResourceManager.GetString("Hardware_sector_0_of_track_1_goes_to_logical_sector_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Detected WC DISK IMAGE with {0} heads, {1} tracks and {2} sectors per track..
-        /// </summary>
-        internal static string Detected_WC_DISK_IMAGE_with_0_heads_1_tracks_and_2_sectors_per_track {
+        internal static string Got_0_sectors {
             get {
-                return ResourceManager.GetString("Detected_WC_DISK_IMAGE_with_0_heads_1_tracks_and_2_sectors_per_track", resourceCulture);
+                return ResourceManager.GetString("Got_0_sectors", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Device type: {0}.
-        /// </summary>
-        internal static string Device_type_0 {
+        internal static string Cooking_sectors {
             get {
-                return ResourceManager.GetString("Device_type_0", resourceCulture);
+                return ResourceManager.GetString("Cooking_sectors", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Devices supported: {0}.
-        /// </summary>
-        internal static string Devices_supported_0 {
+        internal static string Apridisk_Name {
             get {
-                return ResourceManager.GetString("Devices_supported_0", resourceCulture);
+                return ResourceManager.GetString("Apridisk_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Did not find any extent.
-        /// </summary>
-        internal static string Did_not_find_any_extent {
+        internal static string Enable_Apridisk_compression {
             get {
-                return ResourceManager.GetString("Did_not_find_any_extent", resourceCulture);
+                return ResourceManager.GetString("Enable_Apridisk_compression", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Did not find any track..
-        /// </summary>
-        internal static string Did_not_find_any_track {
+        internal static string Found_deleted_record_at_0 {
             get {
-                return ResourceManager.GetString("Did_not_find_any_track", resourceCulture);
+                return ResourceManager.GetString("Found_deleted_record_at_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Differencing images not yet supported.
-        /// </summary>
-        internal static string Differencing_images_not_yet_supported {
+        internal static string Found_comment_record_at_0 {
             get {
-                return ResourceManager.GetString("Differencing_images_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Found_comment_record_at_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Digital Research DiskCopy image contains a disk of type {0}.
-        /// </summary>
-        internal static string Digital_Research_DiskCopy_image_contains_a_disk_of_type_0 {
+        internal static string Comment_0 {
             get {
-                return ResourceManager.GetString("Digital_Research_DiskCopy_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Comment_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to DIM comments: {0}.
-        /// </summary>
-        internal static string DIM_comments_0 {
+        internal static string Found_creator_record_at_0 {
             get {
-                return ResourceManager.GetString("DIM_comments_0", resourceCulture);
+                return ResourceManager.GetString("Found_creator_record_at_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to DIM image contains a disk of type {0}.
-        /// </summary>
-        internal static string DIM_image_contains_a_disk_of_type_0 {
+        internal static string Creator_0 {
             get {
-                return ResourceManager.GetString("DIM_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Creator_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to DIM Disk Image.
-        /// </summary>
-        internal static string Dim_Name {
+        internal static string Found_compressed_sector_record_at_0_for_cylinder_1_head_2_sector_3 {
             get {
-                return ResourceManager.GetString("Dim_Name", resourceCulture);
+                return ResourceManager.GetString("Found_compressed_sector_record_at_0_for_cylinder_1_head_2_sector_3", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to DIM shows unknown image with {0} tracks.
-        /// </summary>
-        internal static string DIM_shows_unknown_image_with_0_tracks {
+        internal static string Found_uncompressed_sector_record_at_0_for_cylinder_1_head_2_sector_3 {
             get {
-                return ResourceManager.GetString("DIM_shows_unknown_image_with_0_tracks", resourceCulture);
+                return ResourceManager.GetString("Found_uncompressed_sector_record_at_0_for_cylinder_1_head_2_sector_3", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Directory listing present, reading.
-        /// </summary>
-        internal static string Directory_listing_present_reading {
+        internal static string Found_0_cylinders_and_1_heads_with_a_maximum_sector_number_of_2 {
             get {
-                return ResourceManager.GetString("Directory_listing_present_reading", resourceCulture);
+                return ResourceManager.GetString("Found_0_cylinders_and_1_heads_with_a_maximum_sector_number_of_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc-At-Once entry {0}.
-        /// </summary>
-        internal static string Disc_At_Once_entry_0 {
+        internal static string Found_a_minimum_of_0_bytes_per_sector {
             get {
-                return ResourceManager.GetString("Disc_At_Once_entry_0", resourceCulture);
+                return ResourceManager.GetString("Found_a_minimum_of_0_bytes_per_sector", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc CD-TEXT:.
-        /// </summary>
-        internal static string Disc_CD_TEXT {
+        internal static string Found_a_minimum_of_0_sectors_per_track {
             get {
-                return ResourceManager.GetString("Disc_CD_TEXT", resourceCulture);
+                return ResourceManager.GetString("Found_a_minimum_of_0_sectors_per_track", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc contains {0} sessions.
-        /// </summary>
-        internal static string Disc_contains_0_sessions {
+        internal static string Sector_address_not_found {
             get {
-                return ResourceManager.GetString("Disc_contains_0_sessions", resourceCulture);
+                return ResourceManager.GetString("Sector_address_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc contains {0} tracks.
-        /// </summary>
-        internal static string Disc_contains_0_tracks {
+        internal static string BlindWrite4_Name {
             get {
-                return ResourceManager.GetString("Disc_contains_0_tracks", resourceCulture);
+                return ResourceManager.GetString("BlindWrite4_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc ID: {0}.
-        /// </summary>
-        internal static string Disc_ID_0 {
+        internal static string Data_file_0_not_found {
             get {
-                return ResourceManager.GetString("Disc_ID_0", resourceCulture);
+                return ResourceManager.GetString("Data_file_0_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc ID: {0:X6}.
-        /// </summary>
-        internal static string Disc_ID_0_X6 {
+        internal static string Unable_to_find_data_file {
             get {
-                return ResourceManager.GetString("Disc_ID_0_X6", resourceCulture);
+                return ResourceManager.GetString("Unable_to_find_data_file", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc ID not set..
-        /// </summary>
-        internal static string Disc_ID_not_set {
+        internal static string BlindWrite_image_describes_a_disc_of_type_0 {
             get {
-                return ResourceManager.GetString("Disc_ID_not_set", resourceCulture);
+                return ResourceManager.GetString("BlindWrite_image_describes_a_disc_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc image parsing results.
-        /// </summary>
-        internal static string Disc_image_parsing_results {
+        internal static string BlindWrite_comments_0 {
             get {
-                return ResourceManager.GetString("Disc_image_parsing_results", resourceCulture);
+                return ResourceManager.GetString("BlindWrite_comments_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc information:.
-        /// </summary>
-        internal static string Disc_information {
+        internal static string BlindWrite5_Name {
             get {
-                return ResourceManager.GetString("Disc_information", resourceCulture);
+                return ResourceManager.GetString("BlindWrite5_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc information: {0}.
-        /// </summary>
-        internal static string Disc_information_0 {
+        internal static string mode_page_2A_0 {
             get {
-                return ResourceManager.GetString("Disc_information_0", resourceCulture);
+                return ResourceManager.GetString("mode_page_2A_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc manufactured by: {0}.
-        /// </summary>
-        internal static string Disc_manufactured_by_0 {
+        internal static string PMA_0 {
             get {
-                return ResourceManager.GetString("Disc_manufactured_by_0", resourceCulture);
+                return ResourceManager.GetString("PMA_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disc Type: {0}.
-        /// </summary>
-        internal static string Disc_Type_0 {
+        internal static string PFI_0 {
             get {
-                return ResourceManager.GetString("Disc_Type_0", resourceCulture);
+                return ResourceManager.GetString("PFI_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to DiscFerret.
-        /// </summary>
-        internal static string DiscFerret_Name {
+        internal static string Disc_information_0 {
             get {
-                return ResourceManager.GetString("DiscFerret_Name", resourceCulture);
+                return ResourceManager.GetString("Disc_information_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to DiscJuggler.
-        /// </summary>
-        internal static string DiscJuggler_Name {
+        internal static string Data_path_0 {
             get {
-                return ResourceManager.GetString("DiscJuggler_Name", resourceCulture);
+                return ResourceManager.GetString("Data_path_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Disk tracks are not same size. spt = {0} (expected {1}), bps = {2} (expected {3}) at track {4} sector {5}.
-        /// </summary>
-        internal static string Disk_tracks_are_not_same_size {
+        internal static string Correctly_arrived_end_of_image {
             get {
-                return ResourceManager.GetString("Disk_tracks_are_not_same_size", resourceCulture);
+                return ResourceManager.GetString("Correctly_arrived_end_of_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to DiskCopy 4.2 image contains a disk of type {0}.
-        /// </summary>
-        internal static string DiskCopy_4_2_image_contains_a_disk_of_type_0 {
+        internal static string BlindWrite5_image_ends_after_expected_position_Probably_new_version_with_different_data_Errors_may_occur {
             get {
-                return ResourceManager.GetString("DiskCopy_4_2_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("BlindWrite5_image_ends_after_expected_position_Probably_new_version_with_differen" +
+                        "t_data_Errors_may_occur", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Apple DiskCopy 4.2.
-        /// </summary>
-        internal static string DiskCopy42_Name {
+        internal static string Cannot_find_data_file_0 {
             get {
-                return ResourceManager.GetString("DiskCopy42_Name", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_data_file_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to DiskDupe DDI Disk Image.
-        /// </summary>
-        internal static string DiskDupe_Name {
+        internal static string BlindWrite5_found_unknown_subchannel_size_0 {
             get {
-                return ResourceManager.GetString("DiskDupe_Name", resourceCulture);
+                return ResourceManager.GetString("BlindWrite5_found_unknown_subchannel_size_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Domestic title: {0}.
-        /// </summary>
-        internal static string Domestic_title_0 {
+        internal static string Building_maps {
             get {
-                return ResourceManager.GetString("Domestic_title_0", resourceCulture);
+                return ResourceManager.GetString("Building_maps", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Don&apos;t know how to write sector tag type {0}.
-        /// </summary>
-        internal static string Dont_know_how_to_write_sector_tag_type_0 {
+        internal static string Could_not_find_image_for_track_0 {
             get {
-                return ResourceManager.GetString("Dont_know_how_to_write_sector_tag_type_0", resourceCulture);
+                return ResourceManager.GetString("Could_not_find_image_for_track_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Digital Research DiskCopy.
-        /// </summary>
-        internal static string DriDiskCopy_Name {
+        internal static string Partition_ending_sector_0 {
             get {
-                return ResourceManager.GetString("DriDiskCopy_Name", resourceCulture);
+                return ResourceManager.GetString("Partition_ending_sector_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Dunno how to handle &quot;{0}&quot; extents..
-        /// </summary>
-        internal static string Dunno_how_to_handle_0_extents {
+        internal static string printing_track_map {
             get {
-                return ResourceManager.GetString("Dunno_how_to_handle_0_extents", resourceCulture);
+                return ResourceManager.GetString("printing_track_map", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Dynamic header checksum = 0x{0:X8}, calculated = 0x{1:X8}.
-        /// </summary>
-        internal static string Dynamic_header_checksum_equals_0_X8_calculated_1_X8 {
+        internal static string Track_description_0 {
             get {
-                return ResourceManager.GetString("Dynamic_header_checksum_equals_0_X8_calculated_1_X8", resourceCulture);
+                return ResourceManager.GetString("Track_description_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Enable Apridisk compression..
-        /// </summary>
-        internal static string Enable_Apridisk_compression {
+        internal static string Track_type_0 {
             get {
-                return ResourceManager.GetString("Enable_Apridisk_compression", resourceCulture);
+                return ResourceManager.GetString("Track_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Encrypted images are currently not supported..
-        /// </summary>
-        internal static string Encrypted_images_are_currently_not_supported {
+        internal static string Track_starting_sector_0 {
             get {
-                return ResourceManager.GetString("Encrypted_images_are_currently_not_supported", resourceCulture);
+                return ResourceManager.GetString("Track_starting_sector_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Encrypted images are not yet supported..
-        /// </summary>
-        internal static string Encrypted_images_are_not_yet_supported {
+        internal static string Track_ending_sector_0 {
             get {
-                return ResourceManager.GetString("Encrypted_images_are_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Track_ending_sector_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to End of disk image arrived.
-        /// </summary>
-        internal static string End_of_disk_image_arrived {
+        internal static string TOC_len_0 {
             get {
-                return ResourceManager.GetString("End_of_disk_image_arrived", resourceCulture);
+                return ResourceManager.GetString("TOC_len_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to End position = {0}.
-        /// </summary>
-        internal static string End_position_equals_0 {
+        internal static string Blu_Name {
             get {
-                return ResourceManager.GetString("End_position_equals_0", resourceCulture);
+                return ResourceManager.GetString("Blu_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Ending sector: {0}.
-        /// </summary>
-        internal static string Ending_sector_0 {
+        internal static string BLU_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("Ending_sector_0", resourceCulture);
+                return ResourceManager.GetString("BLU_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Ending track: {0}.
-        /// </summary>
-        internal static string Ending_track_0 {
+        internal static string AtariLynx_Name {
             get {
-                return ResourceManager.GetString("Ending_track_0", resourceCulture);
+                return ResourceManager.GetString("AtariLynx_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Error {0} opening parent &quot;{1}&quot;..
-        /// </summary>
-        internal static string Error_0_opening_parent_1 {
+        internal static string Name_0 {
             get {
-                return ResourceManager.GetString("Error_0_opening_parent_1", resourceCulture);
+                return ResourceManager.GetString("Name_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Error decompressing block, should be {0} bytes but got {1} bytes..
-        /// </summary>
-        internal static string Error_decompressing_block_should_be_0_bytes_but_got_1_bytes {
+        internal static string Manufacturer_0 {
             get {
-                return ResourceManager.GetString("Error_decompressing_block_should_be_0_bytes_but_got_1_bytes", resourceCulture);
+                return ResourceManager.GetString("Manufacturer_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Error decompressing DDT, should be {0} bytes but got {1} bytes..
-        /// </summary>
-        internal static string Error_decompressing_DDT_should_be_0_bytes_but_got_1_bytes {
+        internal static string Bank_zero_size_0_pages_1_bytes {
             get {
-                return ResourceManager.GetString("Error_decompressing_DDT_should_be_0_bytes_but_got_1_bytes", resourceCulture);
+                return ResourceManager.GetString("Bank_zero_size_0_pages_1_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Europe.
-        /// </summary>
-        internal static string Europe {
+        internal static string Bank_one_size_0_pages_1_bytes {
             get {
-                return ResourceManager.GetString("Europe", resourceCulture);
+                return ResourceManager.GetString("Bank_one_size_0_pages_1_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Europe, Oceania, Asia.
-        /// </summary>
-        internal static string Europe_Oceania_Asia {
+        internal static string Rotation_0 {
             get {
-                return ResourceManager.GetString("Europe_Oceania_Asia", resourceCulture);
+                return ResourceManager.GetString("Rotation_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Exception: {0}.
-        /// </summary>
-        internal static string Exception_0 {
+        internal static string No_image_has_been_opened {
             get {
-                return ResourceManager.GetString("Exception_0", resourceCulture);
+                return ResourceManager.GetString("No_image_has_been_opened", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Exception {0} processing Aaru Metadata block.
-        /// </summary>
-        internal static string Exception_0_processing_Aaru_Metadata_block {
+        internal static string Cannot_create_an_opened_image {
             get {
-                return ResourceManager.GetString("Exception_0_processing_Aaru_Metadata_block", resourceCulture);
+                return ResourceManager.GetString("Cannot_create_an_opened_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Exception {0} processing CICM XML metadata block.
-        /// </summary>
-        internal static string Exception_0_processing_CICM_XML_metadata_block {
+        internal static string The_requested_position_is_out_of_range {
             get {
-                return ResourceManager.GetString("Exception_0_processing_CICM_XML_metadata_block", resourceCulture);
+                return ResourceManager.GetString("The_requested_position_is_out_of_range", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Exception occurred opening file..
-        /// </summary>
-        internal static string Exception_occurred_opening_file {
+        internal static string Buffer_must_not_be_null {
             get {
-                return ResourceManager.GetString("Exception_occurred_opening_file", resourceCulture);
+                return ResourceManager.GetString("Buffer_must_not_be_null", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Exception trying to identify image file {0}.
-        /// </summary>
-        internal static string Exception_trying_to_identify_image_file_0 {
+        internal static string GameBoy_Name {
             get {
-                return ResourceManager.GetString("Exception_trying_to_identify_image_file_0", resourceCulture);
+                return ResourceManager.GetString("GameBoy_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Exception trying to open image file {0}.
-        /// </summary>
-        internal static string Exception_trying_to_open_image_file_0 {
+        internal static string Requires_Game_Boy_Color {
             get {
-                return ResourceManager.GetString("Exception_trying_to_open_image_file_0", resourceCulture);
+                return ResourceManager.GetString("Requires_Game_Boy_Color", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Expansion RAM size: {0} bytes.
-        /// </summary>
-        internal static string Expansion_RAM_size_0_bytes {
+        internal static string Contains_features_for_Game_Boy_Color {
             get {
-                return ResourceManager.GetString("Expansion_RAM_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Contains_features_for_Game_Boy_Color", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Expected block CRC {0:X16} but got {1:X16}.
-        /// </summary>
-        internal static string Expected_block_CRC_0_X16_but_got_1_X16 {
+        internal static string Contains_features_for_Super_Game_Boy {
             get {
-                return ResourceManager.GetString("Expected_block_CRC_0_X16_but_got_1_X16", resourceCulture);
+                return ResourceManager.GetString("Contains_features_for_Super_Game_Boy", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Expected block with data type {0} at position {1} but found data type {2}.
-        /// </summary>
-        internal static string Expected_block_with_data_type_0_at_position_1_but_found_data_type_2 {
+        internal static string Region_0 {
             get {
-                return ResourceManager.GetString("Expected_block_with_data_type_0_at_position_1_but_found_data_type_2", resourceCulture);
+                return ResourceManager.GetString("Region_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Expected CRC32: {0}.
-        /// </summary>
-        internal static string Expected_CRC32_0 {
+        internal static string Japan {
             get {
-                return ResourceManager.GetString("Expected_CRC32_0", resourceCulture);
+                return ResourceManager.GetString("Japan", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Expected DDT CRC {0:X16} but got {1:X16}.
-        /// </summary>
-        internal static string Expected_DDT_CRC_0_but_got_1 {
+        internal static string World {
             get {
-                return ResourceManager.GetString("Expected_DDT_CRC_0_but_got_1", resourceCulture);
+                return ResourceManager.GetString("World", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Expected index CRC {0:X16} but got {1:X16}.
-        /// </summary>
-        internal static string Expected_index_CRC_0_X16_but_got_1_X16 {
+        internal static string Cartridge_type_0 {
             get {
-                return ResourceManager.GetString("Expected_index_CRC_0_X16_but_got_1_X16", resourceCulture);
+                return ResourceManager.GetString("Cartridge_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Expected MD5: {0}.
-        /// </summary>
-        internal static string Expected_MD5_0 {
+        internal static string ROM_size_0_bytes {
             get {
-                return ResourceManager.GetString("Expected_MD5_0", resourceCulture);
+                return ResourceManager.GetString("ROM_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Expected SHA1: {0}.
-        /// </summary>
-        internal static string Expected_SHA1_0 {
+        internal static string Save_RAM_size_0_bytes {
             get {
-                return ResourceManager.GetString("Expected_SHA1_0", resourceCulture);
+                return ResourceManager.GetString("Save_RAM_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Export.
-        /// </summary>
-        internal static string Export {
+        internal static string Licensee_0 {
             get {
-                return ResourceManager.GetString("Export", resourceCulture);
+                return ResourceManager.GetString("Licensee_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extended = {0}.
-        /// </summary>
-        internal static string Extended_equals_0 {
+        internal static string Revision_0 {
             get {
-                return ResourceManager.GetString("Extended_equals_0", resourceCulture);
+                return ResourceManager.GetString("Revision_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extent {0} is too small..
-        /// </summary>
-        internal static string Extent_0_is_too_small {
+        internal static string Header_checksum_0 {
             get {
-                return ResourceManager.GetString("Extent_0_is_too_small", resourceCulture);
+                return ResourceManager.GetString("Header_checksum_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extent contains incorrect number of sectors, {0}. {1} were expected.
-        /// </summary>
-        internal static string Extent_contains_incorrect_number_of_sectors_0_1_were_expected {
+        internal static string Checksum_0_X4 {
             get {
-                return ResourceManager.GetString("Extent_contains_incorrect_number_of_sectors_0_1_were_expected", resourceCulture);
+                return ResourceManager.GetString("Checksum_0_X4", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extent file {0} not found..
-        /// </summary>
-        internal static string Extent_file_0_not_found {
+        internal static string none_licensee {
             get {
-                return ResourceManager.GetString("Extent_file_0_not_found", resourceCulture);
+                return ResourceManager.GetString("none_licensee", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra RAM is of unknown type 0x{0:X2}.
-        /// </summary>
-        internal static string Extra_RAM_is_of_unknown_type_0 {
+        internal static string Unknown_licensee {
             get {
-                return ResourceManager.GetString("Extra_RAM_is_of_unknown_type_0", resourceCulture);
+                return ResourceManager.GetString("Unknown_licensee", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra RAM not present..
-        /// </summary>
-        internal static string Extra_RAM_not_present {
+        internal static string GBC_see_above {
             get {
-                return ResourceManager.GetString("Extra_RAM_not_present", resourceCulture);
+                return ResourceManager.GetString("GBC_see_above", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra RAM present..
-        /// </summary>
-        internal static string Extra_RAM_present {
+        internal static string ROM_only {
             get {
-                return ResourceManager.GetString("Extra_RAM_present", resourceCulture);
+                return ResourceManager.GetString("ROM_only", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra RAM starts at 0x{0:X8} and ends at 0x{1:X8} ({2} bytes).
-        /// </summary>
-        internal static string Extra_RAM_starts_at_0_and_ends_at_1_2_bytes {
+        internal static string ROM_and_MBC1 {
             get {
-                return ResourceManager.GetString("Extra_RAM_starts_at_0_and_ends_at_1_2_bytes", resourceCulture);
+                return ResourceManager.GetString("ROM_and_MBC1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra RAM uses 16-bit access..
-        /// </summary>
-        internal static string Extra_RAM_uses_16_bit_access {
+        internal static string ROM_MBC1_and_RAM {
             get {
-                return ResourceManager.GetString("Extra_RAM_uses_16_bit_access", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC1_and_RAM", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra RAM uses 16-bit access and persists when powered off..
-        /// </summary>
-        internal static string Extra_RAM_uses_16_bit_access_and_persists_when_powered_off {
+        internal static string ROM_MBC1_RAM_and_battery {
             get {
-                return ResourceManager.GetString("Extra_RAM_uses_16_bit_access_and_persists_when_powered_off", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC1_RAM_and_battery", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra RAM uses 8-bit access (even addresses)..
-        /// </summary>
-        internal static string Extra_RAM_uses_8_bit_access_even_addresses {
+        internal static string ROM_and_MBC2 {
             get {
-                return ResourceManager.GetString("Extra_RAM_uses_8_bit_access_even_addresses", resourceCulture);
+                return ResourceManager.GetString("ROM_and_MBC2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra RAM uses 8-bit access (even addresses) and persists when powered off..
-        /// </summary>
-        internal static string Extra_RAM_uses_8_bit_access_even_addresses_and_persists_when_powered_off {
+        internal static string ROM_MBC2_and_battery {
             get {
-                return ResourceManager.GetString("Extra_RAM_uses_8_bit_access_even_addresses_and_persists_when_powered_off", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC2_and_battery", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra RAM uses 8-bit access (odd addresses)..
-        /// </summary>
-        internal static string Extra_RAM_uses_8_bit_access_odd_addresses {
+        internal static string ROM_and_RAM {
             get {
-                return ResourceManager.GetString("Extra_RAM_uses_8_bit_access_odd_addresses", resourceCulture);
+                return ResourceManager.GetString("ROM_and_RAM", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra RAM uses 8-bit access (odd addresses) and persists when powered off..
-        /// </summary>
-        internal static string Extra_RAM_uses_8_bit_access_odd_addresses_and_persists_when_powered_off {
+        internal static string ROM_RAM_and_battery {
             get {
-                return ResourceManager.GetString("Extra_RAM_uses_8_bit_access_odd_addresses_and_persists_when_powered_off", resourceCulture);
+                return ResourceManager.GetString("ROM_RAM_and_battery", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra track 1 (head 0) present, reading.
-        /// </summary>
-        internal static string Extra_track_1_head_0_present_reading {
+        internal static string ROM_and_MMM01 {
             get {
-                return ResourceManager.GetString("Extra_track_1_head_0_present_reading", resourceCulture);
+                return ResourceManager.GetString("ROM_and_MMM01", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra track 1 (head 1) present, reading.
-        /// </summary>
-        internal static string Extra_track_1_head_1_present_reading {
+        internal static string ROM_MMM01_and_RAM {
             get {
-                return ResourceManager.GetString("Extra_track_1_head_1_present_reading", resourceCulture);
+                return ResourceManager.GetString("ROM_MMM01_and_RAM", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra track 2 (head 0) present, reading.
-        /// </summary>
-        internal static string Extra_track_2_head_0_present_reading {
+        internal static string ROM_MMM01_RAM_and_battery {
             get {
-                return ResourceManager.GetString("Extra_track_2_head_0_present_reading", resourceCulture);
+                return ResourceManager.GetString("ROM_MMM01_RAM_and_battery", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Extra track 2 (head 1) present, reading.
-        /// </summary>
-        internal static string Extra_track_2_head_1_present_reading {
+        internal static string ROM_MBC3_timer_and_battery {
             get {
-                return ResourceManager.GetString("Extra_track_2_head_1_present_reading", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC3_timer_and_battery", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to File &quot;{0}&quot; found.
-        /// </summary>
-        internal static string File_0_found {
+        internal static string ROM_MBC3_RAM_timer_and_battery {
             get {
-                return ResourceManager.GetString("File_0_found", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC3_RAM_timer_and_battery", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to File &quot;{0}&quot; not found..
-        /// </summary>
-        internal static string File_0_not_found {
+        internal static string ROM_and_MBC3 {
             get {
-                return ResourceManager.GetString("File_0_not_found", resourceCulture);
+                return ResourceManager.GetString("ROM_and_MBC3", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to File parameters not found..
-        /// </summary>
-        internal static string File_parameters_not_found {
+        internal static string ROM_MBC3_and_RAM {
             get {
-                return ResourceManager.GetString("File_parameters_not_found", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC3_and_RAM", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Filling extents.
-        /// </summary>
-        internal static string Filling_extents {
+        internal static string ROM_MBC3_RAM_and_battery {
             get {
-                return ResourceManager.GetString("Filling_extents", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC3_RAM_and_battery", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Filling the BAT took {0} seconds.
-        /// </summary>
-        internal static string Filling_the_BAT_took_0_seconds {
+        internal static string ROM_and_MBC5 {
             get {
-                return ResourceManager.GetString("Filling_the_BAT_took_0_seconds", resourceCulture);
+                return ResourceManager.GetString("ROM_and_MBC5", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Finland.
-        /// </summary>
-        internal static string Finland {
+        internal static string ROM_MBC5_and_RAM {
             get {
-                return ResourceManager.GetString("Finland", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC5_and_RAM", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to FLAC is not supported.
-        /// </summary>
-        internal static string FLAC_is_not_supported {
+        internal static string ROM_MBC5_RAM_and_battery {
             get {
-                return ResourceManager.GetString("FLAC_is_not_supported", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC5_RAM_and_battery", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Flash size: {0} bytes.
-        /// </summary>
-        internal static string Flash_size_0_bytes {
+        internal static string ROM_MBC5_and_vibration_motor {
             get {
-                return ResourceManager.GetString("Flash_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC5_and_vibration_motor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Flux decoding is not yet implemented..
-        /// </summary>
-        internal static string Flux_decoding_is_not_yet_implemented {
+        internal static string ROM_MBC5_RAM_and_vibration_motor {
             get {
-                return ResourceManager.GetString("Flux_decoding_is_not_yet_implemented", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC5_RAM_and_vibration_motor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found {0} compact disc indexes at position {0}.
-        /// </summary>
-        internal static string Found_0_compact_disc_indexes_at_position_0 {
+        internal static string ROM_MBC5_RAM_battery_and_vibration_motor {
             get {
-                return ResourceManager.GetString("Found_0_compact_disc_indexes_at_position_0", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC5_RAM_battery_and_vibration_motor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found {0} cylinders and {1} heads with a maximum sector number of {2}.
-        /// </summary>
-        internal static string Found_0_cylinders_and_1_heads_with_a_maximum_sector_number_of_2 {
+        internal static string ROM_and_MBC6 {
             get {
-                return ResourceManager.GetString("Found_0_cylinders_and_1_heads_with_a_maximum_sector_number_of_2", resourceCulture);
+                return ResourceManager.GetString("ROM_and_MBC6", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found {0} tracks at position {0}.
-        /// </summary>
-        internal static string Found_0_tracks_at_position_0 {
+        internal static string ROM_MBC7_RAM_battery_light_sensor_and_vibration_motor {
             get {
-                return ResourceManager.GetString("Found_0_tracks_at_position_0", resourceCulture);
+                return ResourceManager.GetString("ROM_MBC7_RAM_battery_light_sensor_and_vibration_motor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found {1} at line {0}.
-        /// </summary>
-        internal static string Found_1_at_line_0 {
+        internal static string Pocket_Camera {
             get {
-                return ResourceManager.GetString("Found_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Pocket_Camera", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found {1}_CHANNEL_AUDIO at line {0}.
-        /// </summary>
-        internal static string Found_1_CHANNEL_AUDIO_at_line_0 {
+        internal static string ROM_and_TAMA5 {
             get {
-                return ResourceManager.GetString("Found_1_CHANNEL_AUDIO_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM_and_TAMA5", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found {1} COPY at line {0}.
-        /// </summary>
-        internal static string Found_1_COPY_at_line_0 {
+        internal static string ROM_and_HuC_3 {
             get {
-                return ResourceManager.GetString("Found_1_COPY_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM_and_HuC_3", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found {1} PRE_EMPHASIS at line {0}.
-        /// </summary>
-        internal static string Found_1_PRE_EMPHASIS_at_line_0 {
+        internal static string ROM_and_HuC_1 {
             get {
-                return ResourceManager.GetString("Found_1_PRE_EMPHASIS_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM_and_HuC_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found a minimum of {0} bytes per sector.
-        /// </summary>
-        internal static string Found_a_minimum_of_0_bytes_per_sector {
+        internal static string Unknown_cartridge_type {
             get {
-                return ResourceManager.GetString("Found_a_minimum_of_0_bytes_per_sector", resourceCulture);
+                return ResourceManager.GetString("Unknown_cartridge_type", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found a minimum of {0} sectors per track.
-        /// </summary>
-        internal static string Found_a_minimum_of_0_sectors_per_track {
+        internal static string GameBoyAdvance_Name {
             get {
-                return ResourceManager.GetString("Found_a_minimum_of_0_sectors_per_track", resourceCulture);
+                return ResourceManager.GetString("GameBoyAdvance_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found Aaru Metadata block at position {0}.
-        /// </summary>
-        internal static string Found_Aaru_Metadata_block_at_position_0 {
+        internal static string Device_type_0 {
             get {
-                return ResourceManager.GetString("Found_Aaru_Metadata_block_at_position_0", resourceCulture);
+                return ResourceManager.GetString("Device_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found ADR at line {0}.
-        /// </summary>
-        internal static string Found_ADR_at_line_0 {
+        internal static string Console_type_0 {
             get {
-                return ResourceManager.GetString("Found_ADR_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Console_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found AFrame at line {0}.
-        /// </summary>
-        internal static string Found_AFrame_at_line_0 {
+        internal static string Product_code_AGB_0 {
             get {
-                return ResourceManager.GetString("Found_AFrame_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Product_code_AGB_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found ALBA at line {0}.
-        /// </summary>
-        internal static string Found_ALBA_at_line_0 {
+        internal static string Maker_code_0 {
             get {
-                return ResourceManager.GetString("Found_ALBA_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Maker_code_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found AMin at line {0}.
-        /// </summary>
-        internal static string Found_AMin_at_line_0 {
+        internal static string MasterSystem_Name {
             get {
-                return ResourceManager.GetString("Found_AMin_at_line_0", resourceCulture);
+                return ResourceManager.GetString("MasterSystem_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found ARRANGER &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_ARRANGER_1_at_line_0 {
+        internal static string Product_code_0 {
             get {
-                return ResourceManager.GetString("Found_ARRANGER_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Product_code_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found ARRANGER at line {0}.
-        /// </summary>
-        internal static string Found_ARRANGER_at_line_0 {
+        internal static string Master_System {
             get {
-                return ResourceManager.GetString("Found_ARRANGER_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Master_System", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found ASec at line {0}.
-        /// </summary>
-        internal static string Found_ASec_at_line_0 {
+        internal static string Export {
             get {
-                return ResourceManager.GetString("Found_ASec_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Export", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found AUDIOFILE &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_AUDIOFILE_1_at_line_0 {
+        internal static string Game_Gear {
             get {
-                return ResourceManager.GetString("Found_AUDIOFILE_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Game_Gear", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found barcode field in incorrect place at line {0}.
-        /// </summary>
-        internal static string Found_barcode_field_in_incorrect_place_at_line_0 {
+        internal static string International {
             get {
-                return ResourceManager.GetString("Found_barcode_field_in_incorrect_place_at_line_0", resourceCulture);
+                return ResourceManager.GetString("International", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CATALOG &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_CATALOG_1_at_line_0 {
+        internal static string Unknown_region {
             get {
-                return ResourceManager.GetString("Found_CATALOG_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Unknown_region", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CATALOG at line {0}.
-        /// </summary>
-        internal static string Found_CATALOG_at_line_0 {
+        internal static string Nes_Name {
             get {
-                return ResourceManager.GetString("Found_CATALOG_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Nes_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found Catalog at line {0}.
-        /// </summary>
-        internal static string Found_Catalog_at_line_0_smallcase {
+        internal static string PRG_ROM_size_0_bytes {
             get {
-                return ResourceManager.GetString("Found_Catalog_at_line_0_smallcase", resourceCulture);
+                return ResourceManager.GetString("PRG_ROM_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CATALOG field in incorrect place at line {0}.
-        /// </summary>
-        internal static string Found_CATALOG_field_in_incorrect_place_at_line_0 {
+        internal static string CHR_ROM_size_0_bytes {
             get {
-                return ResourceManager.GetString("Found_CATALOG_field_in_incorrect_place_at_line_0", resourceCulture);
+                return ResourceManager.GetString("CHR_ROM_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CD-Text Entries at line {0}.
-        /// </summary>
-        internal static string Found_CD_Text_Entries_at_line_0 {
+        internal static string Trainer_size_0_bytes {
             get {
-                return ResourceManager.GetString("Found_CD_Text_Entries_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Trainer_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CD-Text Entry at line {0}.
-        /// </summary>
-        internal static string Found_CD_Text_Entry_at_line_0 {
+        internal static string Mapper_0 {
             get {
-                return ResourceManager.GetString("Found_CD_Text_Entry_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Mapper_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CD-Text file field in incorrect place at line {0}.
-        /// </summary>
-        internal static string Found_CD_Text_file_field_in_incorrect_place_at_line_0 {
+        internal static string Has_battery_backed_RAM {
             get {
-                return ResourceManager.GetString("Found_CD_Text_file_field_in_incorrect_place_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Has_battery_backed_RAM", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CDDB ID field in incorrect place at line {0}.
-        /// </summary>
-        internal static string Found_CDDB_ID_field_in_incorrect_place_at_line_0 {
+        internal static string Uses_four_screen_VRAM {
             get {
-                return ResourceManager.GetString("Found_CDDB_ID_field_in_incorrect_place_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Uses_four_screen_VRAM", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CDTEXTFILE at line {0}.
-        /// </summary>
-        internal static string Found_CDTEXTFILE_at_line_0 {
+        internal static string Uses_vertical_mirroring {
             get {
-                return ResourceManager.GetString("Found_CDTEXTFILE_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Uses_vertical_mirroring", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CDTextLength at line {0}.
-        /// </summary>
-        internal static string Found_CDTextLength_at_line_0 {
+        internal static string Uses_horizontal_mirroring {
             get {
-                return ResourceManager.GetString("Found_CDTextLength_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Uses_horizontal_mirroring", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;CDTX&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_CDTX_chunk_parsing_0_bytes {
+        internal static string VS_Unisystem_game {
             get {
-                return ResourceManager.GetString("Found_CDTX_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("VS_Unisystem_game", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CICM XML metadata block at position {0}.
-        /// </summary>
-        internal static string Found_CICM_XML_metadata_block_at_position_0 {
+        internal static string PlayChoice_10_game {
             get {
-                return ResourceManager.GetString("Found_CICM_XML_metadata_block_at_position_0", resourceCulture);
+                return ResourceManager.GetString("PlayChoice_10_game", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found [CloneCD] out of order in line {0}.
-        /// </summary>
-        internal static string Found_CloneCD_out_of_order_in_line_0 {
+        internal static string INST_ROM_size_0_bytes {
             get {
-                return ResourceManager.GetString("Found_CloneCD_out_of_order_in_line_0", resourceCulture);
+                return ResourceManager.GetString("INST_ROM_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found comment &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_comment_1_at_line_0 {
+        internal static string PROM_size_0_bytes {
             get {
-                return ResourceManager.GetString("Found_comment_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("PROM_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found comment record at {0}.
-        /// </summary>
-        internal static string Found_comment_record_at_0 {
+        internal static string VR_Technology_VT01 {
             get {
-                return ResourceManager.GetString("Found_comment_record_at_0", resourceCulture);
+                return ResourceManager.GetString("VR_Technology_VT01", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found COMPOSER &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_COMPOSER_1_at_line_0 {
+        internal static string VR_Technology_VT02 {
             get {
-                return ResourceManager.GetString("Found_COMPOSER_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("VR_Technology_VT02", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found COMPOSER at line {0}.
-        /// </summary>
-        internal static string Found_COMPOSER_at_line_0 {
+        internal static string VR_Technology_VT03 {
             get {
-                return ResourceManager.GetString("Found_COMPOSER_at_line_0", resourceCulture);
+                return ResourceManager.GetString("VR_Technology_VT03", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found compressed sector record at {0} for cylinder {1} head {2} sector {3}.
-        /// </summary>
-        internal static string Found_compressed_sector_record_at_0_for_cylinder_1_head_2_sector_3 {
+        internal static string VR_Technology_VT09 {
             get {
-                return ResourceManager.GetString("Found_compressed_sector_record_at_0_for_cylinder_1_head_2_sector_3", resourceCulture);
+                return ResourceManager.GetString("VR_Technology_VT09", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found Control at line {0}.
-        /// </summary>
-        internal static string Found_Control_at_line_0 {
+        internal static string VR_Technology_VT32 {
             get {
-                return ResourceManager.GetString("Found_Control_at_line_0", resourceCulture);
+                return ResourceManager.GetString("VR_Technology_VT32", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found CRC32 for {1} {2} at line {0}.
-        /// </summary>
-        internal static string Found_CRC32_for_1_2_at_line_0 {
+        internal static string VR_Technology_VT369 {
             get {
-                return ResourceManager.GetString("Found_CRC32_for_1_2_at_line_0", resourceCulture);
+                return ResourceManager.GetString("VR_Technology_VT369", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found creator record at {0}.
-        /// </summary>
-        internal static string Found_creator_record_at_0 {
+        internal static string Nintendo64_Name {
             get {
-                return ResourceManager.GetString("Found_creator_record_at_0", resourceCulture);
+                return ResourceManager.GetString("Nintendo64_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;CUES&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_CUES_chunk_parsing_0_bytes {
+        internal static string Cartridge_ID_0 {
             get {
-                return ResourceManager.GetString("Found_CUES_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Cartridge_ID_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;CUEX&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_CUEX_chunk_parsing_0_bytes {
+        internal static string Version_0_1 {
             get {
-                return ResourceManager.GetString("Found_CUEX_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Version_0_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;DAOI&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_DAOI_chunk_parsing_0_bytes {
+        internal static string CRC1_0 {
             get {
-                return ResourceManager.GetString("Found_DAOI_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("CRC1_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;DAOX&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_DAOX_chunk_parsing_0_bytes {
+        internal static string CRC2_0 {
             get {
-                return ResourceManager.GetString("Found_DAOX_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("CRC2_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found data block type {0} at position {1}.
-        /// </summary>
-        internal static string Found_data_block_type_0_at_position_1 {
+        internal static string Beta {
             get {
-                return ResourceManager.GetString("Found_data_block_type_0_at_position_1", resourceCulture);
+                return ResourceManager.GetString("Beta", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found DATAFILE &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_DATAFILE_1_at_line_0 {
+        internal static string Asia_NTSC {
             get {
-                return ResourceManager.GetString("Found_DATAFILE_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Asia_NTSC", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found DataTracksScrambled at line {0}.
-        /// </summary>
-        internal static string Found_DataTracksScrambled_at_line_0 {
+        internal static string Brazil {
             get {
-                return ResourceManager.GetString("Found_DataTracksScrambled_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Brazil", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found deleted record at {0}.
-        /// </summary>
-        internal static string Found_deleted_record_at_0 {
+        internal static string China {
             get {
-                return ResourceManager.GetString("Found_deleted_record_at_0", resourceCulture);
+                return ResourceManager.GetString("China", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;DINF&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_DINF_chunk_parsing_0_bytes {
+        internal static string Germany {
             get {
-                return ResourceManager.GetString("Found_DINF_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Germany", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found DISC_ID &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_DISC_ID_1_at_line_0 {
+        internal static string North_America {
             get {
-                return ResourceManager.GetString("Found_DISC_ID_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("North_America", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found DISC_ID at line {0}.
-        /// </summary>
-        internal static string Found_DISC_ID_at_line_0 {
+        internal static string France {
             get {
-                return ResourceManager.GetString("Found_DISC_ID_at_line_0", resourceCulture);
+                return ResourceManager.GetString("France", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found dump hardware block at position {0}.
-        /// </summary>
-        internal static string Found_dump_hardware_block_at_position_0 {
+        internal static string Gateway_64_NTSC {
             get {
-                return ResourceManager.GetString("Found_dump_hardware_block_at_position_0", resourceCulture);
+                return ResourceManager.GetString("Gateway_64_NTSC", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;END!&quot; chunk, finishing parse.
-        /// </summary>
-        internal static string Found_END_chunk_finishing_parse {
+        internal static string Netherlands {
             get {
-                return ResourceManager.GetString("Found_END_chunk_finishing_parse", resourceCulture);
+                return ResourceManager.GetString("Netherlands", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;ETN2&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_ETN2_chunk_parsing_0_bytes {
+        internal static string Italy {
             get {
-                return ResourceManager.GetString("Found_ETN2_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Italy", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;ETNF&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_ETNF_chunk_parsing_0_bytes {
+        internal static string Korea {
             get {
-                return ResourceManager.GetString("Found_ETNF_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Korea", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found FILE at line {0}.
-        /// </summary>
-        internal static string Found_FILE_at_line_0 {
+        internal static string Gateway_64_PAL {
             get {
-                return ResourceManager.GetString("Found_FILE_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Gateway_64_PAL", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found FLAGS at line {0}.
-        /// </summary>
-        internal static string Found_FLAGS_at_line_0 {
+        internal static string Canada {
             get {
-                return ResourceManager.GetString("Found_FLAGS_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Canada", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found FLAGS field in incorrect place at line {0}.
-        /// </summary>
-        internal static string Found_FLAGS_field_in_incorrect_place_at_line_0 {
+        internal static string Europe {
             get {
-                return ResourceManager.GetString("Found_FLAGS_field_in_incorrect_place_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Europe", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found footer at {0}.
-        /// </summary>
-        internal static string Found_footer_at_0 {
+        internal static string Spain {
             get {
-                return ResourceManager.GetString("Found_footer_at_0", resourceCulture);
+                return ResourceManager.GetString("Spain", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found GENRE at line {0}.
-        /// </summary>
-        internal static string Found_GENRE_at_line_0 {
+        internal static string Australia {
             get {
-                return ResourceManager.GetString("Found_GENRE_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Australia", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found INDEX {0} before INDEX 00 or INDEX 01.
-        /// </summary>
-        internal static string Found_INDEX_0_before_INDEX_00_or_INDEX_01 {
+        internal static string Scandinavia {
             get {
-                return ResourceManager.GetString("Found_INDEX_0_before_INDEX_00_or_INDEX_01", resourceCulture);
+                return ResourceManager.GetString("Scandinavia", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found INDEX &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_INDEX_1_at_line_0 {
+        internal static string Unknown_country {
             get {
-                return ResourceManager.GetString("Found_INDEX_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Unknown_country", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found INDEX at line {0}.
-        /// </summary>
-        internal static string Found_INDEX_at_line_0 {
+        internal static string SegaMegaDrive_Name {
             get {
-                return ResourceManager.GetString("Found_INDEX_at_line_0", resourceCulture);
+                return ResourceManager.GetString("SegaMegaDrive_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found INDEX before a track {0}.
-        /// </summary>
-        internal static string Found_INDEX_before_a_track_0 {
+        internal static string System_type_0 {
             get {
-                return ResourceManager.GetString("Found_INDEX_before_a_track_0", resourceCulture);
+                return ResourceManager.GetString("System_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found ISRC &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_ISRC_1_at_line_0 {
+        internal static string Copyright_string_0 {
             get {
-                return ResourceManager.GetString("Found_ISRC_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Copyright_string_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found ISRC at line {0}.
-        /// </summary>
-        internal static string Found_ISRC_at_line_0 {
+        internal static string Domestic_title_0 {
             get {
-                return ResourceManager.GetString("Found_ISRC_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Domestic_title_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found ISRC before a track {0}.
-        /// </summary>
-        internal static string Found_ISRC_before_a_track_0 {
+        internal static string Overseas_title_0 {
             get {
-                return ResourceManager.GetString("Found_ISRC_before_a_track_0", resourceCulture);
+                return ResourceManager.GetString("Overseas_title_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found MD5 for {1} {2} at line {0}.
-        /// </summary>
-        internal static string Found_MD5_for_1_2_at_line_0 {
+        internal static string Serial_number_0 {
             get {
-                return ResourceManager.GetString("Found_MD5_for_1_2_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Serial_number_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found media tag {0}.
-        /// </summary>
-        internal static string Found_media_tag_0 {
+        internal static string Devices_supported_0 {
             get {
-                return ResourceManager.GetString("Found_media_tag_0", resourceCulture);
+                return ResourceManager.GetString("Devices_supported_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found MESSAGE &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_MESSAGE_1_at_line_0 {
+        internal static string ROM_starts_at_0_and_ends_at_1_2_bytes {
             get {
-                return ResourceManager.GetString("Found_MESSAGE_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM_starts_at_0_and_ends_at_1_2_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found metadata &quot;{0}&quot;.
-        /// </summary>
-        internal static string Found_metadata_0_ {
+        internal static string RAM_starts_at_0_and_ends_at_1_2_bytes {
             get {
-                return ResourceManager.GetString("Found_metadata_0_", resourceCulture);
+                return ResourceManager.GetString("RAM_starts_at_0_and_ends_at_1_2_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found metadata block at position {0}.
-        /// </summary>
-        internal static string Found_metadata_block_at_position_0 {
+        internal static string Extra_RAM_present {
             get {
-                return ResourceManager.GetString("Found_metadata_block_at_position_0", resourceCulture);
+                return ResourceManager.GetString("Extra_RAM_present", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;MTYP&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_MTYP_chunk_parsing_0_bytes {
+        internal static string Extra_RAM_uses_16_bit_access {
             get {
-                return ResourceManager.GetString("Found_MTYP_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Extra_RAM_uses_16_bit_access", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found obsolete UDIF format..
-        /// </summary>
-        internal static string Found_obsolete_UDIF_format {
+        internal static string Extra_RAM_uses_8_bit_access_even_addresses {
             get {
-                return ResourceManager.GetString("Found_obsolete_UDIF_format", resourceCulture);
+                return ResourceManager.GetString("Extra_RAM_uses_8_bit_access_even_addresses", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PERFORMER &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_PERFORMER_1_at_line_0 {
+        internal static string Extra_RAM_uses_8_bit_access_odd_addresses {
             get {
-                return ResourceManager.GetString("Found_PERFORMER_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Extra_RAM_uses_8_bit_access_odd_addresses", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PERFORMER at line {0}.
-        /// </summary>
-        internal static string Found_PERFORMER_at_line_0 {
+        internal static string Extra_RAM_uses_16_bit_access_and_persists_when_powered_off {
             get {
-                return ResourceManager.GetString("Found_PERFORMER_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Extra_RAM_uses_16_bit_access_and_persists_when_powered_off", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PFrame at line {0}.
-        /// </summary>
-        internal static string Found_PFrame_at_line_0 {
+        internal static string Extra_RAM_uses_8_bit_access_even_addresses_and_persists_when_powered_off {
             get {
-                return ResourceManager.GetString("Found_PFrame_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Extra_RAM_uses_8_bit_access_even_addresses_and_persists_when_powered_off", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PLBA at line {0}.
-        /// </summary>
-        internal static string Found_PLBA_at_line_0 {
+        internal static string Extra_RAM_uses_8_bit_access_odd_addresses_and_persists_when_powered_off {
             get {
-                return ResourceManager.GetString("Found_PLBA_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Extra_RAM_uses_8_bit_access_odd_addresses_and_persists_when_powered_off", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PMin at line {0}.
-        /// </summary>
-        internal static string Found_PMin_at_line_0 {
+        internal static string Extra_RAM_is_of_unknown_type_0 {
             get {
-                return ResourceManager.GetString("Found_PMin_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Extra_RAM_is_of_unknown_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found Point at line {0}.
-        /// </summary>
-        internal static string Found_Point_at_line_0 {
+        internal static string Extra_RAM_starts_at_0_and_ends_at_1_2_bytes {
             get {
-                return ResourceManager.GetString("Found_Point_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Extra_RAM_starts_at_0_and_ends_at_1_2_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found POSTGAP at line {0}.
-        /// </summary>
-        internal static string Found_POSTGAP_at_line_0 {
+        internal static string Extra_RAM_not_present {
             get {
-                return ResourceManager.GetString("Found_POSTGAP_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Extra_RAM_not_present", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found POSTGAP field before a track at line {0}.
-        /// </summary>
-        internal static string Found_POSTGAP_field_before_a_track_at_line_0 {
+        internal static string Modem_support_0 {
             get {
-                return ResourceManager.GetString("Found_POSTGAP_field_before_a_track_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Modem_support_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PREGAP &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_PREGAP_1_at_line_0 {
+        internal static string Region_support_0 {
             get {
-                return ResourceManager.GetString("Found_PREGAP_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Region_support_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PREGAP at line {0}.
-        /// </summary>
-        internal static string Found_PREGAP_at_line_0 {
+        internal static string SuperNintendo_Name {
             get {
-                return ResourceManager.GetString("Found_PREGAP_at_line_0", resourceCulture);
+                return ResourceManager.GetString("SuperNintendo_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PREGAP field before a track at line {0}.
-        /// </summary>
-        internal static string Found_PREGAP_field_before_a_track_at_line_0 {
+        internal static string Game_code_0 {
             get {
-                return ResourceManager.GetString("Found_PREGAP_field_before_a_track_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Game_code_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PreGapMode at line {0}.
-        /// </summary>
-        internal static string Found_PreGapMode_at_line_0 {
+        internal static string Special_revision_0 {
             get {
-                return ResourceManager.GetString("Found_PreGapMode_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Special_revision_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PreGapSubC at line {0}.
-        /// </summary>
-        internal static string Found_PreGapSubC_at_line_0 {
+        internal static string Header_checksum_0_X4 {
             get {
-                return ResourceManager.GetString("Found_PreGapSubC_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Header_checksum_0_X4", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found PSec at line {0}.
-        /// </summary>
-        internal static string Found_PSec_at_line_0 {
+        internal static string Header_checksum_complement_0 {
             get {
-                return ResourceManager.GetString("Found_PSec_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Header_checksum_complement_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;RELO&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_RELO_chunk_parsing_0_bytes {
+        internal static string RAM_size_0_bytes {
             get {
-                return ResourceManager.GetString("Found_RELO_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("RAM_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM at line {0}.
-        /// </summary>
-        internal static string Found_REM_at_line_0 {
+        internal static string Flash_size_0_bytes {
             get {
-                return ResourceManager.GetString("Found_REM_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Flash_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM CRC32 at line {0}.
-        /// </summary>
-        internal static string Found_REM_CRC32_at_line_0 {
+        internal static string Expansion_RAM_size_0_bytes {
             get {
-                return ResourceManager.GetString("Found_REM_CRC32_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Expansion_RAM_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM DISC HASHES at line {0}.
-        /// </summary>
-        internal static string Found_REM_DISC_HASHES_at_line_0 {
+        internal static string ROM_speed_0 {
             get {
-                return ResourceManager.GetString("Found_REM_DISC_HASHES_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM_speed_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM Gap Append Method: {1} [{2}] HASHES at line {0}.
-        /// </summary>
-        internal static string Found_REM_Gap_Append_Method_1_2_HASHES_at_line_0 {
+        internal static string Bank_size_0_bytes {
             get {
-                return ResourceManager.GetString("Found_REM_Gap_Append_Method_1_2_HASHES_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Bank_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM HIGH-DENSITY AREA at line {0}.
-        /// </summary>
-        internal static string Found_REM_HIGH_DENSITY_AREA_at_line_0 {
+        internal static string Cartridge_chip_set_0 {
             get {
-                return ResourceManager.GetString("Found_REM_HIGH_DENSITY_AREA_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Cartridge_chip_set_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM LEAD-OUT at line {0}.
-        /// </summary>
-        internal static string Found_REM_LEAD_OUT_at_line_0 {
+        internal static string Coprocessor_0 {
             get {
-                return ResourceManager.GetString("Found_REM_LEAD_OUT_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Coprocessor_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM MD5 at line {0}.
-        /// </summary>
-        internal static string Found_REM_MD5_at_line_0 {
+        internal static string None_coprocessor {
             get {
-                return ResourceManager.GetString("Found_REM_MD5_at_line_0", resourceCulture);
+                return ResourceManager.GetString("None_coprocessor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM METADATA AARU MEDIA-TYPE at line {0}.
-        /// </summary>
-        internal static string Found_REM_METADATA_AARU_MEDIA_TYPE_at_line_0 {
+        internal static string Unknown_coprocessor {
             get {
-                return ResourceManager.GetString("Found_REM_METADATA_AARU_MEDIA_TYPE_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Unknown_coprocessor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM METADATA DIC MEDIA-TYPE at line {0}.
-        /// </summary>
-        internal static string Found_REM_METADATA_DIC_MEDIA_TYPE_at_line_0 {
+        internal static string Other_coprocessor {
             get {
-                return ResourceManager.GetString("Found_REM_METADATA_DIC_MEDIA_TYPE_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Other_coprocessor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM METADATA DUMP EXTENT at line {0}.
-        /// </summary>
-        internal static string Found_REM_METADATA_DUMP_EXTENT_at_line_0 {
+        internal static string ROM {
             get {
-                return ResourceManager.GetString("Found_REM_METADATA_DUMP_EXTENT_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM MSF at line {0}.
-        /// </summary>
-        internal static string Found_REM_MSF_at_line_0 {
+        internal static string ROM_and_coprocessor {
             get {
-                return ResourceManager.GetString("Found_REM_MSF_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM_and_coprocessor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM ORIGINAL MEDIA TYPE at line {0}.
-        /// </summary>
-        internal static string Found_REM_ORIGINAL_MEDIA_TYPE_at_line_0 {
+        internal static string ROM_RAM_and_coprocessor {
             get {
-                return ResourceManager.GetString("Found_REM_ORIGINAL_MEDIA_TYPE_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM_RAM_and_coprocessor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM Ripping Tool at line {0}.
-        /// </summary>
-        internal static string Found_REM_Ripping_Tool_at_line_0 {
+        internal static string ROM_RAM_battery_and_coprocessor {
             get {
-                return ResourceManager.GetString("Found_REM_Ripping_Tool_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM_RAM_battery_and_coprocessor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM Ripping Tool Version at line {0}.
-        /// </summary>
-        internal static string Found_REM_Ripping_Tool_Version_at_line_0 {
+        internal static string ROM_battery_and_coprocessor {
             get {
-                return ResourceManager.GetString("Found_REM_Ripping_Tool_Version_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM_battery_and_coprocessor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM SESSION at line {0}.
-        /// </summary>
-        internal static string Found_REM_SESSION_at_line_0 {
+        internal static string ROM_RAM_battery_coprocessor_and_RTC {
             get {
-                return ResourceManager.GetString("Found_REM_SESSION_at_line_0", resourceCulture);
+                return ResourceManager.GetString("ROM_RAM_battery_coprocessor_and_RTC", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM SHA1 at line {0}.
-        /// </summary>
-        internal static string Found_REM_SHA1_at_line_0 {
+        internal static string Unknown_chipset {
             get {
-                return ResourceManager.GetString("Found_REM_SHA1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Unknown_chipset", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found REM SINGLE-DENSITY AREA at line {0}.
-        /// </summary>
-        internal static string Found_REM_SINGLE_DENSITY_AREA_at_line_0 {
+        internal static string USA_and_Canada {
             get {
-                return ResourceManager.GetString("Found_REM_SINGLE_DENSITY_AREA_at_line_0", resourceCulture);
+                return ResourceManager.GetString("USA_and_Canada", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found Session at line {0}.
-        /// </summary>
-        internal static string Found_Session_at_line_0 {
+        internal static string Europe_Oceania_Asia {
             get {
-                return ResourceManager.GetString("Found_Session_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Europe_Oceania_Asia", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found Sessions at line {0}.
-        /// </summary>
-        internal static string Found_Sessions_at_line_0 {
+        internal static string Sweden_Scandinavia {
             get {
-                return ResourceManager.GetString("Found_Sessions_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Sweden_Scandinavia", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found SHA1 for {1} {2} at line {0}.
-        /// </summary>
-        internal static string Found_SHA1_for_1_2_at_line_0 {
+        internal static string Finland {
             get {
-                return ResourceManager.GetString("Found_SHA1_for_1_2_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Finland", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found SILENCE &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_SILENCE_1_at_line_0 {
+        internal static string Denmark {
             get {
-                return ResourceManager.GetString("Found_SILENCE_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Denmark", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;SINF&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_SINF_chunk_parsing_0_bytes {
+        internal static string Germany_Austria_Switzerland {
             get {
-                return ResourceManager.GetString("Found_SINF_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Germany_Austria_Switzerland", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found SONGWRITER &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_SONGWRITER_1_at_line_0 {
+        internal static string China_Hong_Kong {
             get {
-                return ResourceManager.GetString("Found_SONGWRITER_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("China_Hong_Kong", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found SONGWRITER at line {0}.
-        /// </summary>
-        internal static string Found_SONGWRITER_at_line_0 {
+        internal static string Indonesia {
             get {
-                return ResourceManager.GetString("Found_SONGWRITER_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Indonesia", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found START &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_START_1_at_line_0 {
+        internal static string South_Korea {
             get {
-                return ResourceManager.GetString("Found_START_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("South_Korea", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found tape file block at position {0}.
-        /// </summary>
-        internal static string Found_tape_file_block_at_position_0 {
+        internal static string Unknown_manufacturer {
             get {
-                return ResourceManager.GetString("Found_tape_file_block_at_position_0", resourceCulture);
+                return ResourceManager.GetString("Unknown_manufacturer", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found tape partition block at position {0}.
-        /// </summary>
-        internal static string Found_tape_partition_block_at_position_0 {
+        internal static string Cdrdao_Name {
             get {
-                return ResourceManager.GetString("Found_tape_partition_block_at_position_0", resourceCulture);
+                return ResourceManager.GetString("Cdrdao_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found timestamp: {0}.
-        /// </summary>
-        internal static string Found_timestamp_0 {
+        internal static string Exception_trying_to_identify_image_file_0 {
             get {
-                return ResourceManager.GetString("Found_timestamp_0", resourceCulture);
+                return ResourceManager.GetString("Exception_trying_to_identify_image_file_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;TINF&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_TINF_chunk_parsing_0_bytes {
+        internal static string Exception_0 {
             get {
-                return ResourceManager.GetString("Found_TINF_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Exception_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found TITLE &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_TITLE_1_at_line_0 {
+        internal static string Stack_trace_0 {
             get {
-                return ResourceManager.GetString("Found_TITLE_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Stack_trace_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found TITLE at line {0}.
-        /// </summary>
-        internal static string Found_TITLE_at_line_0 {
+        internal static string Not_a_CDRDAO_TOC_or_TOC_type_not_in_line_0 {
             get {
-                return ResourceManager.GetString("Found_TITLE_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Not_a_CDRDAO_TOC_or_TOC_type_not_in_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found TocEntries at line {0}.
-        /// </summary>
-        internal static string Found_TocEntries_at_line_0 {
+        internal static string Found_comment_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_TocEntries_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Found_comment_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found &quot;TOCT&quot; chunk, parsing {0} bytes.
-        /// </summary>
-        internal static string Found_TOCT_chunk_parsing_0_bytes {
+        internal static string Found_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_TOCT_chunk_parsing_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Found_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found track {0} at {1}..
-        /// </summary>
-        internal static string Found_track_0_at_1 {
+        internal static string Found_CATALOG_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_track_0_at_1", resourceCulture);
+                return ResourceManager.GetString("Found_CATALOG_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found TRACK {0} out of order in line {1}.
-        /// </summary>
-        internal static string Found_TRACK_0_out_of_order_in_line_1 {
+        internal static string Found_TRACK_type_1_with_no_subchannel_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_TRACK_0_out_of_order_in_line_1", resourceCulture);
+                return ResourceManager.GetString("Found_TRACK_type_1_with_no_subchannel_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found track {0} starts at {1} flags {2} type {3} file {4} offset {5} at line {6}.
-        /// </summary>
-        internal static string Found_track_0_starts_at_1_flags_2_type_3_file_4_offset_5_at_line_6 {
+        internal static string Found_TRACK_type_1_subchannel_2_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_track_0_starts_at_1_flags_2_type_3_file_4_offset_5_at_line_6", resourceCulture);
+                return ResourceManager.GetString("Found_TRACK_type_1_subchannel_2_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found TRACK at line {0}.
-        /// </summary>
-        internal static string Found_TRACK_at_line_0 {
+        internal static string Track_mode_0_is_unsupported {
             get {
-                return ResourceManager.GetString("Found_TRACK_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Track_mode_0_is_unsupported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found TRACK field before a file is defined at line {0}.
-        /// </summary>
-        internal static string Found_TRACK_field_before_a_file_is_defined_at_line_0 {
+        internal static string Track_subchannel_mode_0_is_unsupported {
             get {
-                return ResourceManager.GetString("Found_TRACK_field_before_a_file_is_defined_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Track_subchannel_mode_0_is_unsupported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found TRACK type &quot;{1}&quot; subchannel {2} at line {0}.
-        /// </summary>
-        internal static string Found_TRACK_type_1_subchannel_2_at_line_0 {
+        internal static string Found_1_COPY_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_TRACK_type_1_subchannel_2_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Found_1_COPY_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found TRACK type &quot;{1}&quot; with no subchannel at line {0}.
-        /// </summary>
-        internal static string Found_TRACK_type_1_with_no_subchannel_at_line_0 {
+        internal static string Found_1_PRE_EMPHASIS_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_TRACK_type_1_with_no_subchannel_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Found_1_PRE_EMPHASIS_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found TrackNo at line {0}.
-        /// </summary>
-        internal static string Found_TrackNo_at_line_0 {
+        internal static string Found_1_CHANNEL_AUDIO_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_TrackNo_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Found_1_CHANNEL_AUDIO_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found uncompressed sector record at {0} for cylinder {1} head {2} sector {3}.
-        /// </summary>
-        internal static string Found_uncompressed_sector_record_at_0_for_cylinder_1_head_2_sector_3 {
+        internal static string Found_ISRC_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_uncompressed_sector_record_at_0_for_cylinder_1_head_2_sector_3", resourceCulture);
+                return ResourceManager.GetString("Found_ISRC_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found unhandled header, cannot open..
-        /// </summary>
-        internal static string Found_unhandled_header_cannot_open {
+        internal static string Found_INDEX_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_unhandled_header_cannot_open", resourceCulture);
+                return ResourceManager.GetString("Found_INDEX_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found unknown compression type {0}, continuing....
-        /// </summary>
-        internal static string Found_unknown_compression_type_0_continuing {
+        internal static string Found_START_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_unknown_compression_type_0_continuing", resourceCulture);
+                return ResourceManager.GetString("Found_START_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found unknown field defined at line {0}: &quot;{1}&quot;.
-        /// </summary>
-        internal static string Found_unknown_field_defined_at_line_0_1 {
+        internal static string Found_PREGAP_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_unknown_field_defined_at_line_0_1", resourceCulture);
+                return ResourceManager.GetString("Found_PREGAP_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found unknown hash for {1} {2} at line {0}. Please report this disc image..
-        /// </summary>
-        internal static string Found_unknown_hash_for_1_2_at_line_0_Please_report_this_disc_image {
+        internal static string Found_ZERO_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_unknown_hash_for_1_2_at_line_0_Please_report_this_disc_image", resourceCulture);
+                return ResourceManager.GetString("Found_ZERO_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found unsupported and required metadata Guid {0}, not proceeding with image..
-        /// </summary>
-        internal static string Found_unsupported_and_required_metadata_Guid_0_not_proceeding_with_image {
+        internal static string Found_SILENCE_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_unsupported_and_required_metadata_Guid_0_not_proceeding_with_image", resourceCulture);
+                return ResourceManager.GetString("Found_SILENCE_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found unsupported and required parent locator type {0}, not proceeding with image..
-        /// </summary>
-        internal static string Found_unsupported_and_required_parent_locator_type_0_not_proceeding_with_image {
+        internal static string Found_AUDIOFILE_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_unsupported_and_required_parent_locator_type_0_not_proceeding_with_image", resourceCulture);
+                return ResourceManager.GetString("Found_AUDIOFILE_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found unsupported and required region Guid {0}, not proceeding with image..
-        /// </summary>
-        internal static string Found_unsupported_and_required_region_Guid_0_not_proceeding_with_image {
+        internal static string Found_DATAFILE_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_unsupported_and_required_region_Guid_0_not_proceeding_with_image", resourceCulture);
+                return ResourceManager.GetString("Found_DATAFILE_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found unsupported compression algorithm {0}.
-        /// </summary>
-        internal static string Found_unsupported_compression_algorithm_0 {
+        internal static string Found_TITLE_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_unsupported_compression_algorithm_0", resourceCulture);
+                return ResourceManager.GetString("Found_TITLE_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found unsupported hash {0}.
-        /// </summary>
-        internal static string Found_unsupported_hash_0 {
+        internal static string Found_PERFORMER_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_unsupported_hash_0", resourceCulture);
+                return ResourceManager.GetString("Found_PERFORMER_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found UPC_EAN &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_UPC_EAN_1_at_line_0 {
+        internal static string Found_SONGWRITER_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_UPC_EAN_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Found_SONGWRITER_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found UPC_EAN at line {0}.
-        /// </summary>
-        internal static string Found_UPC_EAN_at_line_0 {
+        internal static string Found_COMPOSER_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_UPC_EAN_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Found_COMPOSER_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found Version at line {0}.
-        /// </summary>
-        internal static string Found_Version_at_line_0 {
+        internal static string Found_ARRANGER_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_Version_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Found_ARRANGER_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found ZERO &quot;{1}&quot; at line {0}.
-        /// </summary>
-        internal static string Found_ZERO_1_at_line_0 {
+        internal static string Found_MESSAGE_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_ZERO_1_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Found_MESSAGE_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Found Zero at line {0}.
-        /// </summary>
-        internal static string Found_Zero_at_line_0 {
+        internal static string Found_DISC_ID_1_at_line_0 {
             get {
-                return ResourceManager.GetString("Found_Zero_at_line_0", resourceCulture);
+                return ResourceManager.GetString("Found_DISC_ID_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to France.
-        /// </summary>
-        internal static string France {
+        internal static string Found_UPC_EAN_1_at_line_0 {
             get {
-                return ResourceManager.GetString("France", resourceCulture);
+                return ResourceManager.GetString("Found_UPC_EAN_1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Game code: {0}.
-        /// </summary>
-        internal static string Game_code_0 {
+        internal static string Disc_image_parsing_results {
             get {
-                return ResourceManager.GetString("Game_code_0", resourceCulture);
+                return ResourceManager.GetString("Disc_image_parsing_results", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Game Gear.
-        /// </summary>
-        internal static string Game_Gear {
+        internal static string Disc_CD_TEXT {
             get {
-                return ResourceManager.GetString("Game_Gear", resourceCulture);
+                return ResourceManager.GetString("Disc_CD_TEXT", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Nintendo Game Boy.
-        /// </summary>
-        internal static string GameBoy_Name {
+        internal static string Arranger_is_not_set {
             get {
-                return ResourceManager.GetString("GameBoy_Name", resourceCulture);
+                return ResourceManager.GetString("Arranger_is_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Nintendo Game Boy Advance.
-        /// </summary>
-        internal static string GameBoyAdvance_Name {
+        internal static string Arranger_0 {
             get {
-                return ResourceManager.GetString("GameBoyAdvance_Name", resourceCulture);
+                return ResourceManager.GetString("Arranger_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to gap.
-        /// </summary>
-        internal static string gap {
+        internal static string Composer_is_not_set {
             get {
-                return ResourceManager.GetString("gap", resourceCulture);
+                return ResourceManager.GetString("Composer_is_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Gateway 64 (NTSC).
-        /// </summary>
-        internal static string Gateway_64_NTSC {
+        internal static string Composer_0 {
             get {
-                return ResourceManager.GetString("Gateway_64_NTSC", resourceCulture);
+                return ResourceManager.GetString("Composer_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Gateway 64 (PAL).
-        /// </summary>
-        internal static string Gateway_64_PAL {
+        internal static string Performer_is_not_set {
             get {
-                return ResourceManager.GetString("Gateway_64_PAL", resourceCulture);
+                return ResourceManager.GetString("Performer_is_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to &apos;&apos;&apos;GBC - see above&apos;&apos;&apos;.
-        /// </summary>
-        internal static string GBC_see_above {
+        internal static string Performer_0 {
             get {
-                return ResourceManager.GetString("GBC_see_above", resourceCulture);
+                return ResourceManager.GetString("Performer_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to GDI image describes a disc of type {0}.
-        /// </summary>
-        internal static string GDI_image_describes_a_disc_of_type_0 {
+        internal static string Songwriter_is_not_set {
             get {
-                return ResourceManager.GetString("GDI_image_describes_a_disc_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Songwriter_is_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Dreamcast GDI image.
-        /// </summary>
-        internal static string Gdi_Name {
+        internal static string Songwriter_0 {
             get {
-                return ResourceManager.GetString("Gdi_Name", resourceCulture);
+                return ResourceManager.GetString("Songwriter_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Genre: {0}.
-        /// </summary>
-        internal static string Genre_0 {
+        internal static string Title_is_not_set {
             get {
-                return ResourceManager.GetString("Genre_0", resourceCulture);
+                return ResourceManager.GetString("Title_is_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Genre is not set..
-        /// </summary>
-        internal static string Genre_is_not_set {
+        internal static string Title_0 {
             get {
-                return ResourceManager.GetString("Genre_is_not_set", resourceCulture);
+                return ResourceManager.GetString("Title_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Geometry set to {0} cylinders {1} heads {2} sectors per track.
-        /// </summary>
-        internal static string Geometry_set_to_0_cylinders_1_heads_2_sectors_per_track {
+        internal static string Disc_information {
             get {
-                return ResourceManager.GetString("Geometry_set_to_0_cylinders_1_heads_2_sectors_per_track", resourceCulture);
+                return ResourceManager.GetString("Disc_information", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Germany.
-        /// </summary>
-        internal static string Germany {
+        internal static string Guessed_disk_type_0 {
             get {
-                return ResourceManager.GetString("Germany", resourceCulture);
+                return ResourceManager.GetString("Guessed_disk_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Germany, Austria, Switzerland.
-        /// </summary>
-        internal static string Germany_Austria_Switzerland {
+        internal static string Barcode_not_set {
             get {
-                return ResourceManager.GetString("Germany_Austria_Switzerland", resourceCulture);
+                return ResourceManager.GetString("Barcode_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Got {0} sectors.
-        /// </summary>
-        internal static string Got_0_sectors {
+        internal static string Barcode_0 {
             get {
-                return ResourceManager.GetString("Got_0_sectors", resourceCulture);
+                return ResourceManager.GetString("Barcode_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Got {0} tracks.
-        /// </summary>
-        internal static string Got_0_tracks {
+        internal static string Disc_ID_not_set {
             get {
-                return ResourceManager.GetString("Got_0_tracks", resourceCulture);
+                return ResourceManager.GetString("Disc_ID_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Got a shift of {0} for {1} sectors per block.
-        /// </summary>
-        internal static string Got_a_shift_of_0_for_1_sectors_per_block {
+        internal static string Disc_ID_0 {
             get {
-                return ResourceManager.GetString("Got_a_shift_of_0_for_1_sectors_per_block", resourceCulture);
+                return ResourceManager.GetString("Disc_ID_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Guessed disk type: {0}.
-        /// </summary>
-        internal static string Guessed_disk_type_0 {
+        internal static string MCN_not_set {
             get {
-                return ResourceManager.GetString("Guessed_disk_type_0", resourceCulture);
+                return ResourceManager.GetString("MCN_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Hardware sector {0} of track {1} goes to logical sector {2}.
-        /// </summary>
-        internal static string Hardware_sector_0_of_track_1_goes_to_logical_sector_2 {
+        internal static string MCN_0 {
             get {
-                return ResourceManager.GetString("Hardware_sector_0_of_track_1_goes_to_logical_sector_2", resourceCulture);
+                return ResourceManager.GetString("MCN_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Has battery backed RAM.
-        /// </summary>
-        internal static string Has_battery_backed_RAM {
+        internal static string Comment_not_set {
             get {
-                return ResourceManager.GetString("Has_battery_backed_RAM", resourceCulture);
+                return ResourceManager.GetString("Comment_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to HD-Copy disk image.
-        /// </summary>
-        internal static string HdCopy_Name {
+        internal static string Track_information {
             get {
-                return ResourceManager.GetString("HdCopy_Name", resourceCulture);
+                return ResourceManager.GetString("Track_information", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Header checksum: 0x{0:X2}.
-        /// </summary>
-        internal static string Header_checksum_0 {
+        internal static string Disc_contains_0_tracks {
             get {
-                return ResourceManager.GetString("Header_checksum_0", resourceCulture);
+                return ResourceManager.GetString("Disc_contains_0_tracks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Header checksum: 0x{0:X4}.
-        /// </summary>
-        internal static string Header_checksum_0_X4 {
+        internal static string Track_0_information {
             get {
-                return ResourceManager.GetString("Header_checksum_0_X4", resourceCulture);
+                return ResourceManager.GetString("Track_0_information", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Header checksum complement: 0x{0:X4}.
-        /// </summary>
-        internal static string Header_checksum_complement_0 {
+        internal static string _0_bytes_per_sector {
             get {
-                return ResourceManager.GetString("Header_checksum_complement_0", resourceCulture);
+                return ResourceManager.GetString("_0_bytes_per_sector", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Header checksum = 0x{0:X8}, calculated = 0x{1:X8}.
-        /// </summary>
-        internal static string Header_checksum_equals_0_X8_calculated_equals_1_X8 {
+        internal static string Pregap_0_sectors {
             get {
-                return ResourceManager.GetString("Header_checksum_equals_0_X8_calculated_equals_1_X8", resourceCulture);
+                return ResourceManager.GetString("Pregap_0_sectors", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to How many sectors to store per block (will be rounded to next power of two).
-        /// </summary>
-        internal static string How_many_sectors_to_store_per_block_will_be_rounded_to_next_power_of_two {
+        internal static string Data_0_sectors_starting_at_sector_1 {
             get {
-                return ResourceManager.GetString("How_many_sectors_to_store_per_block_will_be_rounded_to_next_power_of_two", resourceCulture);
+                return ResourceManager.GetString("Data_0_sectors_starting_at_sector_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Hunk type {0} is not supported.
-        /// </summary>
-        internal static string Hunk_type_0_is_not_supported {
+        internal static string Postgap_0_sectors {
             get {
-                return ResourceManager.GetString("Hunk_type_0_is_not_supported", resourceCulture);
+                return ResourceManager.GetString("Postgap_0_sectors", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Identified image with C/H/S = {0}/{1}/{2}.
-        /// </summary>
-        internal static string Identified_image_with_CHS_equals_0_1_2 {
+        internal static string Track_is_flagged_as_quadraphonic {
             get {
-                return ResourceManager.GetString("Identified_image_with_CHS_equals_0_1_2", resourceCulture);
+                return ResourceManager.GetString("Track_is_flagged_as_quadraphonic", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Ignored field type {0}.
-        /// </summary>
-        internal static string Ignored_field_type_0 {
+        internal static string Track_allows_digital_copy {
             get {
-                return ResourceManager.GetString("Ignored_field_type_0", resourceCulture);
+                return ResourceManager.GetString("Track_allows_digital_copy", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image application = {0} version {1}.
-        /// </summary>
-        internal static string Image_application_0_version_1 {
+        internal static string Track_has_pre_emphasis_applied {
             get {
-                return ResourceManager.GetString("Image_application_0_version_1", resourceCulture);
+                return ResourceManager.GetString("Track_has_pre_emphasis_applied", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image cannot be a CD-ROM and a GD-ROM at the same time, aborting..
-        /// </summary>
-        internal static string Image_cannot_be_a_CD_ROM_and_a_GD_ROM_at_the_same_time_aborting {
+        internal static string Track_resides_in_file_0_type_defined_as_1_starting_at_byte_2 {
             get {
-                return ResourceManager.GetString("Image_cannot_be_a_CD_ROM_and_a_GD_ROM_at_the_same_time_aborting", resourceCulture);
+                return ResourceManager.GetString("Track_resides_in_file_0_type_defined_as_1_starting_at_byte_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image cannot be a GD-ROM and a CD-ROM at the same time, aborting..
-        /// </summary>
-        internal static string Image_cannot_be_a_GD_ROM_and_a_CD_ROM_at_the_same_time_aborting {
+        internal static string Indexes {
             get {
-                return ResourceManager.GetString("Image_cannot_be_a_GD_ROM_and_a_CD_ROM_at_the_same_time_aborting", resourceCulture);
+                return ResourceManager.GetString("Indexes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image cannot be a hard disk and a CD-ROM at the same time, aborting..
-        /// </summary>
-        internal static string Image_cannot_be_a_hard_disk_and_a_CD_ROM_at_the_same_time_aborting {
+        internal static string Index_0_starts_at_sector_1 {
             get {
-                return ResourceManager.GetString("Image_cannot_be_a_hard_disk_and_a_CD_ROM_at_the_same_time_aborting", resourceCulture);
+                return ResourceManager.GetString("Index_0_starts_at_sector_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image cannot be a hard disk and a C/GD-ROM at the same time, aborting..
-        /// </summary>
-        internal static string Image_cannot_be_a_hard_disk_and_a_CGD_ROM_at_the_same_time_aborting {
+        internal static string ISRC_is_not_set {
             get {
-                return ResourceManager.GetString("Image_cannot_be_a_hard_disk_and_a_CGD_ROM_at_the_same_time_aborting", resourceCulture);
+                return ResourceManager.GetString("ISRC_is_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image cannot be a hard disk and a GD-ROM at the same time, aborting..
-        /// </summary>
-        internal static string Image_cannot_be_a_hard_disk_and_a_GD_ROM_at_the_same_time_aborting {
+        internal static string ISRC_0 {
             get {
-                return ResourceManager.GetString("Image_cannot_be_a_hard_disk_and_a_GD_ROM_at_the_same_time_aborting", resourceCulture);
+                return ResourceManager.GetString("ISRC_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image corrupted beyond recovery, cannot open..
-        /// </summary>
-        internal static string Image_corrupted_beyond_recovery_cannot_open {
+        internal static string Building_offset_map {
             get {
-                return ResourceManager.GetString("Image_corrupted_beyond_recovery_cannot_open", resourceCulture);
+                return ResourceManager.GetString("Building_offset_map", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image created on {0}.
-        /// </summary>
-        internal static string Image_created_on_0 {
+        internal static string Unordered_tracks {
             get {
-                return ResourceManager.GetString("Image_created_on_0", resourceCulture);
+                return ResourceManager.GetString("Unordered_tracks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image does not represent a known media, aborting.
-        /// </summary>
-        internal static string Image_does_not_represent_a_known_media_aborting {
+        internal static string CDRDAO_image_describes_a_disc_of_type_0 {
             get {
-                return ResourceManager.GetString("Image_does_not_represent_a_known_media_aborting", resourceCulture);
+                return ResourceManager.GetString("CDRDAO_image_describes_a_disc_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image is differential but parent cannot be opened..
-        /// </summary>
-        internal static string Image_is_differential_but_parent_cannot_be_opened {
+        internal static string CDRDAO_comments_0 {
             get {
-                return ResourceManager.GetString("Image_is_differential_but_parent_cannot_be_opened", resourceCulture);
+                return ResourceManager.GetString("CDRDAO_comments_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image is not opened for writing.
-        /// </summary>
-        internal static string Image_is_not_opened_for_writing {
+        internal static string Invalid_value_for_split_option {
             get {
-                return ResourceManager.GetString("Image_is_not_opened_for_writing", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_split_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image is too large.
-        /// </summary>
-        internal static string Image_is_too_large {
+        internal static string Separate_tracks_not_yet_implemented {
             get {
-                return ResourceManager.GetString("Image_is_too_large", resourceCulture);
+                return ResourceManager.GetString("Separate_tracks_not_yet_implemented", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image last written on {0}.
-        /// </summary>
-        internal static string Image_last_written_on_0 {
+        internal static string Cant_find_file_containing_0 {
             get {
-                return ResourceManager.GetString("Image_last_written_on_0", resourceCulture);
+                return ResourceManager.GetString("Cant_find_file_containing_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image modified on {0}.
-        /// </summary>
-        internal static string Image_modified_on_0 {
+        internal static string Invalid_tracks_sent {
             get {
-                return ResourceManager.GetString("Image_modified_on_0", resourceCulture);
+                return ResourceManager.GetString("Invalid_tracks_sent", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image resource fork doesn&apos;t contain UDIF block chunks. Please fill an issue and send it to us..
-        /// </summary>
-        internal static string Image_resource_fork_doesnt_contain_UDIF_block_chunks {
+        internal static string Unsupported_subchannel_type_0_for_track_1 {
             get {
-                return ResourceManager.GetString("Image_resource_fork_doesnt_contain_UDIF_block_chunks", resourceCulture);
+                return ResourceManager.GetString("Unsupported_subchannel_type_0_for_track_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image says it&apos;s unformatted.
-        /// </summary>
-        internal static string Image_says_its_unformatted {
+        internal static string CdrWin_Name {
             get {
-                return ResourceManager.GetString("Image_says_its_unformatted", resourceCulture);
+                return ResourceManager.GetString("CdrWin_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image size is too small.
-        /// </summary>
-        internal static string Image_size_is_too_small {
+        internal static string Write_each_track_to_a_separate_file {
             get {
-                return ResourceManager.GetString("Image_size_is_too_small", resourceCulture);
+                return ResourceManager.GetString("Write_each_track_to_a_separate_file", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image uses unknown incompatible features {0:X}.
-        /// </summary>
-        internal static string Image_uses_unknown_incompatible_features_0 {
+        internal static string Found_TRACK_0_out_of_order_in_line_1 {
             get {
-                return ResourceManager.GetString("Image_uses_unknown_incompatible_features_0", resourceCulture);
+                return ResourceManager.GetString("Found_TRACK_0_out_of_order_in_line_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Image version {0} not recognized..
-        /// </summary>
-        internal static string Image_version_0_not_recognized {
+        internal static string No_tracks_found {
             get {
-                return ResourceManager.GetString("Image_version_0_not_recognized", resourceCulture);
+                return ResourceManager.GetString("No_tracks_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to IMD comments: {0}.
-        /// </summary>
-        internal static string IMD_comments_0 {
+        internal static string Found_REM_CRC32_at_line_0 {
             get {
-                return ResourceManager.GetString("IMD_comments_0", resourceCulture);
+                return ResourceManager.GetString("Found_REM_CRC32_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to IMD image contains a disk of type {0}.
-        /// </summary>
-        internal static string IMD_image_contains_a_disk_of_type_0 {
+        internal static string Found_REM_MD5_at_line_0 {
             get {
-                return ResourceManager.GetString("IMD_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Found_REM_MD5_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Dunfield&apos;s IMD.
-        /// </summary>
-        internal static string Imd_Name {
+        internal static string Found_REM_SHA1_at_line_0 {
             get {
-                return ResourceManager.GetString("Imd_Name", resourceCulture);
+                return ResourceManager.GetString("Found_REM_SHA1_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to In memory DDT?: {0}.
-        /// </summary>
-        internal static string In_memory_DDT_0 {
+        internal static string Found_CRC32_for_1_2_at_line_0 {
             get {
-                return ResourceManager.GetString("In_memory_DDT_0", resourceCulture);
+                return ResourceManager.GetString("Found_CRC32_for_1_2_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Inconsistent track mode and track sector size found. A best try to fix has been done. It is recommended this disc is dumped with another software..
-        /// </summary>
-        internal static string Inconsistent_track_mode_and_track_sector_size_found {
+        internal static string track {
             get {
-                return ResourceManager.GetString("Inconsistent_track_mode_and_track_sector_size_found", resourceCulture);
+                return ResourceManager.GetString("track", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect Alcohol 120% image created by an old version of Aaru. Convert image to correct it..
-        /// </summary>
-        internal static string Incorrect_Alcohol_120_image_created_by_an_old_version_of_Aaru_Convert_image_to_correct_it {
+        internal static string Found_MD5_for_1_2_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_Alcohol_120_image_created_by_an_old_version_of_Aaru_Convert_image_to_co" +
-                        "rrect_it", resourceCulture);
+                return ResourceManager.GetString("Found_MD5_for_1_2_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect CRC found: 0x{0:X16} found, expected 0x{1:X16}, continuing....
-        /// </summary>
-        internal static string Incorrect_CRC_found_0_X16_found_expected_1_X16_continuing {
+        internal static string gap {
             get {
-                return ResourceManager.GetString("Incorrect_CRC_found_0_X16_found_expected_1_X16_continuing", resourceCulture);
+                return ResourceManager.GetString("gap", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect data size.
-        /// </summary>
-        internal static string Incorrect_data_size {
+        internal static string Found_SHA1_for_1_2_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_data_size", resourceCulture);
+                return ResourceManager.GetString("Found_SHA1_for_1_2_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect data size for CMI.
-        /// </summary>
-        internal static string Incorrect_data_size_for_CMI {
+        internal static string Found_unknown_hash_for_1_2_at_line_0_Please_report_this_disc_image {
             get {
-                return ResourceManager.GetString("Incorrect_data_size_for_CMI", resourceCulture);
+                return ResourceManager.GetString("Found_unknown_hash_for_1_2_at_line_0_Please_report_this_disc_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect data size for decrypted title key.
-        /// </summary>
-        internal static string Incorrect_data_size_for_decrypted_title_key {
+        internal static string Found_REM_METADATA_DUMP_EXTENT_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_data_size_for_decrypted_title_key", resourceCulture);
+                return ResourceManager.GetString("Found_REM_METADATA_DUMP_EXTENT_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect data size for subchannel.
-        /// </summary>
-        internal static string Incorrect_data_size_for_subchannel {
+        internal static string Found_REM_METADATA_DIC_MEDIA_TYPE_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_data_size_for_subchannel", resourceCulture);
+                return ResourceManager.GetString("Found_REM_METADATA_DIC_MEDIA_TYPE_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect data size for title key.
-        /// </summary>
-        internal static string Incorrect_data_size_for_title_key {
+        internal static string Found_REM_METADATA_AARU_MEDIA_TYPE_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_data_size_for_title_key", resourceCulture);
+                return ResourceManager.GetString("Found_REM_METADATA_AARU_MEDIA_TYPE_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect data size for track flags.
-        /// </summary>
-        internal static string Incorrect_data_size_for_track_flags {
+        internal static string Found_REM_ORIGINAL_MEDIA_TYPE_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_data_size_for_track_flags", resourceCulture);
+                return ResourceManager.GetString("Found_REM_ORIGINAL_MEDIA_TYPE_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect disk type {0}.
-        /// </summary>
-        internal static string Incorrect_disk_type_0 {
+        internal static string Found_REM_SESSION_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_disk_type_0", resourceCulture);
+                return ResourceManager.GetString("Found_REM_SESSION_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect identifier for compact disc indexes block at position {0}.
-        /// </summary>
-        internal static string Incorrect_identifier_for_compact_disc_indexes_block_at_position_0 {
+        internal static string Found_REM_SINGLE_DENSITY_AREA_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_identifier_for_compact_disc_indexes_block_at_position_0", resourceCulture);
+                return ResourceManager.GetString("Found_REM_SINGLE_DENSITY_AREA_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect identifier for data block at position {0}.
-        /// </summary>
-        internal static string Incorrect_identifier_for_data_block_at_position_0 {
+        internal static string Found_REM_HIGH_DENSITY_AREA_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_identifier_for_data_block_at_position_0", resourceCulture);
+                return ResourceManager.GetString("Found_REM_HIGH_DENSITY_AREA_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect identifier for tracks block at position {0}.
-        /// </summary>
-        internal static string Incorrect_identifier_for_tracks_block_at_position_0 {
+        internal static string Found_REM_MSF_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_identifier_for_tracks_block_at_position_0", resourceCulture);
+                return ResourceManager.GetString("Found_REM_MSF_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect index identifier.
-        /// </summary>
-        internal static string Incorrect_index_identifier {
+        internal static string Found_REM_LEAD_OUT_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_index_identifier", resourceCulture);
+                return ResourceManager.GetString("Found_REM_LEAD_OUT_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect number of sectors for Apple HD20 image.
-        /// </summary>
-        internal static string Incorrect_number_of_sectors_for_Apple_HD20_image {
+        internal static string Found_REM_Ripping_Tool_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_number_of_sectors_for_Apple_HD20_image", resourceCulture);
+                return ResourceManager.GetString("Found_REM_Ripping_Tool_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect number of sectors for Apple MF1DD image.
-        /// </summary>
-        internal static string Incorrect_number_of_sectors_for_Apple_MF1DD_image {
+        internal static string Found_REM_Ripping_Tool_Version_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_number_of_sectors_for_Apple_MF1DD_image", resourceCulture);
+                return ResourceManager.GetString("Found_REM_Ripping_Tool_Version_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect number of sectors for Apple MF2DD image.
-        /// </summary>
-        internal static string Incorrect_number_of_sectors_for_Apple_MF2DD_image {
+        internal static string Found_REM_DISC_HASHES_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_number_of_sectors_for_Apple_MF2DD_image", resourceCulture);
+                return ResourceManager.GetString("Found_REM_DISC_HASHES_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect number of sectors for Apple Profile image.
-        /// </summary>
-        internal static string Incorrect_number_of_sectors_for_Apple_Profile_image {
+        internal static string Found_REM_Gap_Append_Method_1_2_HASHES_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_number_of_sectors_for_Apple_Profile_image", resourceCulture);
+                return ResourceManager.GetString("Found_REM_Gap_Append_Method_1_2_HASHES_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect number of sectors for Apple Widget image.
-        /// </summary>
-        internal static string Incorrect_number_of_sectors_for_Apple_Widget_image {
+        internal static string Found_REM_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_number_of_sectors_for_Apple_Widget_image", resourceCulture);
+                return ResourceManager.GetString("Found_REM_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect number of sectors for DMF image.
-        /// </summary>
-        internal static string Incorrect_number_of_sectors_for_DMF_image {
+        internal static string Found_ARRANGER_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_number_of_sectors_for_DMF_image", resourceCulture);
+                return ResourceManager.GetString("Found_ARRANGER_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect number of sectors for media.
-        /// </summary>
-        internal static string Incorrect_number_of_sectors_for_media {
+        internal static string Found_UPC_EAN_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_number_of_sectors_for_media", resourceCulture);
+                return ResourceManager.GetString("Found_UPC_EAN_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect number of sectors for MF2DD image.
-        /// </summary>
-        internal static string Incorrect_number_of_sectors_for_MF2DD_image {
+        internal static string Found_barcode_field_in_incorrect_place_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_number_of_sectors_for_MF2DD_image", resourceCulture);
+                return ResourceManager.GetString("Found_barcode_field_in_incorrect_place_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect number of sectors for MF2HD image.
-        /// </summary>
-        internal static string Incorrect_number_of_sectors_for_MF2HD_image {
+        internal static string Found_CDTEXTFILE_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_number_of_sectors_for_MF2HD_image", resourceCulture);
+                return ResourceManager.GetString("Found_CDTEXTFILE_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Incorrect tag for disk type.
-        /// </summary>
-        internal static string Incorrect_tag_for_disk_type {
+        internal static string Found_CD_Text_file_field_in_incorrect_place_at_line_0 {
             get {
-                return ResourceManager.GetString("Incorrect_tag_for_disk_type", resourceCulture);
+                return ResourceManager.GetString("Found_CD_Text_file_field_in_incorrect_place_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Index {0} starts at sector {1}.
-        /// </summary>
-        internal static string Index_0_starts_at_sector_1 {
+        internal static string Found_COMPOSER_at_line_0 {
             get {
-                return ResourceManager.GetString("Index_0_starts_at_sector_1", resourceCulture);
+                return ResourceManager.GetString("Found_COMPOSER_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Index at {0} contains {1} entries.
-        /// </summary>
-        internal static string Index_at_0_contains_1_entries {
+        internal static string Found_DISC_ID_at_line_0 {
             get {
-                return ResourceManager.GetString("Index_at_0_contains_1_entries", resourceCulture);
+                return ResourceManager.GetString("Found_DISC_ID_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Index not found!.
-        /// </summary>
-        internal static string Index_not_found {
+        internal static string Found_CDDB_ID_field_in_incorrect_place_at_line_0 {
             get {
-                return ResourceManager.GetString("Index_not_found", resourceCulture);
+                return ResourceManager.GetString("Found_CDDB_ID_field_in_incorrect_place_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Index not found in existing image, cannot continue.
-        /// </summary>
-        internal static string Index_not_found_in_existing_image_cannot_continue {
+        internal static string Found_FILE_at_line_0 {
             get {
-                return ResourceManager.GetString("Index_not_found_in_existing_image_cannot_continue", resourceCulture);
+                return ResourceManager.GetString("Found_FILE_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Indexes:.
-        /// </summary>
-        internal static string Indexes {
+        internal static string File_0_not_found {
             get {
-                return ResourceManager.GetString("Indexes", resourceCulture);
+                return ResourceManager.GetString("File_0_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Indonesia.
-        /// </summary>
-        internal static string Indonesia {
+        internal static string File_0_found {
             get {
-                return ResourceManager.GetString("Indonesia", resourceCulture);
+                return ResourceManager.GetString("File_0_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to INST-ROM size: {0} bytes.
-        /// </summary>
-        internal static string INST_ROM_size_0_bytes {
+        internal static string Unsupported_file_type_0 {
             get {
-                return ResourceManager.GetString("INST_ROM_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Unsupported_file_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to International.
-        /// </summary>
-        internal static string International {
+        internal static string Unknown_file_type_0 {
             get {
-                return ResourceManager.GetString("International", resourceCulture);
+                return ResourceManager.GetString("Unknown_file_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid adapter type {0}.
-        /// </summary>
-        internal static string Invalid_adapter_type_0 {
+        internal static string Found_FLAGS_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_adapter_type_0", resourceCulture);
+                return ResourceManager.GetString("Found_FLAGS_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid compression type {0} for block with data type {1}, continuing....
-        /// </summary>
-        internal static string Invalid_compression_type_0_for_block_with_data_type_1_continuing {
+        internal static string Found_FLAGS_field_in_incorrect_place_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_compression_type_0_for_block_with_data_type_1_continuing", resourceCulture);
+                return ResourceManager.GetString("Found_FLAGS_field_in_incorrect_place_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid encryption method.
-        /// </summary>
-        internal static string Invalid_encryption_method {
+        internal static string Found_GENRE_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_encryption_method", resourceCulture);
+                return ResourceManager.GetString("Found_GENRE_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid hunk found..
-        /// </summary>
-        internal static string Invalid_hunk_found {
+        internal static string Found_INDEX_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_hunk_found", resourceCulture);
+                return ResourceManager.GetString("Found_INDEX_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid read mode {0} for this track.
-        /// </summary>
-        internal static string Invalid_read_mode_0_for_this_track {
+        internal static string Found_INDEX_before_a_track_0 {
             get {
-                return ResourceManager.GetString("Invalid_read_mode_0_for_this_track", resourceCulture);
+                return ResourceManager.GetString("Found_INDEX_before_a_track_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid sector type {0}.
-        /// </summary>
-        internal static string Invalid_sector_type_0 {
+        internal static string Found_INDEX_0_before_INDEX_00_or_INDEX_01 {
             get {
-                return ResourceManager.GetString("Invalid_sector_type_0", resourceCulture);
+                return ResourceManager.GetString("Found_INDEX_0_before_INDEX_00_or_INDEX_01", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid sector type &apos;{0}&apos; encountered.
-        /// </summary>
-        internal static string Invalid_sector_type_0_encountered {
+        internal static string Sets_currentFile_offset_to_0 {
             get {
-                return ResourceManager.GetString("Invalid_sector_type_0_encountered", resourceCulture);
+                return ResourceManager.GetString("Sets_currentFile_offset_to_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid subchannel mode for this sector.
-        /// </summary>
-        internal static string Invalid_subchannel_mode_for_this_sector {
+        internal static string Found_ISRC_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_subchannel_mode_for_this_sector", resourceCulture);
+                return ResourceManager.GetString("Found_ISRC_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid track block found at {0}.
-        /// </summary>
-        internal static string Invalid_track_block_found_at_0 {
+        internal static string Found_ISRC_before_a_track_0 {
             get {
-                return ResourceManager.GetString("Invalid_track_block_found_at_0", resourceCulture);
+                return ResourceManager.GetString("Found_ISRC_before_a_track_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid tracks sent.
-        /// </summary>
-        internal static string Invalid_tracks_sent {
+        internal static string Found_CATALOG_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_tracks_sent", resourceCulture);
+                return ResourceManager.GetString("Found_CATALOG_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for compress option.
-        /// </summary>
-        internal static string Invalid_value_for_compress_option {
+        internal static string Found_CATALOG_field_in_incorrect_place_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_compress_option", resourceCulture);
+                return ResourceManager.GetString("Found_CATALOG_field_in_incorrect_place_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for deduplicate option.
-        /// </summary>
-        internal static string Invalid_value_for_deduplicate_option {
+        internal static string Found_PERFORMER_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_deduplicate_option", resourceCulture);
+                return ResourceManager.GetString("Found_PERFORMER_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for dictionary option.
-        /// </summary>
-        internal static string Invalid_value_for_dictionary_option {
+        internal static string Found_POSTGAP_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_dictionary_option", resourceCulture);
+                return ResourceManager.GetString("Found_POSTGAP_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for hwversion option.
-        /// </summary>
-        internal static string Invalid_value_for_hwversion_option {
+        internal static string Found_POSTGAP_field_before_a_track_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_hwversion_option", resourceCulture);
+                return ResourceManager.GetString("Found_POSTGAP_field_before_a_track_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for max_ddt_size option.
-        /// </summary>
-        internal static string Invalid_value_for_max_ddt_size_option {
+        internal static string Found_PREGAP_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_max_ddt_size_option", resourceCulture);
+                return ResourceManager.GetString("Found_PREGAP_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for md5 option.
-        /// </summary>
-        internal static string Invalid_value_for_md5_option {
+        internal static string Found_SONGWRITER_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_md5_option", resourceCulture);
+                return ResourceManager.GetString("Found_SONGWRITER_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for sectors_per_block option.
-        /// </summary>
-        internal static string Invalid_value_for_sectors_per_block_option {
+        internal static string Found_PREGAP_field_before_a_track_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_sectors_per_block_option", resourceCulture);
+                return ResourceManager.GetString("Found_PREGAP_field_before_a_track_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for sha1 option.
-        /// </summary>
-        internal static string Invalid_value_for_sha1_option {
+        internal static string Found_TITLE_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_sha1_option", resourceCulture);
+                return ResourceManager.GetString("Found_TITLE_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for sha256 option.
-        /// </summary>
-        internal static string Invalid_value_for_sha256_option {
+        internal static string Found_TRACK_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_sha256_option", resourceCulture);
+                return ResourceManager.GetString("Found_TRACK_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for spamsum option.
-        /// </summary>
-        internal static string Invalid_value_for_spamsum_option {
+        internal static string Found_TRACK_field_before_a_file_is_defined_at_line_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_spamsum_option", resourceCulture);
+                return ResourceManager.GetString("Found_TRACK_field_before_a_file_is_defined_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for sparse option.
-        /// </summary>
-        internal static string Invalid_value_for_sparse_option {
+        internal static string Setting_currentTrack_sequence_to_0 {
             get {
-                return ResourceManager.GetString("Invalid_value_for_sparse_option", resourceCulture);
+                return ResourceManager.GetString("Setting_currentTrack_sequence_to_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid value for split option.
-        /// </summary>
-        internal static string Invalid_value_for_split_option {
+        internal static string This_image_from_PowerISO_is_damaged_beyond_possible_recovery_Will_not_open {
             get {
-                return ResourceManager.GetString("Invalid_value_for_split_option", resourceCulture);
+                return ResourceManager.GetString("This_image_from_PowerISO_is_damaged_beyond_possible_recovery_Will_not_open", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Invalid write mode for this sector.
-        /// </summary>
-        internal static string Invalid_write_mode_for_this_sector {
+        internal static string Found_unknown_field_defined_at_line_0_1 {
             get {
-                return ResourceManager.GetString("Invalid_write_mode_for_this_sector", resourceCulture);
+                return ResourceManager.GetString("Found_unknown_field_defined_at_line_0_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ISOBuster disc type: {0}.
-        /// </summary>
-        internal static string ISOBuster_disc_type_0 {
+        internal static string The_data_files_are_not_correct_according_to_the_cuesheet_file_cannot_continue_with_this_file {
             get {
-                return ResourceManager.GetString("ISOBuster_disc_type_0", resourceCulture);
+                return ResourceManager.GetString("The_data_files_are_not_correct_according_to_the_cuesheet_file_cannot_continue_wit" +
+                        "h_this_file", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ISOBuster disc type not set..
-        /// </summary>
-        internal static string ISOBuster_disc_type_not_set {
+        internal static string The_data_files_are_missing_a_pregap_or_hidden_track_contents_will_do_best_effort_to_make_the_rest_of_the_image_readable {
             get {
-                return ResourceManager.GetString("ISOBuster_disc_type_not_set", resourceCulture);
+                return ResourceManager.GetString("The_data_files_are_missing_a_pregap_or_hidden_track_contents_will_do_best_effort_" +
+                        "to_make_the_rest_of_the_image_readable", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ISRC: {0}.
-        /// </summary>
-        internal static string ISRC_0 {
+        internal static string This_image_is_most_probably_corrupted_beyond_repair_It_is_highly_recommended_to_dump_it_with_another_software {
             get {
-                return ResourceManager.GetString("ISRC_0", resourceCulture);
+                return ResourceManager.GetString("This_image_is_most_probably_corrupted_beyond_repair_It_is_highly_recommended_to_d" +
+                        "ump_it_with_another_software", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ISRC is not set..
-        /// </summary>
-        internal static string ISRC_is_not_set {
+        internal static string Genre_is_not_set {
             get {
-                return ResourceManager.GetString("ISRC_is_not_set", resourceCulture);
+                return ResourceManager.GetString("Genre_is_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Italy.
-        /// </summary>
-        internal static string Italy {
+        internal static string Genre_0 {
             get {
-                return ResourceManager.GetString("Italy", resourceCulture);
+                return ResourceManager.GetString("Genre_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Japan.
-        /// </summary>
-        internal static string Japan {
+        internal static string CD_TEXT_binary_file_not_set {
             get {
-                return ResourceManager.GetString("Japan", resourceCulture);
+                return ResourceManager.GetString("CD_TEXT_binary_file_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Korea.
-        /// </summary>
-        internal static string Korea {
+        internal static string CD_TEXT_binary_file_0 {
             get {
-                return ResourceManager.GetString("Korea", resourceCulture);
+                return ResourceManager.GetString("CD_TEXT_binary_file_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to KryoFlux STREAM.
-        /// </summary>
-        internal static string KryoFlux_Name {
+        internal static string ISOBuster_disc_type_not_set {
             get {
-                return ResourceManager.GetString("KryoFlux_Name", resourceCulture);
+                return ResourceManager.GetString("ISOBuster_disc_type_not_set", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to L2 size must be between 512 bytes and 64 Kbytes.
-        /// </summary>
-        internal static string L2_size_must_be_between_512_bytes_and_64_Kbytes {
+        internal static string ISOBuster_disc_type_0 {
             get {
-                return ResourceManager.GetString("L2_size_must_be_between_512_bytes_and_64_Kbytes", resourceCulture);
+                return ResourceManager.GetString("ISOBuster_disc_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to LBA: {0}.
-        /// </summary>
-        internal static string LBA_0 {
+        internal static string Data_0_sectors {
             get {
-                return ResourceManager.GetString("LBA_0", resourceCulture);
+                return ResourceManager.GetString("Data_0_sectors", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Licensee: {0}.
-        /// </summary>
-        internal static string Licensee_0 {
+        internal static string Track_has_SCMS {
             get {
-                return ResourceManager.GetString("Licensee_0", resourceCulture);
+                return ResourceManager.GetString("Track_has_SCMS", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Lisa Twiggy detected, reversing second half of disk.
-        /// </summary>
-        internal static string Lisa_Twiggy_detected_reversing_second_half_of_disk {
+        internal static string Session_information {
             get {
-                return ResourceManager.GetString("Lisa_Twiggy_detected_reversing_second_half_of_disk", resourceCulture);
+                return ResourceManager.GetString("Session_information", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Logical sector size not found..
-        /// </summary>
-        internal static string Logical_sector_size_not_found {
+        internal static string Disc_contains_0_sessions {
             get {
-                return ResourceManager.GetString("Logical_sector_size_not_found", resourceCulture);
+                return ResourceManager.GetString("Disc_contains_0_sessions", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to LZH Compressed images not yet supported.
-        /// </summary>
-        internal static string LZH_Compressed_images_not_yet_supported {
+        internal static string Session_0_information {
             get {
-                return ResourceManager.GetString("LZH_Compressed_images_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Session_0_information", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Macintosh Twiggy detected, reversing disk sides.
-        /// </summary>
-        internal static string Macintosh_Twiggy_detected_reversing_disk_sides {
+        internal static string Starting_track_0 {
             get {
-                return ResourceManager.GetString("Macintosh_Twiggy_detected_reversing_disk_sides", resourceCulture);
+                return ResourceManager.GetString("Starting_track_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to magic = &quot;{0}&quot;.
-        /// </summary>
-        internal static string magic_equals_0_quoted {
+        internal static string Starting_sector_0 {
             get {
-                return ResourceManager.GetString("magic_equals_0_quoted", resourceCulture);
+                return ResourceManager.GetString("Starting_sector_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Maker code: {0}.
-        /// </summary>
-        internal static string Maker_code_0 {
+        internal static string Ending_track_0 {
             get {
-                return ResourceManager.GetString("Maker_code_0", resourceCulture);
+                return ResourceManager.GetString("Ending_track_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Manufacturer: {0}.
-        /// </summary>
-        internal static string Manufacturer_0 {
+        internal static string Ending_sector_0 {
             get {
-                return ResourceManager.GetString("Manufacturer_0", resourceCulture);
+                return ResourceManager.GetString("Ending_sector_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Mapper: {0}.
-        /// </summary>
-        internal static string Mapper_0 {
+        internal static string Track_0_lacks_index_01 {
             get {
-                return ResourceManager.GetString("Mapper_0", resourceCulture);
+                return ResourceManager.GetString("Track_0_lacks_index_01", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Master System.
-        /// </summary>
-        internal static string Master_System {
+        internal static string CDRWIN_image_describes_a_disc_of_type_0 {
             get {
-                return ResourceManager.GetString("Master_System", resourceCulture);
+                return ResourceManager.GetString("CDRWIN_image_describes_a_disc_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sega Game Gear / Master System.
-        /// </summary>
-        internal static string MasterSystem_Name {
+        internal static string CDRWIN_comments_0 {
             get {
-                return ResourceManager.GetString("MasterSystem_Name", resourceCulture);
+                return ResourceManager.GetString("CDRWIN_comments_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to MAXI Disk image.
-        /// </summary>
-        internal static string MaxiDisk_Name {
+        internal static string This_image_is_missing_vital_multi_session_data_and_cannot_be_read_correctly {
             get {
-                return ResourceManager.GetString("MaxiDisk_Name", resourceCulture);
+                return ResourceManager.GetString("This_image_is_missing_vital_multi_session_data_and_cannot_be_read_correctly", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Maximum size, in mebibytes, for in-memory DDT. If image needs a bigger one, it will be on-disk.
-        /// </summary>
-        internal static string Maximum_size_in_mebibytes_for_in_memory_DDT_If_image_needs_a_bigger_one_it_will_be_on_disk {
+        internal static string Calculated_SHA1_0 {
             get {
-                return ResourceManager.GetString("Maximum_size_in_mebibytes_for_in_memory_DDT_If_image_needs_a_bigger_one_it_will_b" +
-                        "e_on_disk", resourceCulture);
+                return ResourceManager.GetString("Calculated_SHA1_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to MCN: {0}.
-        /// </summary>
-        internal static string MCN_0 {
+        internal static string Expected_SHA1_0 {
             get {
-                return ResourceManager.GetString("MCN_0", resourceCulture);
+                return ResourceManager.GetString("Expected_SHA1_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to MCN not set..
-        /// </summary>
-        internal static string MCN_not_set {
+        internal static string Calculated_MD5_0 {
             get {
-                return ResourceManager.GetString("MCN_not_set", resourceCulture);
+                return ResourceManager.GetString("Calculated_MD5_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Media tag type {0} duplicated, removing previous entry....
-        /// </summary>
-        internal static string Media_tag_type_0_duplicated_removing_previous_entry {
+        internal static string Expected_MD5_0 {
             get {
-                return ResourceManager.GetString("Media_tag_type_0_duplicated_removing_previous_entry", resourceCulture);
+                return ResourceManager.GetString("Expected_MD5_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Media type is {0} ({1}).
-        /// </summary>
-        internal static string Media_type_is_0_1 {
+        internal static string Calculated_CRC32_0 {
             get {
-                return ResourceManager.GetString("Media_type_is_0_1", resourceCulture);
+                return ResourceManager.GetString("Calculated_CRC32_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to MediaType: {0}.
-        /// </summary>
-        internal static string MediaType_0 {
+        internal static string Expected_CRC32_0 {
             get {
-                return ResourceManager.GetString("MediaType_0", resourceCulture);
+                return ResourceManager.GetString("Expected_CRC32_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Memory snapshot: {0} bytes.
-        /// </summary>
-        internal static string Memory_snapshot_0_bytes {
+        internal static string Found_unsupported_hash_0 {
             get {
-                return ResourceManager.GetString("Memory_snapshot_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Found_unsupported_hash_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Metadata not found, cannot continue..
-        /// </summary>
-        internal static string Metadata_not_found_cannot_continue {
+        internal static string Unsupported_compression_0 {
             get {
-                return ResourceManager.GetString("Metadata_not_found_cannot_continue", resourceCulture);
+                return ResourceManager.GetString("Unsupported_compression_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to mode page 2A: {0}.
-        /// </summary>
-        internal static string mode_page_2A_0 {
+        internal static string Unable_to_decompress_hunk_correctly_got_0_bytes_expected_1 {
             get {
-                return ResourceManager.GetString("mode_page_2A_0", resourceCulture);
+                return ResourceManager.GetString("Unable_to_decompress_hunk_correctly_got_0_bytes_expected_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Modem support: {0}.
-        /// </summary>
-        internal static string Modem_support_0 {
+        internal static string Invalid_hunk_found {
             get {
-                return ResourceManager.GetString("Modem_support_0", resourceCulture);
+                return ResourceManager.GetString("Invalid_hunk_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Name: {0}.
-        /// </summary>
-        internal static string Name_0 {
+        internal static string Compressed_CD_GD_ROM_hunks_are_not_yet_supported {
             get {
-                return ResourceManager.GetString("Name_0", resourceCulture);
+                return ResourceManager.GetString("Compressed_CD_GD_ROM_hunks_are_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Apple New Disk Image Format.
-        /// </summary>
-        internal static string Ndif_Name {
+        internal static string Parent_images_are_not_supported {
             get {
-                return ResourceManager.GetString("Ndif_Name", resourceCulture);
+                return ResourceManager.GetString("Parent_images_are_not_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Nero image contains a disc of type {0}.
-        /// </summary>
-        internal static string Nero_image_contains_a_disc_of_type_0 {
+        internal static string FLAC_is_not_supported {
             get {
-                return ResourceManager.GetString("Nero_image_contains_a_disc_of_type_0", resourceCulture);
+                return ResourceManager.GetString("FLAC_is_not_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Nero Burning ROM image.
-        /// </summary>
-        internal static string Nero_Name {
+        internal static string Hunk_type_0_is_not_supported {
             get {
-                return ResourceManager.GetString("Nero_Name", resourceCulture);
+                return ResourceManager.GetString("Hunk_type_0_is_not_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Nero version not recognized..
-        /// </summary>
-        internal static string Nero_version_not_recognized {
+        internal static string Compressed_v5_hunks_not_yet_supported {
             get {
-                return ResourceManager.GetString("Nero_version_not_recognized", resourceCulture);
+                return ResourceManager.GetString("Compressed_v5_hunks_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to iNES.
-        /// </summary>
-        internal static string Nes_Name {
+        internal static string Unsupported_hunk_map_version_0 {
             get {
-                return ResourceManager.GetString("Nes_Name", resourceCulture);
+                return ResourceManager.GetString("Unsupported_hunk_map_version_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Netherlands.
-        /// </summary>
-        internal static string Netherlands {
+        internal static string Chd_Name {
             get {
-                return ResourceManager.GetString("Netherlands", resourceCulture);
+                return ResourceManager.GetString("Chd_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to T98-Next NHD r0 Disk Image.
-        /// </summary>
-        internal static string Nhdr0_Name {
+        internal static string Reading_Hunk_map {
             get {
-                return ResourceManager.GetString("Nhdr0_Name", resourceCulture);
+                return ResourceManager.GetString("Reading_Hunk_map", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Nintendo 64.
-        /// </summary>
-        internal static string Nintendo64_Name {
+        internal static string Took_0_seconds {
             get {
-                return ResourceManager.GetString("Nintendo64_Name", resourceCulture);
+                return ResourceManager.GetString("Took_0_seconds", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to No cylinders or heads found.
-        /// </summary>
-        internal static string No_cylinders_or_heads_found {
+        internal static string CHD_version_5_is_not_yet_supported {
             get {
-                return ResourceManager.GetString("No_cylinders_or_heads_found", resourceCulture);
+                return ResourceManager.GetString("CHD_version_5_is_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to No image has been opened..
-        /// </summary>
-        internal static string No_image_has_been_opened {
+        internal static string Cannot_read_compressed_CHD_version_5 {
             get {
-                return ResourceManager.GetString("No_image_has_been_opened", resourceCulture);
+                return ResourceManager.GetString("Cannot_read_compressed_CHD_version_5", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to No tracks found.
-        /// </summary>
-        internal static string No_tracks_found {
+        internal static string Unsupported_CHD_version_0 {
             get {
-                return ResourceManager.GetString("No_tracks_found", resourceCulture);
+                return ResourceManager.GetString("Unsupported_CHD_version_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to None.
-        /// </summary>
-        internal static string None_coprocessor {
+        internal static string Reading_metadata {
             get {
-                return ResourceManager.GetString("None_coprocessor", resourceCulture);
+                return ResourceManager.GetString("Reading_metadata", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to none.
-        /// </summary>
-        internal static string none_licensee {
+        internal static string Found_metadata_0_ {
             get {
-                return ResourceManager.GetString("none_licensee", resourceCulture);
+                return ResourceManager.GetString("Found_metadata_0_", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to North America.
-        /// </summary>
-        internal static string North_America {
+        internal static string Image_cannot_be_a_hard_disk_and_a_CGD_ROM_at_the_same_time_aborting {
             get {
-                return ResourceManager.GetString("North_America", resourceCulture);
+                return ResourceManager.GetString("Image_cannot_be_a_hard_disk_and_a_CGD_ROM_at_the_same_time_aborting", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Not a CDRDAO TOC or TOC type not in line {0}..
-        /// </summary>
-        internal static string Not_a_CDRDAO_TOC_or_TOC_type_not_in_line_0 {
+        internal static string Image_cannot_be_a_hard_disk_and_a_CD_ROM_at_the_same_time_aborting {
             get {
-                return ResourceManager.GetString("Not_a_CDRDAO_TOC_or_TOC_type_not_in_line_0", resourceCulture);
+                return ResourceManager.GetString("Image_cannot_be_a_hard_disk_and_a_CD_ROM_at_the_same_time_aborting", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Not a correct Dreamcast GDI image.
-        /// </summary>
-        internal static string Not_a_correct_Dreamcast_GDI_image {
+        internal static string Image_cannot_be_a_GD_ROM_and_a_CD_ROM_at_the_same_time_aborting {
             get {
-                return ResourceManager.GetString("Not_a_correct_Dreamcast_GDI_image", resourceCulture);
+                return ResourceManager.GetString("Image_cannot_be_a_GD_ROM_and_a_CD_ROM_at_the_same_time_aborting", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Not a descriptor..
-        /// </summary>
-        internal static string Not_a_descriptor {
+        internal static string Unsupported_track_type_0 {
             get {
-                return ResourceManager.GetString("Not_a_descriptor", resourceCulture);
+                return ResourceManager.GetString("Unsupported_track_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Not the expected track info..
-        /// </summary>
-        internal static string Not_the_expected_track_info {
+        internal static string Unsorted_tracks_cannot_proceed {
             get {
-                return ResourceManager.GetString("Not_the_expected_track_info", resourceCulture);
+                return ResourceManager.GetString("Unsorted_tracks_cannot_proceed", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Of {0} sectors written, {1} are unique ({2:P}).
-        /// </summary>
-        internal static string Of_0_sectors_written_1_are_unique_2 {
+        internal static string Image_cannot_be_a_hard_disk_and_a_GD_ROM_at_the_same_time_aborting {
             get {
-                return ResourceManager.GetString("Of_0_sectors_written_1_are_unique_2", resourceCulture);
+                return ResourceManager.GetString("Image_cannot_be_a_hard_disk_and_a_GD_ROM_at_the_same_time_aborting", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Optical disc track.
-        /// </summary>
-        internal static string Optical_disc_track {
+        internal static string Image_cannot_be_a_CD_ROM_and_a_GD_ROM_at_the_same_time_aborting {
             get {
-                return ResourceManager.GetString("Optical_disc_track", resourceCulture);
+                return ResourceManager.GetString("Image_cannot_be_a_CD_ROM_and_a_GD_ROM_at_the_same_time_aborting", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Other.
-        /// </summary>
-        internal static string Other_coprocessor {
+        internal static string Image_does_not_represent_a_known_media_aborting {
             get {
-                return ResourceManager.GetString("Other_coprocessor", resourceCulture);
+                return ResourceManager.GetString("Image_does_not_represent_a_known_media_aborting", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Overseas title: {0}.
-        /// </summary>
-        internal static string Overseas_title_0 {
+        internal static string CisCopy_Name {
             get {
-                return ResourceManager.GetString("Overseas_title_0", resourceCulture);
+                return ResourceManager.GetString("CisCopy_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Parallels disk image.
-        /// </summary>
-        internal static string Parallels_Name {
+        internal static string Incorrect_disk_type_0 {
             get {
-                return ResourceManager.GetString("Parallels_Name", resourceCulture);
+                return ResourceManager.GetString("Incorrect_disk_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Parent images are not supported.
-        /// </summary>
-        internal static string Parent_images_are_not_supported {
+        internal static string Compressed_images_are_not_supported {
             get {
-                return ResourceManager.GetString("Parent_images_are_not_supported", resourceCulture);
+                return ResourceManager.GetString("Compressed_images_are_not_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Parent locator not found..
-        /// </summary>
-        internal static string Parent_locator_not_found {
+        internal static string CisCopy_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("Parent_locator_not_found", resourceCulture);
+                return ResourceManager.GetString("CisCopy_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Parsing image.
-        /// </summary>
-        internal static string Parsing_image {
+        internal static string CloneCd_Name {
             get {
-                return ResourceManager.GetString("Parsing_image", resourceCulture);
+                return ResourceManager.GetString("CloneCd_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Parsing property list..
-        /// </summary>
-        internal static string Parsing_property_list {
+        internal static string Found_CloneCD_out_of_order_in_line_0 {
             get {
-                return ResourceManager.GetString("Parsing_property_list", resourceCulture);
+                return ResourceManager.GetString("Found_CloneCD_out_of_order_in_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to PartClone disk image.
-        /// </summary>
-        internal static string PartClone_Name {
+        internal static string Found_Version_at_line_0 {
             get {
-                return ResourceManager.GetString("PartClone_Name", resourceCulture);
+                return ResourceManager.GetString("Found_Version_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Partimage disk image.
-        /// </summary>
-        internal static string Partimage_Name {
+        internal static string CloneCD_plugin_Warning_Unknown_CCD_image_version_0_may_not_work {
             get {
-                return ResourceManager.GetString("Partimage_Name", resourceCulture);
+                return ResourceManager.GetString("CloneCD_plugin_Warning_Unknown_CCD_image_version_0_may_not_work", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Partition description: {0}.
-        /// </summary>
-        internal static string Partition_description_0 {
+        internal static string Found_TocEntries_at_line_0 {
             get {
-                return ResourceManager.GetString("Partition_description_0", resourceCulture);
+                return ResourceManager.GetString("Found_TocEntries_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Partition ending sector: {0}.
-        /// </summary>
-        internal static string Partition_ending_sector_0 {
+        internal static string Found_Sessions_at_line_0 {
             get {
-                return ResourceManager.GetString("Partition_ending_sector_0", resourceCulture);
+                return ResourceManager.GetString("Found_Sessions_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Partition name: {0}.
-        /// </summary>
-        internal static string Partition_name_0 {
+        internal static string Found_DataTracksScrambled_at_line_0 {
             get {
-                return ResourceManager.GetString("Partition_name_0", resourceCulture);
+                return ResourceManager.GetString("Found_DataTracksScrambled_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Partition sectors: {0}.
-        /// </summary>
-        internal static string Partition_sectors_0 {
+        internal static string Found_CDTextLength_at_line_0 {
             get {
-                return ResourceManager.GetString("Partition_sectors_0", resourceCulture);
+                return ResourceManager.GetString("Found_CDTextLength_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Partition sequence: {0}.
-        /// </summary>
-        internal static string Partition_sequence_0 {
+        internal static string Found_Catalog_at_line_0_smallcase {
             get {
-                return ResourceManager.GetString("Partition_sequence_0", resourceCulture);
+                return ResourceManager.GetString("Found_Catalog_at_line_0_smallcase", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Partition size in bytes: {0}.
-        /// </summary>
-        internal static string Partition_size_in_bytes_0 {
+        internal static string Found_CD_Text_Entries_at_line_0 {
             get {
-                return ResourceManager.GetString("Partition_size_in_bytes_0", resourceCulture);
+                return ResourceManager.GetString("Found_CD_Text_Entries_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Partition starting offset: {0}.
-        /// </summary>
-        internal static string Partition_starting_offset_0 {
+        internal static string Found_CD_Text_Entry_at_line_0 {
             get {
-                return ResourceManager.GetString("Partition_starting_offset_0", resourceCulture);
+                return ResourceManager.GetString("Found_CD_Text_Entry_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Partition starting sector: {0}.
-        /// </summary>
-        internal static string Partition_starting_sector_0 {
+        internal static string Found_PreGapMode_at_line_0 {
             get {
-                return ResourceManager.GetString("Partition_starting_sector_0", resourceCulture);
+                return ResourceManager.GetString("Found_PreGapMode_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Partition type: {0}.
-        /// </summary>
-        internal static string Partition_type_0 {
+        internal static string Found_PreGapSubC_at_line_0 {
             get {
-                return ResourceManager.GetString("Partition_type_0", resourceCulture);
+                return ResourceManager.GetString("Found_PreGapSubC_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Performer: {0}.
-        /// </summary>
-        internal static string Performer_0 {
+        internal static string Found_Session_at_line_0 {
             get {
-                return ResourceManager.GetString("Performer_0", resourceCulture);
+                return ResourceManager.GetString("Found_Session_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Performer is not set..
-        /// </summary>
-        internal static string Performer_is_not_set {
+        internal static string Found_Point_at_line_0 {
             get {
-                return ResourceManager.GetString("Performer_is_not_set", resourceCulture);
+                return ResourceManager.GetString("Found_Point_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to PFI: {0}.
-        /// </summary>
-        internal static string PFI_0 {
+        internal static string Found_ADR_at_line_0 {
             get {
-                return ResourceManager.GetString("PFI_0", resourceCulture);
+                return ResourceManager.GetString("Found_ADR_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Physical sector size not found..
-        /// </summary>
-        internal static string Physical_sector_size_not_found {
+        internal static string Found_Control_at_line_0 {
             get {
-                return ResourceManager.GetString("Physical_sector_size_not_found", resourceCulture);
+                return ResourceManager.GetString("Found_Control_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to PlayChoice-10 game.
-        /// </summary>
-        internal static string PlayChoice_10_game {
+        internal static string Found_TrackNo_at_line_0 {
             get {
-                return ResourceManager.GetString("PlayChoice_10_game", resourceCulture);
+                return ResourceManager.GetString("Found_TrackNo_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Please open VMDK descriptor..
-        /// </summary>
-        internal static string Please_open_VMDK_descriptor {
+        internal static string Found_AMin_at_line_0 {
             get {
-                return ResourceManager.GetString("Please_open_VMDK_descriptor", resourceCulture);
+                return ResourceManager.GetString("Found_AMin_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to PMA: {0}.
-        /// </summary>
-        internal static string PMA_0 {
+        internal static string Found_ASec_at_line_0 {
             get {
-                return ResourceManager.GetString("PMA_0", resourceCulture);
+                return ResourceManager.GetString("Found_ASec_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Pocket Camera.
-        /// </summary>
-        internal static string Pocket_Camera {
+        internal static string Found_AFrame_at_line_0 {
             get {
-                return ResourceManager.GetString("Pocket_Camera", resourceCulture);
+                return ResourceManager.GetString("Found_AFrame_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Possible parent path: &quot;{0}&quot;.
-        /// </summary>
-        internal static string Possible_parent_path_0 {
+        internal static string Found_ALBA_at_line_0 {
             get {
-                return ResourceManager.GetString("Possible_parent_path_0", resourceCulture);
+                return ResourceManager.GetString("Found_ALBA_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Postgap: {0} sectors.
-        /// </summary>
-        internal static string Postgap_0_sectors {
+        internal static string Found_Zero_at_line_0 {
             get {
-                return ResourceManager.GetString("Postgap_0_sectors", resourceCulture);
+                return ResourceManager.GetString("Found_Zero_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Pregap: {0} sectors.
-        /// </summary>
-        internal static string Pregap_0_sectors {
+        internal static string Found_PMin_at_line_0 {
             get {
-                return ResourceManager.GetString("Pregap_0_sectors", resourceCulture);
+                return ResourceManager.GetString("Found_PMin_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to PRG ROM size: {0} bytes.
-        /// </summary>
-        internal static string PRG_ROM_size_0_bytes {
+        internal static string Found_PSec_at_line_0 {
             get {
-                return ResourceManager.GetString("PRG_ROM_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Found_PSec_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to printing partition map.
-        /// </summary>
-        internal static string printing_partition_map {
+        internal static string Found_PFrame_at_line_0 {
             get {
-                return ResourceManager.GetString("printing_partition_map", resourceCulture);
+                return ResourceManager.GetString("Found_PFrame_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to printing track map.
-        /// </summary>
-        internal static string printing_track_map {
+        internal static string Found_PLBA_at_line_0 {
             get {
-                return ResourceManager.GetString("printing_track_map", resourceCulture);
+                return ResourceManager.GetString("Found_PLBA_at_line_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Product code: {0}.
-        /// </summary>
-        internal static string Product_code_0 {
+        internal static string Did_not_find_any_track {
             get {
-                return ResourceManager.GetString("Product_code_0", resourceCulture);
+                return ResourceManager.GetString("Did_not_find_any_track", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Product code: AGB-{0}.
-        /// </summary>
-        internal static string Product_code_AGB_0 {
+        internal static string Disc_Type_0 {
             get {
-                return ResourceManager.GetString("Product_code_AGB_0", resourceCulture);
+                return ResourceManager.GetString("Disc_Type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to PROM size: 0x{0} bytes.
-        /// </summary>
-        internal static string PROM_size_0_bytes {
+        internal static string Disc_manufactured_by_0 {
             get {
-                return ResourceManager.GetString("PROM_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Disc_manufactured_by_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to QEMU Copy-On-Write disk image.
-        /// </summary>
-        internal static string Qcow_Name {
+        internal static string Disc_ID_0_X6 {
             get {
-                return ResourceManager.GetString("Qcow_Name", resourceCulture);
+                return ResourceManager.GetString("Disc_ID_0_X6", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to QEMU Copy-On-Write disk image v2.
-        /// </summary>
-        internal static string Qcow2_Name {
+        internal static string This_format_requires_sectors_to_be_raw_Generating_ECC_is_not_yet_implemented {
             get {
-                return ResourceManager.GetString("Qcow2_Name", resourceCulture);
+                return ResourceManager.GetString("This_format_requires_sectors_to_be_raw_Generating_ECC_is_not_yet_implemented", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to QEMU Enhanced Disk image.
-        /// </summary>
-        internal static string Qed_Name {
+        internal static string Unexpected_first_session_track_type_0 {
             get {
-                return ResourceManager.GetString("Qed_Name", resourceCulture);
+                return ResourceManager.GetString("Unexpected_first_session_track_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to RAM size: {0} bytes.
-        /// </summary>
-        internal static string RAM_size_0_bytes {
+        internal static string Could_not_create_subchannel_file_exception_0 {
             get {
-                return ResourceManager.GetString("RAM_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Could_not_create_subchannel_file_exception_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to RAM starts at 0x{0:X8} and ends at 0x{1:X8} ({2} bytes).
-        /// </summary>
-        internal static string RAM_starts_at_0_and_ends_at_1_2_bytes {
+        internal static string CopyQm_Name {
             get {
-                return ResourceManager.GetString("RAM_starts_at_0_and_ends_at_1_2_bytes", resourceCulture);
+                return ResourceManager.GetString("CopyQm_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Raw device image files are not supported, try accessing the device directly..
-        /// </summary>
-        internal static string Raw_device_image_files_are_not_supported {
+        internal static string Calculated_header_checksum_equals_0_X2_1 {
             get {
-                return ResourceManager.GetString("Raw_device_image_files_are_not_supported", resourceCulture);
+                return ResourceManager.GetString("Calculated_header_checksum_equals_0_X2_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Raw disk image contains a disk of type {0}.
-        /// </summary>
-        internal static string Raw_disk_image_contains_a_disk_of_type_0 {
+        internal static string Calculated_data_CRC_equals_0_X8_1 {
             get {
-                return ResourceManager.GetString("Raw_disk_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Calculated_data_CRC_equals_0_X8_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Read {0} sectors.
-        /// </summary>
-        internal static string Read_0_sectors {
+        internal static string CopyQM_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("Read_0_sectors", resourceCulture);
+                return ResourceManager.GetString("CopyQM_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Read {0} tracks.
-        /// </summary>
-        internal static string Read_0_tracks {
+        internal static string CopyQM_comments_0 {
             get {
-                return ResourceManager.GetString("Read_0_tracks", resourceCulture);
+                return ResourceManager.GetString("CopyQM_comments_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to reading bad sector {0} ({1},{2},{3}).
-        /// </summary>
-        internal static string reading_bad_sector_0_1_2_3 {
+        internal static string CopyTape_Name {
             get {
-                return ResourceManager.GetString("reading_bad_sector_0_1_2_3", resourceCulture);
+                return ResourceManager.GetString("CopyTape_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading BAT.
-        /// </summary>
-        internal static string Reading_BAT {
+        internal static string Found_unhandled_header_cannot_open {
             get {
-                return ResourceManager.GetString("Reading_BAT", resourceCulture);
+                return ResourceManager.GetString("Found_unhandled_header_cannot_open", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading bytemap {0} bytes.
-        /// </summary>
-        internal static string Reading_bytemap_0_bytes {
+        internal static string Cannot_decode_block_header_cannot_open {
             get {
-                return ResourceManager.GetString("Reading_bytemap_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Cannot_decode_block_header_cannot_open", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading data.
-        /// </summary>
-        internal static string Reading_data {
+        internal static string Cannot_write_unwritten_blocks {
             get {
-                return ResourceManager.GetString("Reading_data", resourceCulture);
+                return ResourceManager.GetString("Cannot_write_unwritten_blocks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading grain directory.
-        /// </summary>
-        internal static string Reading_grain_directory {
+        internal static string Cannot_skip_blocks {
             get {
-                return ResourceManager.GetString("Reading_grain_directory", resourceCulture);
+                return ResourceManager.GetString("Cannot_skip_blocks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading grain tables.
-        /// </summary>
-        internal static string Reading_grain_tables {
+        internal static string magic_equals_0_quoted {
             get {
-                return ResourceManager.GetString("Reading_grain_tables", resourceCulture);
+                return ResourceManager.GetString("magic_equals_0_quoted", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading Hunk map..
-        /// </summary>
-        internal static string Reading_Hunk_map {
+        internal static string Cpcdsk_Name {
             get {
-                return ResourceManager.GetString("Reading_Hunk_map", resourceCulture);
+                return ResourceManager.GetString("Cpcdsk_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading Image Block Map.
-        /// </summary>
-        internal static string Reading_Image_Block_Map {
+        internal static string Extended_equals_0 {
             get {
-                return ResourceManager.GetString("Reading_Image_Block_Map", resourceCulture);
+                return ResourceManager.GetString("Extended_equals_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading Image Block Map took {0} ms.
-        /// </summary>
-        internal static string Reading_Image_Block_Map_took_0_ms {
+        internal static string Track_0_Side_1_size_equals_2 {
             get {
-                return ResourceManager.GetString("Reading_Image_Block_Map_took_0_ms", resourceCulture);
+                return ResourceManager.GetString("Track_0_Side_1_size_equals_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading L1 table.
-        /// </summary>
-        internal static string Reading_L1_table {
+        internal static string Not_the_expected_track_info {
             get {
-                return ResourceManager.GetString("Reading_L1_table", resourceCulture);
+                return ResourceManager.GetString("Not_the_expected_track_info", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading L2 table #{0}.
-        /// </summary>
-        internal static string Reading_L2_table_0 {
+        internal static string Read_0_sectors {
             get {
-                return ResourceManager.GetString("Reading_L2_table_0", resourceCulture);
+                return ResourceManager.GetString("Read_0_sectors", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading metadata..
-        /// </summary>
-        internal static string Reading_metadata {
+        internal static string Read_0_tracks {
             get {
-                return ResourceManager.GetString("Reading_metadata", resourceCulture);
+                return ResourceManager.GetString("Read_0_tracks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading property list..
-        /// </summary>
-        internal static string Reading_property_list {
+        internal static string All_tracks_are_same_size_0 {
             get {
-                return ResourceManager.GetString("Reading_property_list", resourceCulture);
+                return ResourceManager.GetString("All_tracks_are_same_size_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading resource fork..
-        /// </summary>
-        internal static string Reading_resource_fork {
+        internal static string _0_tracks {
             get {
-                return ResourceManager.GetString("Reading_resource_fork", resourceCulture);
+                return ResourceManager.GetString("_0_tracks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading Sector Bitmap.
-        /// </summary>
-        internal static string Reading_Sector_Bitmap {
+        internal static string D88_Name {
             get {
-                return ResourceManager.GetString("Reading_Sector_Bitmap", resourceCulture);
+                return ResourceManager.GetString("D88_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Reading tags.
-        /// </summary>
-        internal static string Reading_tags {
+        internal static string Disk_tracks_are_not_same_size {
             get {
-                return ResourceManager.GetString("Reading_tags", resourceCulture);
+                return ResourceManager.GetString("Disk_tracks_are_not_same_size", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Rebuilding TOC.
-        /// </summary>
-        internal static string Rebuilding_TOC {
+        internal static string _0_sectors {
             get {
-                return ResourceManager.GetString("Rebuilding_TOC", resourceCulture);
+                return ResourceManager.GetString("_0_sectors", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Region: {0}.
-        /// </summary>
-        internal static string Region_0 {
+        internal static string Dart_Name {
             get {
-                return ResourceManager.GetString("Region_0", resourceCulture);
+                return ResourceManager.GetString("Dart_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Region support: {0}.
-        /// </summary>
-        internal static string Region_support_0 {
+        internal static string LZH_Compressed_images_not_yet_supported {
             get {
-                return ResourceManager.GetString("Region_support_0", resourceCulture);
+                return ResourceManager.GetString("LZH_Compressed_images_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Requires Game Boy Color.
-        /// </summary>
-        internal static string Requires_Game_Boy_Color {
+        internal static string Image_application_0_version_1 {
             get {
-                return ResourceManager.GetString("Requires_Game_Boy_Color", resourceCulture);
+                return ResourceManager.GetString("Image_application_0_version_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Revision: {0}.
-        /// </summary>
-        internal static string Revision_0 {
+        internal static string Dim_Name {
             get {
-                return ResourceManager.GetString("Revision_0", resourceCulture);
+                return ResourceManager.GetString("Dim_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (RLE decoder): Input data size: {0} bytes.
-        /// </summary>
-        internal static string RLE_decoder_Input_data_size_0_bytes {
+        internal static string DIM_shows_unknown_image_with_0_tracks {
             get {
-                return ResourceManager.GetString("RLE_decoder_Input_data_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("DIM_shows_unknown_image_with_0_tracks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (RLE decoder): Output data size: {0} bytes.
-        /// </summary>
-        internal static string RLE_decoder_Output_data_size_0_bytes {
+        internal static string DIM_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("RLE_decoder_Output_data_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("DIM_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (RLE decoder): Processed input: {0} bytes.
-        /// </summary>
-        internal static string RLE_decoder_Processed_input_0_bytes {
+        internal static string DIM_comments_0 {
             get {
-                return ResourceManager.GetString("RLE_decoder_Processed_input_0_bytes", resourceCulture);
+                return ResourceManager.GetString("DIM_comments_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (RLE decoder): Processed Output: {0} bytes.
-        /// </summary>
-        internal static string RLE_decoder_Processed_Output_0_bytes {
+        internal static string DiscFerret_Name {
             get {
-                return ResourceManager.GetString("RLE_decoder_Processed_Output_0_bytes", resourceCulture);
+                return ResourceManager.GetString("DiscFerret_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM.
-        /// </summary>
-        internal static string ROM {
+        internal static string Invalid_track_block_found_at_0 {
             get {
-                return ResourceManager.GetString("ROM", resourceCulture);
+                return ResourceManager.GetString("Invalid_track_block_found_at_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and coprocessor.
-        /// </summary>
-        internal static string ROM_and_coprocessor {
+        internal static string Flux_decoding_is_not_yet_implemented {
             get {
-                return ResourceManager.GetString("ROM_and_coprocessor", resourceCulture);
+                return ResourceManager.GetString("Flux_decoding_is_not_yet_implemented", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and HuC-1.
-        /// </summary>
-        internal static string ROM_and_HuC_1 {
+        internal static string DiscJuggler_Name {
             get {
-                return ResourceManager.GetString("ROM_and_HuC_1", resourceCulture);
+                return ResourceManager.GetString("DiscJuggler_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and HuC-3.
-        /// </summary>
-        internal static string ROM_and_HuC_3 {
+        internal static string Track_title_0 {
             get {
-                return ResourceManager.GetString("ROM_and_HuC_3", resourceCulture);
+                return ResourceManager.GetString("Track_title_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and MBC1.
-        /// </summary>
-        internal static string ROM_and_MBC1 {
+        internal static string Unknown_read_mode_0 {
             get {
-                return ResourceManager.GetString("ROM_and_MBC1", resourceCulture);
+                return ResourceManager.GetString("Unknown_read_mode_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and MBC2.
-        /// </summary>
-        internal static string ROM_and_MBC2 {
+        internal static string Invalid_read_mode_0_for_this_track {
             get {
-                return ResourceManager.GetString("ROM_and_MBC2", resourceCulture);
+                return ResourceManager.GetString("Invalid_read_mode_0_for_this_track", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and MBC3.
-        /// </summary>
-        internal static string ROM_and_MBC3 {
+        internal static string Unknown_track_mode_0 {
             get {
-                return ResourceManager.GetString("ROM_and_MBC3", resourceCulture);
+                return ResourceManager.GetString("Unknown_track_mode_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and MBC5.
-        /// </summary>
-        internal static string ROM_and_MBC5 {
+        internal static string Current_position_equals_0 {
             get {
-                return ResourceManager.GetString("ROM_and_MBC5", resourceCulture);
+                return ResourceManager.GetString("Current_position_equals_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and MBC6.
-        /// </summary>
-        internal static string ROM_and_MBC6 {
+        internal static string End_position_equals_0 {
             get {
-                return ResourceManager.GetString("ROM_and_MBC6", resourceCulture);
+                return ResourceManager.GetString("End_position_equals_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and MMM01.
-        /// </summary>
-        internal static string ROM_and_MMM01 {
+        internal static string Unknown_tmp_header_format_equals_0_value {
             get {
-                return ResourceManager.GetString("ROM_and_MMM01", resourceCulture);
+                return ResourceManager.GetString("Unknown_tmp_header_format_equals_0_value", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and RAM.
-        /// </summary>
-        internal static string ROM_and_RAM {
+        internal static string Unknown_tmp_header_fmtByte_equals_0_value {
             get {
-                return ResourceManager.GetString("ROM_and_RAM", resourceCulture);
+                return ResourceManager.GetString("Unknown_tmp_header_fmtByte_equals_0_value", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM and TAMA5.
-        /// </summary>
-        internal static string ROM_and_TAMA5 {
+        internal static string Image_says_its_unformatted {
             get {
-                return ResourceManager.GetString("ROM_and_TAMA5", resourceCulture);
+                return ResourceManager.GetString("Image_says_its_unformatted", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, battery and coprocessor.
-        /// </summary>
-        internal static string ROM_battery_and_coprocessor {
+        internal static string DiskCopy42_Name {
             get {
-                return ResourceManager.GetString("ROM_battery_and_coprocessor", resourceCulture);
+                return ResourceManager.GetString("DiskCopy42_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC1 and RAM.
-        /// </summary>
-        internal static string ROM_MBC1_and_RAM {
+        internal static string Use_Mac_OS_X_format_byte {
             get {
-                return ResourceManager.GetString("ROM_MBC1_and_RAM", resourceCulture);
+                return ResourceManager.GetString("Use_Mac_OS_X_format_byte", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC1, RAM and battery.
-        /// </summary>
-        internal static string ROM_MBC1_RAM_and_battery {
+        internal static string Unknown_header_format_equals_0_value {
             get {
-                return ResourceManager.GetString("ROM_MBC1_RAM_and_battery", resourceCulture);
+                return ResourceManager.GetString("Unknown_header_format_equals_0_value", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC2 and battery.
-        /// </summary>
-        internal static string ROM_MBC2_and_battery {
+        internal static string Unknown_tag_size {
             get {
-                return ResourceManager.GetString("ROM_MBC2_and_battery", resourceCulture);
+                return ResourceManager.GetString("Unknown_tag_size", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC3 and RAM.
-        /// </summary>
-        internal static string ROM_MBC3_and_RAM {
+        internal static string Macintosh_Twiggy_detected_reversing_disk_sides {
             get {
-                return ResourceManager.GetString("ROM_MBC3_and_RAM", resourceCulture);
+                return ResourceManager.GetString("Macintosh_Twiggy_detected_reversing_disk_sides", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC3, RAM and battery.
-        /// </summary>
-        internal static string ROM_MBC3_RAM_and_battery {
+        internal static string Lisa_Twiggy_detected_reversing_second_half_of_disk {
             get {
-                return ResourceManager.GetString("ROM_MBC3_RAM_and_battery", resourceCulture);
+                return ResourceManager.GetString("Lisa_Twiggy_detected_reversing_second_half_of_disk", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC3, RAM, timer and battery.
-        /// </summary>
-        internal static string ROM_MBC3_RAM_timer_and_battery {
+        internal static string DiskCopy_4_2_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("ROM_MBC3_RAM_timer_and_battery", resourceCulture);
+                return ResourceManager.GetString("DiskCopy_4_2_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC3, timer and battery.
-        /// </summary>
-        internal static string ROM_MBC3_timer_and_battery {
+        internal static string Reading_data {
             get {
-                return ResourceManager.GetString("ROM_MBC3_timer_and_battery", resourceCulture);
+                return ResourceManager.GetString("Reading_data", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC5 and RAM.
-        /// </summary>
-        internal static string ROM_MBC5_and_RAM {
+        internal static string Calculating_data_checksum {
             get {
-                return ResourceManager.GetString("ROM_MBC5_and_RAM", resourceCulture);
+                return ResourceManager.GetString("Calculating_data_checksum", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC5 and vibration motor.
-        /// </summary>
-        internal static string ROM_MBC5_and_vibration_motor {
+        internal static string Calculated_data_checksum_equals_0_X8 {
             get {
-                return ResourceManager.GetString("ROM_MBC5_and_vibration_motor", resourceCulture);
+                return ResourceManager.GetString("Calculated_data_checksum_equals_0_X8", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC5, RAM and battery.
-        /// </summary>
-        internal static string ROM_MBC5_RAM_and_battery {
+        internal static string Stored_data_checksum_equals_0_X8 {
             get {
-                return ResourceManager.GetString("ROM_MBC5_RAM_and_battery", resourceCulture);
+                return ResourceManager.GetString("Stored_data_checksum_equals_0_X8", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC5, RAM and vibration motor.
-        /// </summary>
-        internal static string ROM_MBC5_RAM_and_vibration_motor {
+        internal static string Reading_tags {
             get {
-                return ResourceManager.GetString("ROM_MBC5_RAM_and_vibration_motor", resourceCulture);
+                return ResourceManager.GetString("Reading_tags", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC5, RAM, battery and vibration motor.
-        /// </summary>
-        internal static string ROM_MBC5_RAM_battery_and_vibration_motor {
+        internal static string Calculating_tag_checksum {
             get {
-                return ResourceManager.GetString("ROM_MBC5_RAM_battery_and_vibration_motor", resourceCulture);
+                return ResourceManager.GetString("Calculating_tag_checksum", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MBC7, RAM, battery, light sensor and vibration motor.
-        /// </summary>
-        internal static string ROM_MBC7_RAM_battery_light_sensor_and_vibration_motor {
+        internal static string Calculated_tag_checksum_equals_0_X8 {
             get {
-                return ResourceManager.GetString("ROM_MBC7_RAM_battery_light_sensor_and_vibration_motor", resourceCulture);
+                return ResourceManager.GetString("Calculated_tag_checksum_equals_0_X8", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MMM01 and RAM.
-        /// </summary>
-        internal static string ROM_MMM01_and_RAM {
+        internal static string Stored_tag_checksum_equals_0_X8 {
             get {
-                return ResourceManager.GetString("ROM_MMM01_and_RAM", resourceCulture);
+                return ResourceManager.GetString("Stored_tag_checksum_equals_0_X8", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, MMM01, RAM and battery.
-        /// </summary>
-        internal static string ROM_MMM01_RAM_and_battery {
+        internal static string Twiggy_write_support_not_yet_implemented {
             get {
-                return ResourceManager.GetString("ROM_MMM01_RAM_and_battery", resourceCulture);
+                return ResourceManager.GetString("Twiggy_write_support_not_yet_implemented", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM only.
-        /// </summary>
-        internal static string ROM_only {
+        internal static string Incorrect_number_of_sectors_for_Apple_HD20_image {
             get {
-                return ResourceManager.GetString("ROM_only", resourceCulture);
+                return ResourceManager.GetString("Incorrect_number_of_sectors_for_Apple_HD20_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, RAM and battery.
-        /// </summary>
-        internal static string ROM_RAM_and_battery {
+        internal static string Incorrect_number_of_sectors_for_Apple_Profile_image {
             get {
-                return ResourceManager.GetString("ROM_RAM_and_battery", resourceCulture);
+                return ResourceManager.GetString("Incorrect_number_of_sectors_for_Apple_Profile_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, RAM and coprocessor.
-        /// </summary>
-        internal static string ROM_RAM_and_coprocessor {
+        internal static string Incorrect_number_of_sectors_for_Apple_MF2DD_image {
             get {
-                return ResourceManager.GetString("ROM_RAM_and_coprocessor", resourceCulture);
+                return ResourceManager.GetString("Incorrect_number_of_sectors_for_Apple_MF2DD_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, RAM, battery and coprocessor.
-        /// </summary>
-        internal static string ROM_RAM_battery_and_coprocessor {
+        internal static string Incorrect_number_of_sectors_for_Apple_MF1DD_image {
             get {
-                return ResourceManager.GetString("ROM_RAM_battery_and_coprocessor", resourceCulture);
+                return ResourceManager.GetString("Incorrect_number_of_sectors_for_Apple_MF1DD_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM, RAM, battery, coprocessor and RTC.
-        /// </summary>
-        internal static string ROM_RAM_battery_coprocessor_and_RTC {
+        internal static string Incorrect_number_of_sectors_for_Apple_Widget_image {
             get {
-                return ResourceManager.GetString("ROM_RAM_battery_coprocessor_and_RTC", resourceCulture);
+                return ResourceManager.GetString("Incorrect_number_of_sectors_for_Apple_Widget_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM size: {0} bytes.
-        /// </summary>
-        internal static string ROM_size_0_bytes {
+        internal static string Incorrect_number_of_sectors_for_MF2DD_image {
             get {
-                return ResourceManager.GetString("ROM_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Incorrect_number_of_sectors_for_MF2DD_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM speed: {0}.
-        /// </summary>
-        internal static string ROM_speed_0 {
+        internal static string Incorrect_number_of_sectors_for_MF2HD_image {
             get {
-                return ResourceManager.GetString("ROM_speed_0", resourceCulture);
+                return ResourceManager.GetString("Incorrect_number_of_sectors_for_MF2HD_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to ROM starts at 0x{0:X8} and ends at 0x{1:X8} ({2} bytes).
-        /// </summary>
-        internal static string ROM_starts_at_0_and_ends_at_1_2_bytes {
+        internal static string Incorrect_number_of_sectors_for_DMF_image {
             get {
-                return ResourceManager.GetString("ROM_starts_at_0_and_ends_at_1_2_bytes", resourceCulture);
+                return ResourceManager.GetString("Incorrect_number_of_sectors_for_DMF_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Rotation: {0}.
-        /// </summary>
-        internal static string Rotation_0 {
+        internal static string Identified_image_with_CHS_equals_0_1_2 {
             get {
-                return ResourceManager.GetString("Rotation_0", resourceCulture);
+                return ResourceManager.GetString("Identified_image_with_CHS_equals_0_1_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to RS-IDE Hard Disk Image.
-        /// </summary>
-        internal static string RsIde_Name {
+        internal static string DiskDupe_Name {
             get {
-                return ResourceManager.GetString("RsIde_Name", resourceCulture);
+                return ResourceManager.GetString("DiskDupe_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Save RAM size: {0} bytes.
-        /// </summary>
-        internal static string Save_RAM_size_0_bytes {
+        internal static string Detected_DiskDupe_DDI_image_with_0_tracks_and_1_sectors_per_track {
             get {
-                return ResourceManager.GetString("Save_RAM_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Detected_DiskDupe_DDI_image_with_0_tracks_and_1_sectors_per_track", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to SaveDskF comments: {0}.
-        /// </summary>
-        internal static string SaveDskF_comments_0 {
+        internal static string DriDiskCopy_Name {
             get {
-                return ResourceManager.GetString("SaveDskF_comments_0", resourceCulture);
+                return ResourceManager.GetString("DriDiskCopy_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to SaveDskF image contains a disk of type {0}.
-        /// </summary>
-        internal static string SaveDskF_image_contains_a_disk_of_type_0 {
+        internal static string Digital_Research_DiskCopy_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("SaveDskF_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Digital_Research_DiskCopy_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to IBM SaveDskF.
-        /// </summary>
-        internal static string SaveDskF_Name {
+        internal static string Gdi_Name {
             get {
-                return ResourceManager.GetString("SaveDskF_Name", resourceCulture);
+                return ResourceManager.GetString("Gdi_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Scandinavia.
-        /// </summary>
-        internal static string Scandinavia {
+        internal static string Not_a_correct_Dreamcast_GDI_image {
             get {
-                return ResourceManager.GetString("Scandinavia", resourceCulture);
+                return ResourceManager.GetString("Not_a_correct_Dreamcast_GDI_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sector {0}:{3}:{4} calculated CRC 0x{1:X2} differs from stored CRC 0x{2:X2}.
-        /// </summary>
-        internal static string Sector_0_3_4_calculated_CRC_1_X2_differs_from_stored_CRC_2_X2 {
+        internal static string Unknown_line_0_at_line_1 {
             get {
-                return ResourceManager.GetString("Sector_0_3_4_calculated_CRC_1_X2_differs_from_stored_CRC_2_X2", resourceCulture);
+                return ResourceManager.GetString("Unknown_line_0_at_line_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sector {0} on cylinder {1} head {2} is duplicate, and marked so.
-        /// </summary>
-        internal static string Sector_0_on_cylinder_1_head_2_is_duplicate_and_marked_so {
+        internal static string Found_track_0_starts_at_1_flags_2_type_3_file_4_offset_5_at_line_6 {
             get {
-                return ResourceManager.GetString("Sector_0_on_cylinder_1_head_2_is_duplicate_and_marked_so", resourceCulture);
+                return ResourceManager.GetString("Found_track_0_starts_at_1_flags_2_type_3_file_4_offset_5_at_line_6", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sector {0} on cylinder {1} head {2} is duplicate, but is not marked so.
-        /// </summary>
-        internal static string Sector_0_on_cylinder_1_head_2_is_duplicate_but_is_not_marked_so {
+        internal static string Track_size_not_a_multiple_of_sector_size {
             get {
-                return ResourceManager.GetString("Sector_0_on_cylinder_1_head_2_is_duplicate_but_is_not_marked_so", resourceCulture);
+                return ResourceManager.GetString("Track_size_not_a_multiple_of_sector_size", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sector address not found.
-        /// </summary>
-        internal static string Sector_address_not_found {
+        internal static string Track_is_data {
             get {
-                return ResourceManager.GetString("Sector_address_not_found", resourceCulture);
+                return ResourceManager.GetString("Track_is_data", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sector CRC (plus headers): 0x{0:X2}.
-        /// </summary>
-        internal static string Sector_CRC_plus_headers_0_X2 {
+        internal static string GDI_image_describes_a_disc_of_type_0 {
             get {
-                return ResourceManager.GetString("Sector_CRC_plus_headers_0_X2", resourceCulture);
+                return ResourceManager.GetString("GDI_image_describes_a_disc_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sector flags: 0x{0:X2}.
-        /// </summary>
-        internal static string Sector_flags_0_X2 {
+        internal static string Tried_reading_a_track_that_is_not_present_in_image {
             get {
-                return ResourceManager.GetString("Sector_flags_0_X2", resourceCulture);
+                return ResourceManager.GetString("Tried_reading_a_track_that_is_not_present_in_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sector follows.
-        /// </summary>
-        internal static string Sector_follows {
+        internal static string Track_decompression_yielded_incomplete_data {
             get {
-                return ResourceManager.GetString("Sector_follows", resourceCulture);
+                return ResourceManager.GetString("Track_decompression_yielded_incomplete_data", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sector size: {0}.
-        /// </summary>
-        internal static string Sector_size_0 {
+        internal static string HdCopy_Name {
             get {
-                return ResourceManager.GetString("Sector_size_0", resourceCulture);
+                return ResourceManager.GetString("HdCopy_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sector size {0} is incorrect..
-        /// </summary>
-        internal static string Sector_size_0_is_incorrect {
+        internal static string Detected_HD_Copy_image_with_0_tracks_and_1_sectors_per_track {
             get {
-                return ResourceManager.GetString("Sector_size_0_is_incorrect", resourceCulture);
+                return ResourceManager.GetString("Detected_HD_Copy_image_with_0_tracks_and_1_sectors_per_track", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sectors in track: {0}.
-        /// </summary>
-        internal static string Sectors_in_track_0 {
+        internal static string Track_0_offset_1_size_equals_2 {
             get {
-                return ResourceManager.GetString("Sectors_in_track_0", resourceCulture);
+                return ResourceManager.GetString("Track_0_offset_1_size_equals_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sega Mega Drive / 32X / Pico.
-        /// </summary>
-        internal static string SegaMegaDrive_Name {
+        internal static string Imd_Name {
             get {
-                return ResourceManager.GetString("SegaMegaDrive_Name", resourceCulture);
+                return ResourceManager.GetString("Imd_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Segmented images are not yet supported..
-        /// </summary>
-        internal static string Segmented_images_are_not_yet_supported {
+        internal static string Invalid_sector_type_0 {
             get {
-                return ResourceManager.GetString("Segmented_images_are_not_yet_supported", resourceCulture);
+                return ResourceManager.GetString("Invalid_sector_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Separate tracks not yet implemented.
-        /// </summary>
-        internal static string Separate_tracks_not_yet_implemented {
+        internal static string IMD_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("Separate_tracks_not_yet_implemented", resourceCulture);
+                return ResourceManager.GetString("IMD_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Serial number: {0}.
-        /// </summary>
-        internal static string Serial_number_0 {
+        internal static string IMD_comments_0 {
             get {
-                return ResourceManager.GetString("Serial_number_0", resourceCulture);
+                return ResourceManager.GetString("IMD_comments_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Session {0} has {1} tracks.
-        /// </summary>
-        internal static string Session_0_has_1_tracks {
+        internal static string KryoFlux_Name {
             get {
-                return ResourceManager.GetString("Session_0_has_1_tracks", resourceCulture);
+                return ResourceManager.GetString("KryoFlux_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Session {0} information:.
-        /// </summary>
-        internal static string Session_0_information {
+        internal static string Cannot_find_cyl_0_hd_0_supposing_only_top_head_was_dumped {
             get {
-                return ResourceManager.GetString("Session_0_information", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_cyl_0_hd_0_supposing_only_top_head_was_dumped", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Session information:.
-        /// </summary>
-        internal static string Session_information {
+        internal static string Cannot_find_cyl_0_hd_1_supposing_only_bottom_head_was_dumped {
             get {
-                return ResourceManager.GetString("Session_information", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_cyl_0_hd_1_supposing_only_bottom_head_was_dumped", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sets currentFile.offset to {0}.
-        /// </summary>
-        internal static string Sets_currentFile_offset_to_0 {
+        internal static string Cannot_find_cyl_1_supposing_double_stepping {
             get {
-                return ResourceManager.GetString("Sets_currentFile_offset_to_0", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_cyl_1_supposing_double_stepping", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting comments: {0}.
-        /// </summary>
-        internal static string Setting_comments_0 {
+        internal static string Arrived_end_of_disk_at_cylinder_0 {
             get {
-                return ResourceManager.GetString("Setting_comments_0", resourceCulture);
+                return ResourceManager.GetString("Arrived_end_of_disk_at_cylinder_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting creator: {0}.
-        /// </summary>
-        internal static string Setting_creator_0 {
+        internal static string Found_timestamp_0 {
             get {
-                return ResourceManager.GetString("Setting_creator_0", resourceCulture);
+                return ResourceManager.GetString("Found_timestamp_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting currentTrack.sequence to {0}.
-        /// </summary>
-        internal static string Setting_currentTrack_sequence_to_0 {
+        internal static string MaxiDisk_Name {
             get {
-                return ResourceManager.GetString("Setting_currentTrack_sequence_to_0", resourceCulture);
+                return ResourceManager.GetString("MaxiDisk_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting drive firmware revision: {0}.
-        /// </summary>
-        internal static string Setting_drive_firmware_revision_0 {
+        internal static string Ndif_Name {
             get {
-                return ResourceManager.GetString("Setting_drive_firmware_revision_0", resourceCulture);
+                return ResourceManager.GetString("Ndif_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting drive manufacturer: {0}.
-        /// </summary>
-        internal static string Setting_drive_manufacturer_0 {
+        internal static string Exception_trying_to_open_image_file_0 {
             get {
-                return ResourceManager.GetString("Setting_drive_manufacturer_0", resourceCulture);
+                return ResourceManager.GetString("Exception_trying_to_open_image_file_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting drive model: {0}.
-        /// </summary>
-        internal static string Setting_drive_model_0 {
+        internal static string Chunks_compressed_with_KenCode_are_not_yet_supported {
             get {
-                return ResourceManager.GetString("Setting_drive_model_0", resourceCulture);
+                return ResourceManager.GetString("Chunks_compressed_with_KenCode_are_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting drive serial number: {0}.
-        /// </summary>
-        internal static string Setting_drive_serial_number_0 {
+        internal static string Chunks_compressed_with_LZH_are_not_yet_supported {
             get {
-                return ResourceManager.GetString("Setting_drive_serial_number_0", resourceCulture);
+                return ResourceManager.GetString("Chunks_compressed_with_LZH_are_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting media barcode: {0}.
-        /// </summary>
-        internal static string Setting_media_barcode_0 {
+        internal static string Chunks_compressed_with_StuffIt_are_not_yet_supported {
             get {
-                return ResourceManager.GetString("Setting_media_barcode_0", resourceCulture);
+                return ResourceManager.GetString("Chunks_compressed_with_StuffIt_are_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting media manufacturer: {0}.
-        /// </summary>
-        internal static string Setting_media_manufacturer_0 {
+        internal static string Unsupported_chunk_type_0_found {
             get {
-                return ResourceManager.GetString("Setting_media_manufacturer_0", resourceCulture);
+                return ResourceManager.GetString("Unsupported_chunk_type_0_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting media model: {0}.
-        /// </summary>
-        internal static string Setting_media_model_0 {
+        internal static string Segmented_images_are_not_yet_supported {
             get {
-                return ResourceManager.GetString("Setting_media_model_0", resourceCulture);
+                return ResourceManager.GetString("Segmented_images_are_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting media part number: {0}.
-        /// </summary>
-        internal static string Setting_media_part_number_0 {
+        internal static string Encrypted_images_are_not_yet_supported {
             get {
-                return ResourceManager.GetString("Setting_media_part_number_0", resourceCulture);
+                return ResourceManager.GetString("Encrypted_images_are_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting media sequence as {0} of {1}.
-        /// </summary>
-        internal static string Setting_media_sequence_as_0_of_1 {
+        internal static string Nero_Name {
             get {
-                return ResourceManager.GetString("Setting_media_sequence_as_0_of_1", resourceCulture);
+                return ResourceManager.GetString("Nero_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting media serial number: {0}.
-        /// </summary>
-        internal static string Setting_media_serial_number_0 {
+        internal static string Nero_version_not_recognized {
             get {
-                return ResourceManager.GetString("Setting_media_serial_number_0", resourceCulture);
+                return ResourceManager.GetString("Nero_version_not_recognized", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Setting media title: {0}.
-        /// </summary>
-        internal static string Setting_media_title_0 {
+        internal static string Found_CUES_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("Setting_media_title_0", resourceCulture);
+                return ResourceManager.GetString("Found_CUES_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Size, in bytes, of the LZMA dictionary.
-        /// </summary>
-        internal static string Size_in_bytes_of_the_LZMA_dictionary {
+        internal static string Cuesheet_entry_0 {
             get {
-                return ResourceManager.GetString("Size_in_bytes_of_the_LZMA_dictionary", resourceCulture);
+                return ResourceManager.GetString("Cuesheet_entry_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Some error occurred setting GD sizes.
-        /// </summary>
-        internal static string Some_error_occurred_setting_GD_sizes {
+        internal static string Found_CUEX_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("Some_error_occurred_setting_GD_sizes", resourceCulture);
+                return ResourceManager.GetString("Found_CUEX_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Songwriter: {0}.
-        /// </summary>
-        internal static string Songwriter_0 {
+        internal static string Found_DAOI_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("Songwriter_0", resourceCulture);
+                return ResourceManager.GetString("Found_DAOI_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Songwriter is not set..
-        /// </summary>
-        internal static string Songwriter_is_not_set {
+        internal static string Disc_At_Once_entry_0 {
             get {
-                return ResourceManager.GetString("Songwriter_is_not_set", resourceCulture);
+                return ResourceManager.GetString("Disc_At_Once_entry_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to South Korea.
-        /// </summary>
-        internal static string South_Korea {
+        internal static string Found_DAOX_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("South_Korea", resourceCulture);
+                return ResourceManager.GetString("Found_DAOX_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Spain.
-        /// </summary>
-        internal static string Spain {
+        internal static string Found_CDTX_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("Spain", resourceCulture);
+                return ResourceManager.GetString("Found_CDTX_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sparse images not yet implemented.
-        /// </summary>
-        internal static string Sparse_images_not_yet_implemented {
+        internal static string CD_TEXT_entry_0 {
             get {
-                return ResourceManager.GetString("Sparse_images_not_yet_implemented", resourceCulture);
+                return ResourceManager.GetString("CD_TEXT_entry_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Special revision: {0}.
-        /// </summary>
-        internal static string Special_revision_0 {
+        internal static string Found_TINF_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("Special_revision_0", resourceCulture);
+                return ResourceManager.GetString("Found_TINF_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Split data file at 2GiB..
-        /// </summary>
-        internal static string Split_data_file_at_2GiB {
+        internal static string Track_at_Once_entry_0 {
             get {
-                return ResourceManager.GetString("Split_data_file_at_2GiB", resourceCulture);
+                return ResourceManager.GetString("Track_at_Once_entry_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Splitted images not yet implemented.
-        /// </summary>
-        internal static string Splitted_images_not_yet_implemented {
+        internal static string Found_ETNF_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("Splitted_images_not_yet_implemented", resourceCulture);
+                return ResourceManager.GetString("Found_ETNF_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Stack trace: {0}.
-        /// </summary>
-        internal static string Stack_trace_0 {
+        internal static string Found_ETN2_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("Stack_trace_0", resourceCulture);
+                return ResourceManager.GetString("Found_ETN2_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Starting sector: {0}.
-        /// </summary>
-        internal static string Starting_sector_0 {
+        internal static string Found_SINF_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("Starting_sector_0", resourceCulture);
+                return ResourceManager.GetString("Found_SINF_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Starting track: {0}.
-        /// </summary>
-        internal static string Starting_track_0 {
+        internal static string Session_0_has_1_tracks {
             get {
-                return ResourceManager.GetString("Starting_track_0", resourceCulture);
+                return ResourceManager.GetString("Session_0_has_1_tracks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Store only unique sectors. This consumes more memory and is slower, but it&apos;s enabled by default.
-        /// </summary>
-        internal static string Store_only_unique_sectors_This_consumes_more_memory_and_is_slower_but_its_enabled_by_default {
+        internal static string Found_MTYP_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("Store_only_unique_sectors_This_consumes_more_memory_and_is_slower_but_its_enabled" +
-                        "_by_default", resourceCulture);
+                return ResourceManager.GetString("Found_MTYP_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Stored data checksum = 0x{0:X8}.
-        /// </summary>
-        internal static string Stored_data_checksum_equals_0_X8 {
+        internal static string Media_type_is_0_1 {
             get {
-                return ResourceManager.GetString("Stored_data_checksum_equals_0_X8", resourceCulture);
+                return ResourceManager.GetString("Media_type_is_0_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Stored tag checksum = 0x{0:X8}.
-        /// </summary>
-        internal static string Stored_tag_checksum_equals_0_X8 {
+        internal static string Found_DINF_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("Stored_tag_checksum_equals_0_X8", resourceCulture);
+                return ResourceManager.GetString("Found_DINF_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to SuperCardPro.
-        /// </summary>
-        internal static string SuperCardPro_Name {
+        internal static string Found_RELO_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("SuperCardPro_Name", resourceCulture);
+                return ResourceManager.GetString("Found_RELO_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Super Nintendo.
-        /// </summary>
-        internal static string SuperNintendo_Name {
+        internal static string Found_TOCT_chunk_parsing_0_bytes {
             get {
-                return ResourceManager.GetString("SuperNintendo_Name", resourceCulture);
+                return ResourceManager.GetString("Found_TOCT_chunk_parsing_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Support for image type {0} not yet implemented.
-        /// </summary>
-        internal static string Support_for_image_type_0_not_yet_implemented {
+        internal static string Found_END_chunk_finishing_parse {
             get {
-                return ResourceManager.GetString("Support_for_image_type_0_not_yet_implemented", resourceCulture);
+                return ResourceManager.GetString("Found_END_chunk_finishing_parse", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Support for multiple volumes not supported.
-        /// </summary>
-        internal static string Support_for_multiple_volumes_not_supported {
+        internal static string Unknown_chunk_ID_0_skipping {
             get {
-                return ResourceManager.GetString("Support_for_multiple_volumes_not_supported", resourceCulture);
+                return ResourceManager.GetString("Unknown_chunk_ID_0_skipping", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sweden/Scandinavia.
-        /// </summary>
-        internal static string Sweden_Scandinavia {
+        internal static string Inconsistent_track_mode_and_track_sector_size_found {
             get {
-                return ResourceManager.GetString("Sweden_Scandinavia", resourceCulture);
+                return ResourceManager.GetString("Inconsistent_track_mode_and_track_sector_size_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to System type: {0}.
-        /// </summary>
-        internal static string System_type_0 {
+        internal static string Building_offset_track_and_session_maps {
             get {
-                return ResourceManager.GetString("System_type_0", resourceCulture);
+                return ResourceManager.GetString("Building_offset_track_and_session_maps", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to T98 Hard Disk Image.
-        /// </summary>
-        internal static string T98_Name {
+        internal static string This_image_contains_a_track_that_is_set_to_start_outside_the_file {
             get {
-                return ResourceManager.GetString("T98_Name", resourceCulture);
+                return ResourceManager.GetString("This_image_contains_a_track_that_is_set_to_start_outside_the_file", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Table size must be a power of 2.
-        /// </summary>
-        internal static string Table_size_must_be_a_power_of_2 {
+        internal static string Breaking_track_processing_and_trying_recovery_of_information {
             get {
-                return ResourceManager.GetString("Table_size_must_be_a_power_of_2", resourceCulture);
+                return ResourceManager.GetString("Breaking_track_processing_and_trying_recovery_of_information", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Table size must be between 1 and 16 clusters.
-        /// </summary>
-        internal static string Table_size_must_be_between_1_and_16_clusters {
+        internal static string Image_corrupted_beyond_recovery_cannot_open {
             get {
-                return ResourceManager.GetString("Table_size_must_be_between_1_and_16_clusters", resourceCulture);
+                return ResourceManager.GetString("Image_corrupted_beyond_recovery_cannot_open", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Tag type {0} is null, skipping....
-        /// </summary>
-        internal static string Tag_type_0_is_null_skipping {
+        internal static string Warning_This_image_is_missing_the_last_150_sectors {
             get {
-                return ResourceManager.GetString("Tag_type_0_is_null_skipping", resourceCulture);
+                return ResourceManager.GetString("Warning_This_image_is_missing_the_last_150_sectors", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to TeleDisk comments: {0}.
-        /// </summary>
-        internal static string TeleDisk_comments_0 {
+        internal static string Nero_image_contains_a_disc_of_type_0 {
             get {
-                return ResourceManager.GetString("TeleDisk_comments_0", resourceCulture);
+                return ResourceManager.GetString("Nero_image_contains_a_disc_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to TeleDisk image contains a disk of type {0}.
-        /// </summary>
-        internal static string TeleDisk_image_contains_a_disk_of_type_0 {
+        internal static string Exception_occurred_opening_file {
             get {
-                return ResourceManager.GetString("TeleDisk_image_contains_a_disk_of_type_0", resourceCulture);
+                return ResourceManager.GetString("Exception_occurred_opening_file", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Sydex TeleDisk.
-        /// </summary>
-        internal static string TeleDisk_Name {
+        internal static string Nhdr0_Name {
             get {
-                return ResourceManager.GetString("TeleDisk_Name", resourceCulture);
+                return ResourceManager.GetString("Nhdr0_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to The data files are missing a pregap or hidden track contents, will do best effort to make the rest of the image readable..
-        /// </summary>
-        internal static string The_data_files_are_missing_a_pregap_or_hidden_track_contents_will_do_best_effort_to_make_the_rest_of_the_image_readable {
+        internal static string Parallels_Name {
             get {
-                return ResourceManager.GetString("The_data_files_are_missing_a_pregap_or_hidden_track_contents_will_do_best_effort_" +
-                        "to_make_the_rest_of_the_image_readable", resourceCulture);
+                return ResourceManager.GetString("Parallels_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to The data files are not correct according to the cuesheet file, cannot continue with this file..
-        /// </summary>
-        internal static string The_data_files_are_not_correct_according_to_the_cuesheet_file_cannot_continue_with_this_file {
+        internal static string Reading_BAT {
             get {
-                return ResourceManager.GetString("The_data_files_are_not_correct_according_to_the_cuesheet_file_cannot_continue_wit" +
-                        "h_this_file", resourceCulture);
+                return ResourceManager.GetString("Reading_BAT", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to The disc this image represents contained a hidden track in the first pregap, that this image format cannot store. This dump is therefore, incorrect..
-        /// </summary>
-        internal static string The_disc_this_image_represents_contained_a_hidden_track_in_the_first_pregap_that_this_image_format_cannot_store_This_dump_is_therefore_incorrect {
+        internal static string Too_many_sectors_for_selected_cluster_size {
             get {
-                return ResourceManager.GetString("The_disc_this_image_represents_contained_a_hidden_track_in_the_first_pregap_that_" +
-                        "this_image_format_cannot_store_This_dump_is_therefore_incorrect", resourceCulture);
+                return ResourceManager.GetString("Too_many_sectors_for_selected_cluster_size", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to The requested position is out of range..
-        /// </summary>
-        internal static string The_requested_position_is_out_of_range {
+        internal static string PartClone_Name {
             get {
-                return ResourceManager.GetString("The_requested_position_is_out_of_range", resourceCulture);
+                return ResourceManager.GetString("PartClone_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to The specified sector size does not correspond with the requested image extension..
-        /// </summary>
-        internal static string The_specified_sector_size_does_not_correspond_with_the_requested_image_extension {
+        internal static string Reading_bytemap_0_bytes {
             get {
-                return ResourceManager.GetString("The_specified_sector_size_does_not_correspond_with_the_requested_image_extension", resourceCulture);
+                return ResourceManager.GetString("Reading_bytemap_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to There are sparse extents but there is no header to find the grain tables, cannot proceed..
-        /// </summary>
-        internal static string There_are_sparse_extents_but_there_is_no_header_to_find_the_grain_tables_cannot_proceed {
+        internal static string Could_not_find_partclone_BiTmAgIc_not_continuing {
             get {
-                return ResourceManager.GetString("There_are_sparse_extents_but_there_is_no_header_to_find_the_grain_tables_cannot_p" +
-                        "roceed", resourceCulture);
+                return ResourceManager.GetString("Could_not_find_partclone_BiTmAgIc_not_continuing", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to This format requires sectors to be raw. Generating ECC is not yet implemented.
-        /// </summary>
-        internal static string This_format_requires_sectors_to_be_raw_Generating_ECC_is_not_yet_implemented {
+        internal static string Filling_extents {
             get {
-                return ResourceManager.GetString("This_format_requires_sectors_to_be_raw_Generating_ECC_is_not_yet_implemented", resourceCulture);
+                return ResourceManager.GetString("Filling_extents", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to This image contains a track that is set to start outside the file..
-        /// </summary>
-        internal static string This_image_contains_a_track_that_is_set_to_start_outside_the_file {
+        internal static string Took_0_seconds_to_fill_extents {
             get {
-                return ResourceManager.GetString("This_image_contains_a_track_that_is_set_to_start_outside_the_file", resourceCulture);
+                return ResourceManager.GetString("Took_0_seconds_to_fill_extents", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to This image from PowerISO is damaged beyond possible recovery. Will not open..
-        /// </summary>
-        internal static string This_image_from_PowerISO_is_damaged_beyond_possible_recovery_Will_not_open {
+        internal static string Partimage_Name {
             get {
-                return ResourceManager.GetString("This_image_from_PowerISO_is_damaged_beyond_possible_recovery_Will_not_open", resourceCulture);
+                return ResourceManager.GetString("Partimage_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to This image has a corrupted track list, a best effort has been tried but may require manual editing or redump..
-        /// </summary>
-        internal static string This_image_has_a_corrupted_track_list_a_best_effort_has_been_tried_but_may_require_manual_editing_or_redump {
+        internal static string Support_for_multiple_volumes_not_supported {
             get {
-                return ResourceManager.GetString("This_image_has_a_corrupted_track_list_a_best_effort_has_been_tried_but_may_requir" +
-                        "e_manual_editing_or_redump", resourceCulture);
+                return ResourceManager.GetString("Support_for_multiple_volumes_not_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to This image has a corrupted track list, convert will fix it..
-        /// </summary>
-        internal static string This_image_has_a_corrupted_track_list_convert_will_fix_it {
+        internal static string Encrypted_images_are_currently_not_supported {
             get {
-                return ResourceManager.GetString("This_image_has_a_corrupted_track_list_convert_will_fix_it", resourceCulture);
+                return ResourceManager.GetString("Encrypted_images_are_currently_not_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to This image is missing vital multi-session data and cannot be read correctly..
-        /// </summary>
-        internal static string This_image_is_missing_vital_multi_session_data_and_cannot_be_read_correctly {
+        internal static string Cannot_find_MBRs {
             get {
-                return ResourceManager.GetString("This_image_is_missing_vital_multi_session_data_and_cannot_be_read_correctly", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_MBRs", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to This image is most probably corrupted beyond repair. It is highly recommended to dump it with another software..
-        /// </summary>
-        internal static string This_image_is_most_probably_corrupted_beyond_repair_It_is_highly_recommended_to_dump_it_with_another_software {
+        internal static string Cannot_find_local_header {
             get {
-                return ResourceManager.GetString("This_image_is_most_probably_corrupted_beyond_repair_It_is_highly_recommended_to_d" +
-                        "ump_it_with_another_software", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_local_header", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to This image needs the resource fork to work..
-        /// </summary>
-        internal static string This_image_needs_the_resource_fork_to_work {
+        internal static string Cannot_find_bitmap {
             get {
-                return ResourceManager.GetString("This_image_needs_the_resource_fork_to_work", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_bitmap", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Title: {0}.
-        /// </summary>
-        internal static string Title_0 {
+        internal static string Cannot_find_info_block {
             get {
-                return ResourceManager.GetString("Title_0", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_info_block", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Title is not set..
-        /// </summary>
-        internal static string Title_is_not_set {
+        internal static string Cannot_find_data_blocks {
             get {
-                return ResourceManager.GetString("Title_is_not_set", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_data_blocks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to TOC len {0}.
-        /// </summary>
-        internal static string TOC_len_0 {
+        internal static string Cannot_find_tail_Multiple_volumes_are_not_supported_or_image_is_corrupt {
             get {
-                return ResourceManager.GetString("TOC_len_0", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_tail_Multiple_volumes_are_not_supported_or_image_is_corrupt", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Too many cylinders..
-        /// </summary>
-        internal static string Too_many_cylinders {
+        internal static string Qcow_Name {
             get {
-                return ResourceManager.GetString("Too_many_cylinders", resourceCulture);
+                return ResourceManager.GetString("Qcow_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Too many heads..
-        /// </summary>
-        internal static string Too_many_heads {
+        internal static string Image_size_is_too_small {
             get {
-                return ResourceManager.GetString("Too_many_heads", resourceCulture);
+                return ResourceManager.GetString("Image_size_is_too_small", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Too many sectors.
-        /// </summary>
-        internal static string Too_many_sectors {
+        internal static string Cluster_size_must_be_between_512_bytes_and_64_Kbytes {
             get {
-                return ResourceManager.GetString("Too_many_sectors", resourceCulture);
+                return ResourceManager.GetString("Cluster_size_must_be_between_512_bytes_and_64_Kbytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Too many sectors for selected cluster size.
-        /// </summary>
-        internal static string Too_many_sectors_for_selected_cluster_size {
+        internal static string L2_size_must_be_between_512_bytes_and_64_Kbytes {
             get {
-                return ResourceManager.GetString("Too_many_sectors_for_selected_cluster_size", resourceCulture);
+                return ResourceManager.GetString("L2_size_must_be_between_512_bytes_and_64_Kbytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Too many sectors per track..
-        /// </summary>
-        internal static string Too_many_sectors_per_track {
+        internal static string Invalid_encryption_method {
             get {
-                return ResourceManager.GetString("Too_many_sectors_per_track", resourceCulture);
+                return ResourceManager.GetString("Invalid_encryption_method", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0}ms to deinterleave subchannel..
-        /// </summary>
-        internal static string Took_0_ms_to_deinterleave_subchannel {
+        internal static string AES_encrypted_images_not_yet_supported {
             get {
-                return ResourceManager.GetString("Took_0_ms_to_deinterleave_subchannel", resourceCulture);
+                return ResourceManager.GetString("AES_encrypted_images_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0}ms to de-sequentialize subchannel..
-        /// </summary>
-        internal static string Took_0_ms_to_desequentialize_subchannel {
+        internal static string Differencing_images_not_yet_supported {
             get {
-                return ResourceManager.GetString("Took_0_ms_to_desequentialize_subchannel", resourceCulture);
+                return ResourceManager.GetString("Differencing_images_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0}ms to interleave subchannel..
-        /// </summary>
-        internal static string Took_0_ms_to_interleave_subchannel {
+        internal static string Image_is_too_large {
             get {
-                return ResourceManager.GetString("Took_0_ms_to_interleave_subchannel", resourceCulture);
+                return ResourceManager.GetString("Image_is_too_large", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0}ms to sequentialize subchannel..
-        /// </summary>
-        internal static string Took_0_ms_to_sequentialize_subchannel {
+        internal static string Reading_L1_table {
             get {
-                return ResourceManager.GetString("Took_0_ms_to_sequentialize_subchannel", resourceCulture);
+                return ResourceManager.GetString("Reading_L1_table", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0}ms to transform subchannel..
-        /// </summary>
-        internal static string Took_0_ms_to_transform_subchannel {
+        internal static string Trying_to_read_past_L1_table_position_0_of_a_max_1 {
             get {
-                return ResourceManager.GetString("Took_0_ms_to_transform_subchannel", resourceCulture);
+                return ResourceManager.GetString("Trying_to_read_past_L1_table_position_0_of_a_max_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0}ms to untransform subchannel..
-        /// </summary>
-        internal static string Took_0_ms_to_untransform_subchannel {
+        internal static string Reading_L2_table_0 {
             get {
-                return ResourceManager.GetString("Took_0_ms_to_untransform_subchannel", resourceCulture);
+                return ResourceManager.GetString("Reading_L2_table_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0} seconds.
-        /// </summary>
-        internal static string Took_0_seconds {
+        internal static string Trying_to_write_past_L1_table_position_0_of_a_max_1 {
             get {
-                return ResourceManager.GetString("Took_0_seconds", resourceCulture);
+                return ResourceManager.GetString("Trying_to_write_past_L1_table_position_0_of_a_max_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0} seconds to compress CPI_MAI.
-        /// </summary>
-        internal static string Took_0_seconds_to_compress_CPI_MAI {
+        internal static string Qcow2_Name {
             get {
-                return ResourceManager.GetString("Took_0_seconds_to_compress_CPI_MAI", resourceCulture);
+                return ResourceManager.GetString("Qcow2_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0} seconds to compress decrypted DVD title keys.
-        /// </summary>
-        internal static string Took_0_seconds_to_compress_decrypted_DVD_title_keys {
+        internal static string Unknown_incompatible_features_0_enabled_not_proceeding {
             get {
-                return ResourceManager.GetString("Took_0_seconds_to_compress_decrypted_DVD_title_keys", resourceCulture);
+                return ResourceManager.GetString("Unknown_incompatible_features_0_enabled_not_proceeding", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0} seconds to compress MODE2 subheaders.
-        /// </summary>
-        internal static string Took_0_seconds_to_compress_MODE2_subheaders {
+        internal static string Qed_Name {
             get {
-                return ResourceManager.GetString("Took_0_seconds_to_compress_MODE2_subheaders", resourceCulture);
+                return ResourceManager.GetString("Qed_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0} seconds to compress prefix.
-        /// </summary>
-        internal static string Took_0_seconds_to_compress_prefix {
+        internal static string Cluster_size_must_be_a_power_of_2 {
             get {
-                return ResourceManager.GetString("Took_0_seconds_to_compress_prefix", resourceCulture);
+                return ResourceManager.GetString("Cluster_size_must_be_a_power_of_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0} seconds to compress subchannel.
-        /// </summary>
-        internal static string Took_0_seconds_to_compress_subchannel {
+        internal static string Cluster_size_must_be_between_4_Kbytes_and_64_Mbytes {
             get {
-                return ResourceManager.GetString("Took_0_seconds_to_compress_subchannel", resourceCulture);
+                return ResourceManager.GetString("Cluster_size_must_be_between_4_Kbytes_and_64_Mbytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0} seconds to compress suffix.
-        /// </summary>
-        internal static string Took_0_seconds_to_compress_suffix {
+        internal static string Table_size_must_be_a_power_of_2 {
             get {
-                return ResourceManager.GetString("Took_0_seconds_to_compress_suffix", resourceCulture);
+                return ResourceManager.GetString("Table_size_must_be_a_power_of_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0} seconds to decompress block.
-        /// </summary>
-        internal static string Took_0_seconds_to_decompress_block {
+        internal static string Table_size_must_be_between_1_and_16_clusters {
             get {
-                return ResourceManager.GetString("Took_0_seconds_to_decompress_block", resourceCulture);
+                return ResourceManager.GetString("Table_size_must_be_between_1_and_16_clusters", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0} seconds to decompress DDT.
-        /// </summary>
-        internal static string Took_0_seconds_to_decompress_DDT {
+        internal static string Image_uses_unknown_incompatible_features_0 {
             get {
-                return ResourceManager.GetString("Took_0_seconds_to_decompress_DDT", resourceCulture);
+                return ResourceManager.GetString("Image_uses_unknown_incompatible_features_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Took {0} seconds to fill extents.
-        /// </summary>
-        internal static string Took_0_seconds_to_fill_extents {
+        internal static string RsIde_Name {
             get {
-                return ResourceManager.GetString("Took_0_seconds_to_fill_extents", resourceCulture);
+                return ResourceManager.GetString("RsIde_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Total of {0} data sectors, for {1} bytes.
-        /// </summary>
-        internal static string Total_of_0_data_sectors_for_1_bytes {
+        internal static string Unsupported_media_tag_0 {
             get {
-                return ResourceManager.GetString("Total_of_0_data_sectors_for_1_bytes", resourceCulture);
+                return ResourceManager.GetString("Unsupported_media_tag_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to track.
-        /// </summary>
-        internal static string track {
+        internal static string SaveDskF_Name {
             get {
-                return ResourceManager.GetString("track", resourceCulture);
+                return ResourceManager.GetString("SaveDskF_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track {0}..
-        /// </summary>
-        internal static string Track_0 {
+        internal static string Calculated_checksum_equals_0_X8_1 {
             get {
-                return ResourceManager.GetString("Track_0", resourceCulture);
+                return ResourceManager.GetString("Calculated_checksum_equals_0_X8_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track {0} information:.
-        /// </summary>
-        internal static string Track_0_information {
+        internal static string SaveDskF_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("Track_0_information", resourceCulture);
+                return ResourceManager.GetString("SaveDskF_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track {0} lacks index 01.
-        /// </summary>
-        internal static string Track_0_lacks_index_01 {
+        internal static string SaveDskF_comments_0 {
             get {
-                return ResourceManager.GetString("Track_0_lacks_index_01", resourceCulture);
+                return ResourceManager.GetString("SaveDskF_comments_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track {0} offset 0x{1:x8}, size={2:x4}.
-        /// </summary>
-        internal static string Track_0_offset_1_size_equals_2 {
+        internal static string Compressed_SaveDskF_images_are_not_supported {
             get {
-                return ResourceManager.GetString("Track_0_offset_1_size_equals_2", resourceCulture);
+                return ResourceManager.GetString("Compressed_SaveDskF_images_are_not_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track {0} Side {1} size = {2}.
-        /// </summary>
-        internal static string Track_0_Side_1_size_equals_2 {
+        internal static string SuperCardPro_Name {
             get {
-                return ResourceManager.GetString("Track_0_Side_1_size_equals_2", resourceCulture);
+                return ResourceManager.GetString("SuperCardPro_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track allows digital copy.
-        /// </summary>
-        internal static string Track_allows_digital_copy {
+        internal static string Track_header_at_0_contains_incorrect_signature {
             get {
-                return ResourceManager.GetString("Track_allows_digital_copy", resourceCulture);
+                return ResourceManager.GetString("Track_header_at_0_contains_incorrect_signature", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track-at-Once entry {0}.
-        /// </summary>
-        internal static string Track_at_Once_entry_0 {
+        internal static string Track_number_at_0_should_be_1_but_is_2 {
             get {
-                return ResourceManager.GetString("Track_at_Once_entry_0", resourceCulture);
+                return ResourceManager.GetString("Track_number_at_0_should_be_1_but_is_2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track block at {0} contains {1} entries.
-        /// </summary>
-        internal static string Track_block_at_0_contains_1_entries {
+        internal static string Found_track_0_at_1 {
             get {
-                return ResourceManager.GetString("Track_block_at_0_contains_1_entries", resourceCulture);
+                return ResourceManager.GetString("Found_track_0_at_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track cylinder: {0}.
-        /// </summary>
-        internal static string Track_cylinder_0 {
+        internal static string Found_footer_at_0 {
             get {
-                return ResourceManager.GetString("Track_cylinder_0", resourceCulture);
+                return ResourceManager.GetString("Found_footer_at_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track decompression yielded incomplete data.
-        /// </summary>
-        internal static string Track_decompression_yielded_incomplete_data {
+        internal static string cylinders_equal_0 {
             get {
-                return ResourceManager.GetString("Track_decompression_yielded_incomplete_data", resourceCulture);
+                return ResourceManager.GetString("cylinders_equal_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track description: {0}.
-        /// </summary>
-        internal static string Track_description_0 {
+        internal static string T98_Name {
             get {
-                return ResourceManager.GetString("Track_description_0", resourceCulture);
+                return ResourceManager.GetString("T98_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track ending sector: {0}.
-        /// </summary>
-        internal static string Track_ending_sector_0 {
+        internal static string Sector_size_0_is_incorrect {
             get {
-                return ResourceManager.GetString("Track_ending_sector_0", resourceCulture);
+                return ResourceManager.GetString("Sector_size_0_is_incorrect", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track follows.
-        /// </summary>
-        internal static string Track_follows {
+        internal static string Block_pattern_decoder_Input_data_size_0_bytes {
             get {
-                return ResourceManager.GetString("Track_follows", resourceCulture);
+                return ResourceManager.GetString("Block_pattern_decoder_Input_data_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track has pre-emphasis applied.
-        /// </summary>
-        internal static string Track_has_pre_emphasis_applied {
+        internal static string Block_pattern_decoder_Processed_input_0_bytes {
             get {
-                return ResourceManager.GetString("Track_has_pre_emphasis_applied", resourceCulture);
+                return ResourceManager.GetString("Block_pattern_decoder_Processed_input_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track has SCMS.
-        /// </summary>
-        internal static string Track_has_SCMS {
+        internal static string Block_pattern_decoder_Output_data_size_0_bytes {
             get {
-                return ResourceManager.GetString("Track_has_SCMS", resourceCulture);
+                return ResourceManager.GetString("Block_pattern_decoder_Output_data_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track head: {0}.
-        /// </summary>
-        internal static string Track_head_0 {
+        internal static string Block_pattern_decoder_Processed_Output_0_bytes {
             get {
-                return ResourceManager.GetString("Track_head_0", resourceCulture);
+                return ResourceManager.GetString("Block_pattern_decoder_Processed_Output_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track header at {0} contains incorrect signature..
-        /// </summary>
-        internal static string Track_header_at_0_contains_incorrect_signature {
+        internal static string RLE_decoder_Input_data_size_0_bytes {
             get {
-                return ResourceManager.GetString("Track_header_at_0_contains_incorrect_signature", resourceCulture);
+                return ResourceManager.GetString("RLE_decoder_Input_data_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track header CRC: 0x{0:X2} (calculated 0x{1:X2}).
-        /// </summary>
-        internal static string Track_header_CRC_0_X2_calculated_1_X2 {
+        internal static string RLE_decoder_Processed_input_0_bytes {
             get {
-                return ResourceManager.GetString("Track_header_CRC_0_X2_calculated_1_X2", resourceCulture);
+                return ResourceManager.GetString("RLE_decoder_Processed_input_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track information:.
-        /// </summary>
-        internal static string Track_information {
+        internal static string RLE_decoder_Output_data_size_0_bytes {
             get {
-                return ResourceManager.GetString("Track_information", resourceCulture);
+                return ResourceManager.GetString("RLE_decoder_Output_data_size_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track is data.
-        /// </summary>
-        internal static string Track_is_data {
+        internal static string RLE_decoder_Processed_Output_0_bytes {
             get {
-                return ResourceManager.GetString("Track_is_data", resourceCulture);
+                return ResourceManager.GetString("RLE_decoder_Processed_Output_0_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track is flagged as quadraphonic.
-        /// </summary>
-        internal static string Track_is_flagged_as_quadraphonic {
+        internal static string Data_encoding_0_is_incorrect {
             get {
-                return ResourceManager.GetString("Track_is_flagged_as_quadraphonic", resourceCulture);
+                return ResourceManager.GetString("Data_encoding_0_is_incorrect", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track mode {0} is unsupported.
-        /// </summary>
-        internal static string Track_mode_0_is_unsupported {
+        internal static string calculated_header_crc_equals_0_X4 {
             get {
-                return ResourceManager.GetString("Track_mode_0_is_unsupported", resourceCulture);
+                return ResourceManager.GetString("calculated_header_crc_equals_0_X4", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track not found.
-        /// </summary>
-        internal static string Track_not_found {
+        internal static string TeleDisk_Name {
             get {
-                return ResourceManager.GetString("Track_not_found", resourceCulture);
+                return ResourceManager.GetString("TeleDisk_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track number at {0} should be {1} but is {2}..
-        /// </summary>
-        internal static string Track_number_at_0_should_be_1_but_is_2 {
+        internal static string Calculated_CRC_does_not_coincide_with_stored_one {
             get {
-                return ResourceManager.GetString("Track_number_at_0_should_be_1_but_is_2", resourceCulture);
+                return ResourceManager.GetString("Calculated_CRC_does_not_coincide_with_stored_one", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track resides in file {0}, type defined as {1}, starting at byte {2}.
-        /// </summary>
-        internal static string Track_resides_in_file_0_type_defined_as_1_starting_at_byte_2 {
+        internal static string Comment_header {
             get {
-                return ResourceManager.GetString("Track_resides_in_file_0_type_defined_as_1_starting_at_byte_2", resourceCulture);
+                return ResourceManager.GetString("Comment_header", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track size not a multiple of sector size.
-        /// </summary>
-        internal static string Track_size_not_a_multiple_of_sector_size {
+        internal static string Calculated_CRC_equals_0_X4 {
             get {
-                return ResourceManager.GetString("Track_size_not_a_multiple_of_sector_size", resourceCulture);
+                return ResourceManager.GetString("Calculated_CRC_equals_0_X4", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track starting sector: {0}.
-        /// </summary>
-        internal static string Track_starting_sector_0 {
+        internal static string Comment {
             get {
-                return ResourceManager.GetString("Track_starting_sector_0", resourceCulture);
+                return ResourceManager.GetString("Comment", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track subchannel mode {0} is unsupported.
-        /// </summary>
-        internal static string Track_subchannel_mode_0_is_unsupported {
+        internal static string Image_modified_on_0 {
             get {
-                return ResourceManager.GetString("Track_subchannel_mode_0_is_unsupported", resourceCulture);
+                return ResourceManager.GetString("Image_modified_on_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track title = {0}.
-        /// </summary>
-        internal static string Track_title_0 {
+        internal static string Parsing_image {
             get {
-                return ResourceManager.GetString("Track_title_0", resourceCulture);
+                return ResourceManager.GetString("Parsing_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Track type: {0}.
-        /// </summary>
-        internal static string Track_type_0 {
+        internal static string No_cylinders_or_heads_found {
             get {
-                return ResourceManager.GetString("Track_type_0", resourceCulture);
+                return ResourceManager.GetString("No_cylinders_or_heads_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Trainer size: {0} bytes.
-        /// </summary>
-        internal static string Trainer_size_0_bytes {
+        internal static string Track_follows {
             get {
-                return ResourceManager.GetString("Trainer_size_0_bytes", resourceCulture);
+                return ResourceManager.GetString("Track_follows", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Tried reading a track that is not present in image.
-        /// </summary>
-        internal static string Tried_reading_a_track_that_is_not_present_in_image {
+        internal static string Track_cylinder_0 {
             get {
-                return ResourceManager.GetString("Tried_reading_a_track_that_is_not_present_in_image", resourceCulture);
+                return ResourceManager.GetString("Track_cylinder_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Tried to rewind, this format rewinded on writing.
-        /// </summary>
-        internal static string Tried_to_rewind_this_format_rewinded_on_writing {
+        internal static string Track_head_0 {
             get {
-                return ResourceManager.GetString("Tried_to_rewind_this_format_rewinded_on_writing", resourceCulture);
+                return ResourceManager.GetString("Track_head_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Tried to set geometry on a media that doesn&apos;t support it.
-        /// </summary>
-        internal static string Tried_to_set_geometry_on_a_media_that_doesnt_support_it {
+        internal static string Sectors_in_track_0 {
             get {
-                return ResourceManager.GetString("Tried_to_set_geometry_on_a_media_that_doesnt_support_it", resourceCulture);
+                return ResourceManager.GetString("Sectors_in_track_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Tried to write more data than possible.
-        /// </summary>
-        internal static string Tried_to_write_more_data_than_possible {
+        internal static string Track_header_CRC_0_X2_calculated_1_X2 {
             get {
-                return ResourceManager.GetString("Tried_to_write_more_data_than_possible", resourceCulture);
+                return ResourceManager.GetString("Track_header_CRC_0_X2_calculated_1_X2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Tried to write on a non-writable image.
-        /// </summary>
-        internal static string Tried_to_write_on_a_non_writable_image {
+        internal static string End_of_disk_image_arrived {
             get {
-                return ResourceManager.GetString("Tried_to_write_on_a_non_writable_image", resourceCulture);
+                return ResourceManager.GetString("End_of_disk_image_arrived", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Tried to write past image size.
-        /// </summary>
-        internal static string Tried_to_write_past_image_size {
+        internal static string Total_of_0_data_sectors_for_1_bytes {
             get {
-                return ResourceManager.GetString("Tried_to_write_past_image_size", resourceCulture);
+                return ResourceManager.GetString("Total_of_0_data_sectors_for_1_bytes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Trying to read past L1 table, position {0} of a max {1}.
-        /// </summary>
-        internal static string Trying_to_read_past_L1_table_position_0_of_a_max_1 {
+        internal static string Sector_follows {
             get {
-                return ResourceManager.GetString("Trying_to_read_past_L1_table_position_0_of_a_max_1", resourceCulture);
+                return ResourceManager.GetString("Sector_follows", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Trying to write a media with {0} sectors to an image with {1} sectors, not continuing....
-        /// </summary>
-        internal static string Trying_to_write_a_media_with_0_sectors_to_an_image_with_1_sectors_not_continuing {
+        internal static string AddressMark_cylinder_0 {
             get {
-                return ResourceManager.GetString("Trying_to_write_a_media_with_0_sectors_to_an_image_with_1_sectors_not_continuing", resourceCulture);
+                return ResourceManager.GetString("AddressMark_cylinder_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Trying to write past L1 table, position {0} of a max {1}.
-        /// </summary>
-        internal static string Trying_to_write_past_L1_table_position_0_of_a_max_1 {
+        internal static string AddressMark_head_0 {
             get {
-                return ResourceManager.GetString("Trying_to_write_past_L1_table_position_0_of_a_max_1", resourceCulture);
+                return ResourceManager.GetString("AddressMark_head_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Trying to write subchannel to track {0}, that does not have subchannel.
-        /// </summary>
-        internal static string Trying_to_write_subchannel_to_track_0_that_does_not_have_subchannel {
+        internal static string AddressMark_sector_number_0 {
             get {
-                return ResourceManager.GetString("Trying_to_write_subchannel_to_track_0_that_does_not_have_subchannel", resourceCulture);
+                return ResourceManager.GetString("AddressMark_sector_number_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Twiggy write support not yet implemented.
-        /// </summary>
-        internal static string Twiggy_write_support_not_yet_implemented {
+        internal static string Sector_size_0 {
             get {
-                return ResourceManager.GetString("Twiggy_write_support_not_yet_implemented", resourceCulture);
+                return ResourceManager.GetString("Sector_size_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Type of adapter type. Possible values: ide, lsilogic, buslogic, legacyESX..
-        /// </summary>
-        internal static string Type_of_adapter_type {
+        internal static string Sector_flags_0_X2 {
             get {
-                return ResourceManager.GetString("Type_of_adapter_type", resourceCulture);
+                return ResourceManager.GetString("Sector_flags_0_X2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Apple Universal Disk Image Format.
-        /// </summary>
-        internal static string Udif_Name {
+        internal static string Sector_CRC_plus_headers_0_X2 {
             get {
-                return ResourceManager.GetString("Udif_Name", resourceCulture);
+                return ResourceManager.GetString("Sector_CRC_plus_headers_0_X2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Spectrum Floppy Disk Image.
-        /// </summary>
-        internal static string UkvFdi_Name {
+        internal static string Data_size_in_image_0 {
             get {
-                return ResourceManager.GetString("UkvFdi_Name", resourceCulture);
+                return ResourceManager.GetString("Data_size_in_image_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unable to decompress hunk correctly, got {0} bytes, expected {1}.
-        /// </summary>
-        internal static string Unable_to_decompress_hunk_correctly_got_0_bytes_expected_1 {
+        internal static string Data_encoding_0_X2 {
             get {
-                return ResourceManager.GetString("Unable_to_decompress_hunk_correctly_got_0_bytes_expected_1", resourceCulture);
+                return ResourceManager.GetString("Data_encoding_0_X2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unable to find data file.
-        /// </summary>
-        internal static string Unable_to_find_data_file {
+        internal static string Sector_0_3_4_calculated_CRC_1_X2_differs_from_stored_CRC_2_X2 {
             get {
-                return ResourceManager.GetString("Unable_to_find_data_file", resourceCulture);
+                return ResourceManager.GetString("Sector_0_3_4_calculated_CRC_1_X2_differs_from_stored_CRC_2_X2", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unable to find UDIF signature..
-        /// </summary>
-        internal static string Unable_to_find_UDIF_signature {
+        internal static string LBA_0 {
             get {
-                return ResourceManager.GetString("Unable_to_find_UDIF_signature", resourceCulture);
+                return ResourceManager.GetString("LBA_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unexpected first session track type {0}.
-        /// </summary>
-        internal static string Unexpected_first_session_track_type_0 {
+        internal static string Sector_0_on_cylinder_1_head_2_is_duplicate_and_marked_so {
             get {
-                return ResourceManager.GetString("Unexpected_first_session_track_type_0", resourceCulture);
+                return ResourceManager.GetString("Sector_0_on_cylinder_1_head_2_is_duplicate_and_marked_so", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unexpected sector encountered. Found CHS {0},{1},{2} but expected {3},{4},{5}.
-        /// </summary>
-        internal static string Unexpected_sector_encountered_Found_CHS_0_1_2_but_expected_3_4_5 {
+        internal static string Sector_0_on_cylinder_1_head_2_is_duplicate_but_is_not_marked_so {
             get {
-                return ResourceManager.GetString("Unexpected_sector_encountered_Found_CHS_0_1_2_but_expected_3_4_5", resourceCulture);
+                return ResourceManager.GetString("Sector_0_on_cylinder_1_head_2_is_duplicate_but_is_not_marked_so", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown application &quot;{0}&quot;.
-        /// </summary>
-        internal static string Unknown_application_0 {
+        internal static string TeleDisk_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("Unknown_application_0", resourceCulture);
+                return ResourceManager.GetString("TeleDisk_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown.
-        /// </summary>
-        internal static string Unknown_cartridge_type {
+        internal static string TeleDisk_comments_0 {
             get {
-                return ResourceManager.GetString("Unknown_cartridge_type", resourceCulture);
+                return ResourceManager.GetString("TeleDisk_comments_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown.
-        /// </summary>
-        internal static string Unknown_chipset {
+        internal static string Udif_Name {
             get {
-                return ResourceManager.GetString("Unknown_chipset", resourceCulture);
+                return ResourceManager.GetString("Udif_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown chunk ID &quot;{0}&quot;, skipping....
-        /// </summary>
-        internal static string Unknown_chunk_ID_0_skipping {
+        internal static string Unable_to_find_UDIF_signature {
             get {
-                return ResourceManager.GetString("Unknown_chunk_ID_0_skipping", resourceCulture);
+                return ResourceManager.GetString("Unable_to_find_UDIF_signature", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown.
-        /// </summary>
-        internal static string Unknown_coprocessor {
+        internal static string Found_obsolete_UDIF_format {
             get {
-                return ResourceManager.GetString("Unknown_coprocessor", resourceCulture);
+                return ResourceManager.GetString("Found_obsolete_UDIF_format", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown.
-        /// </summary>
-        internal static string Unknown_country {
+        internal static string Reading_resource_fork {
             get {
-                return ResourceManager.GetString("Unknown_country", resourceCulture);
+                return ResourceManager.GetString("Reading_resource_fork", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown creator code &quot;{0}&quot;.
-        /// </summary>
-        internal static string Unknown_creator_code_0 {
+        internal static string Image_resource_fork_doesnt_contain_UDIF_block_chunks {
             get {
-                return ResourceManager.GetString("Unknown_creator_code_0", resourceCulture);
+                return ResourceManager.GetString("Image_resource_fork_doesnt_contain_UDIF_block_chunks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown file type {0}.
-        /// </summary>
-        internal static string Unknown_file_type_0 {
+        internal static string Reading_property_list {
             get {
-                return ResourceManager.GetString("Unknown_file_type_0", resourceCulture);
+                return ResourceManager.GetString("Reading_property_list", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown header.format = 0x{0:X2} value.
-        /// </summary>
-        internal static string Unknown_header_format_equals_0_value {
+        internal static string Could_not_parse_property_list {
             get {
-                return ResourceManager.GetString("Unknown_header_format_equals_0_value", resourceCulture);
+                return ResourceManager.GetString("Could_not_parse_property_list", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown incompatible features {0:X} enabled, not proceeding..
-        /// </summary>
-        internal static string Unknown_incompatible_features_0_enabled_not_proceeding {
+        internal static string Parsing_property_list {
             get {
-                return ResourceManager.GetString("Unknown_incompatible_features_0_enabled_not_proceeding", resourceCulture);
+                return ResourceManager.GetString("Parsing_property_list", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown.
-        /// </summary>
-        internal static string Unknown_licensee {
+        internal static string Could_not_retrieve_resource_fork {
             get {
-                return ResourceManager.GetString("Unknown_licensee", resourceCulture);
+                return ResourceManager.GetString("Could_not_retrieve_resource_fork", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown line &quot;{0}&quot; at line {1}.
-        /// </summary>
-        internal static string Unknown_line_0_at_line_1 {
+        internal static string Could_not_retrieve_block_chunks_array {
             get {
-                return ResourceManager.GetString("Unknown_line_0_at_line_1", resourceCulture);
+                return ResourceManager.GetString("Could_not_retrieve_block_chunks_array", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown long sector type, cannot write..
-        /// </summary>
-        internal static string Unknown_long_sector_type_cannot_write {
+        internal static string Could_not_retrieve_Name {
             get {
-                return ResourceManager.GetString("Unknown_long_sector_type_cannot_write", resourceCulture);
+                return ResourceManager.GetString("Could_not_retrieve_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown.
-        /// </summary>
-        internal static string Unknown_manufacturer {
+        internal static string Could_not_retrieve_Data {
             get {
-                return ResourceManager.GetString("Unknown_manufacturer", resourceCulture);
+                return ResourceManager.GetString("Could_not_retrieve_Data", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown read mode {0}.
-        /// </summary>
-        internal static string Unknown_read_mode_0 {
+        internal static string This_image_needs_the_resource_fork_to_work {
             get {
-                return ResourceManager.GetString("Unknown_read_mode_0", resourceCulture);
+                return ResourceManager.GetString("This_image_needs_the_resource_fork_to_work", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown.
-        /// </summary>
-        internal static string Unknown_region {
+        internal static string Could_not_retrieve_block_chunks {
             get {
-                return ResourceManager.GetString("Unknown_region", resourceCulture);
+                return ResourceManager.GetString("Could_not_retrieve_block_chunks", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown tag size.
-        /// </summary>
-        internal static string Unknown_tag_size {
+        internal static string Chunks_compressed_with_lzfse_are_not_yet_supported {
             get {
-                return ResourceManager.GetString("Unknown_tag_size", resourceCulture);
+                return ResourceManager.GetString("Chunks_compressed_with_lzfse_are_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown tmp_header.fmtByte = 0x{0:X2} value.
-        /// </summary>
-        internal static string Unknown_tmp_header_fmtByte_equals_0_value {
+        internal static string zlib_exception_on_chunk_starting_at_sector_0 {
             get {
-                return ResourceManager.GetString("Unknown_tmp_header_fmtByte_equals_0_value", resourceCulture);
+                return ResourceManager.GetString("zlib_exception_on_chunk_starting_at_sector_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown tmp_header.format = 0x{0:X2} value.
-        /// </summary>
-        internal static string Unknown_tmp_header_format_equals_0_value {
+        internal static string Tried_to_rewind_this_format_rewinded_on_writing {
             get {
-                return ResourceManager.GetString("Unknown_tmp_header_format_equals_0_value", resourceCulture);
+                return ResourceManager.GetString("Tried_to_rewind_this_format_rewinded_on_writing", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown track mode {0}.
-        /// </summary>
-        internal static string Unknown_track_mode_0 {
+        internal static string UkvFdi_Name {
             get {
-                return ResourceManager.GetString("Unknown_track_mode_0", resourceCulture);
+                return ResourceManager.GetString("UkvFdi_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unknown version 0x{0:X8}.
-        /// </summary>
-        internal static string Unknown_version_0_X8 {
+        internal static string Vdi_Name {
             get {
-                return ResourceManager.GetString("Unknown_version_0_X8", resourceCulture);
+                return ResourceManager.GetString("Vdi_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unordered tracks.
-        /// </summary>
-        internal static string Unordered_tracks {
+        internal static string Support_for_image_type_0_not_yet_implemented {
             get {
-                return ResourceManager.GetString("Unordered_tracks", resourceCulture);
+                return ResourceManager.GetString("Support_for_image_type_0_not_yet_implemented", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsorted tracks, cannot proceed..
-        /// </summary>
-        internal static string Unsorted_tracks_cannot_proceed {
+        internal static string Reading_Image_Block_Map {
             get {
-                return ResourceManager.GetString("Unsorted_tracks_cannot_proceed", resourceCulture);
+                return ResourceManager.GetString("Reading_Image_Block_Map", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported CHD version {0}.
-        /// </summary>
-        internal static string Unsupported_CHD_version_0 {
+        internal static string Reading_Image_Block_Map_took_0_ms {
             get {
-                return ResourceManager.GetString("Unsupported_CHD_version_0", resourceCulture);
+                return ResourceManager.GetString("Reading_Image_Block_Map_took_0_ms", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported chunk type 0x{0:X8} found.
-        /// </summary>
-        internal static string Unsupported_chunk_type_0_found {
+        internal static string Vhd_Name {
             get {
-                return ResourceManager.GetString("Unsupported_chunk_type_0_found", resourceCulture);
+                return ResourceManager.GetString("Vhd_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported compression {0}.
-        /// </summary>
-        internal static string Unsupported_compression_0 {
+        internal static string Header_checksum_equals_0_X8_calculated_equals_1_X8 {
             get {
-                return ResourceManager.GetString("Unsupported_compression_0", resourceCulture);
+                return ResourceManager.GetString("Header_checksum_equals_0_X8_calculated_equals_1_X8", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported feature.
-        /// </summary>
-        internal static string Unsupported_feature {
+        internal static string VirtualPC_plugin_Both_header_and_footer_are_corrupt_image_cannot_be_opened {
             get {
-                return ResourceManager.GetString("Unsupported_feature", resourceCulture);
+                return ResourceManager.GetString("VirtualPC_plugin_Both_header_and_footer_are_corrupt_image_cannot_be_opened", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported file type {0}.
-        /// </summary>
-        internal static string Unsupported_file_type_0 {
+        internal static string VirtualPC_plugin_Unknown_image_type_0_found {
             get {
-                return ResourceManager.GetString("Unsupported_file_type_0", resourceCulture);
+                return ResourceManager.GetString("VirtualPC_plugin_Unknown_image_type_0_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported hunk map version {0}.
-        /// </summary>
-        internal static string Unsupported_hunk_map_version_0 {
+        internal static string VirtualBox_for_unknown_OS_0 {
             get {
-                return ResourceManager.GetString("Unsupported_hunk_map_version_0", resourceCulture);
+                return ResourceManager.GetString("VirtualBox_for_unknown_OS_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported media format {0}.
-        /// </summary>
-        internal static string Unsupported_media_format_0 {
+        internal static string Unknown_version_0_X8 {
             get {
-                return ResourceManager.GetString("Unsupported_media_format_0", resourceCulture);
+                return ResourceManager.GetString("Unknown_version_0_X8", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported media tag {0}..
-        /// </summary>
-        internal static string Unsupported_media_tag_0 {
+        internal static string _5_6_or_7 {
             get {
-                return ResourceManager.GetString("Unsupported_media_tag_0", resourceCulture);
+                return ResourceManager.GetString("_5_6_or_7", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported media tag {0} for medium type {1}.
-        /// </summary>
-        internal static string Unsupported_media_tag_0_for_medium_type_1 {
+        internal static string Virtual_PC_for_unknown_OS_0 {
             get {
-                return ResourceManager.GetString("Unsupported_media_tag_0_for_medium_type_1", resourceCulture);
+                return ResourceManager.GetString("Virtual_PC_for_unknown_OS_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported protocol classified found in URI parent path: &quot;{0}&quot;.
-        /// </summary>
-        internal static string Unsupported_protocol_classified_found_in_URI_parent_path_0 {
+        internal static string Unknown_application_0 {
             get {
-                return ResourceManager.GetString("Unsupported_protocol_classified_found_in_URI_parent_path_0", resourceCulture);
+                return ResourceManager.GetString("Unknown_application_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported sector bitmap block flags (0x{0:X16}) found, not proceeding..
-        /// </summary>
-        internal static string Unsupported_sector_bitmap_block_flags_0_found_not_proceeding {
+        internal static string Dynamic_header_checksum_equals_0_X8_calculated_1_X8 {
             get {
-                return ResourceManager.GetString("Unsupported_sector_bitmap_block_flags_0_found_not_proceeding", resourceCulture);
+                return ResourceManager.GetString("Dynamic_header_checksum_equals_0_X8_calculated_1_X8", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported sector size.
-        /// </summary>
-        internal static string Unsupported_sector_size {
+        internal static string Filling_the_BAT_took_0_seconds {
             get {
-                return ResourceManager.GetString("Unsupported_sector_size", resourceCulture);
+                return ResourceManager.GetString("Filling_the_BAT_took_0_seconds", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported subchannel type {0}.
-        /// </summary>
-        internal static string Unsupported_subchannel_type_0 {
+        internal static string Bitmap_is_0_sectors {
             get {
-                return ResourceManager.GetString("Unsupported_subchannel_type_0", resourceCulture);
+                return ResourceManager.GetString("Bitmap_is_0_sectors", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported subchannel type {0} for track {1}.
-        /// </summary>
-        internal static string Unsupported_subchannel_type_0_for_track_1 {
+        internal static string Unsupported_protocol_classified_found_in_URI_parent_path_0 {
             get {
-                return ResourceManager.GetString("Unsupported_subchannel_type_0_for_track_1", resourceCulture);
+                return ResourceManager.GetString("Unsupported_protocol_classified_found_in_URI_parent_path_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported tag type {0}.
-        /// </summary>
-        internal static string Unsupported_tag_type_0 {
+        internal static string Possible_parent_path_0 {
             get {
-                return ResourceManager.GetString("Unsupported_tag_type_0", resourceCulture);
+                return ResourceManager.GetString("Possible_parent_path_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Unsupported track type {0}.
-        /// </summary>
-        internal static string Unsupported_track_type_0 {
+        internal static string VirtualPC_plugin_Cannot_find_parent_file_for_differencing_disk_image {
             get {
-                return ResourceManager.GetString("Unsupported_track_type_0", resourceCulture);
+                return ResourceManager.GetString("VirtualPC_plugin_Cannot_find_parent_file_for_differencing_disk_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to USA and Canada.
-        /// </summary>
-        internal static string USA_and_Canada {
+        internal static string VirtualPC_plugin_Cannot_find_parent_image_filter {
             get {
-                return ResourceManager.GetString("USA_and_Canada", resourceCulture);
+                return ResourceManager.GetString("VirtualPC_plugin_Cannot_find_parent_image_filter", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Use Mac OS X format byte.
-        /// </summary>
-        internal static string Use_Mac_OS_X_format_byte {
+        internal static string VirtualPC_plugin_Parent_image_is_not_a_Virtual_PC_disk_image {
             get {
-                return ResourceManager.GetString("Use_Mac_OS_X_format_byte", resourceCulture);
+                return ResourceManager.GetString("VirtualPC_plugin_Parent_image_is_not_a_Virtual_PC_disk_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Uses four-screen VRAM.
-        /// </summary>
-        internal static string Uses_four_screen_VRAM {
+        internal static string VirtualPC_plugin_Error_0_opening_parent_disk_image {
             get {
-                return ResourceManager.GetString("Uses_four_screen_VRAM", resourceCulture);
+                return ResourceManager.GetString("VirtualPC_plugin_Error_0_opening_parent_disk_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Uses horizontal mirroring.
-        /// </summary>
-        internal static string Uses_horizontal_mirroring {
+        internal static string VirtualPC_plugin_Parent_image_is_of_different_size {
             get {
-                return ResourceManager.GetString("Uses_horizontal_mirroring", resourceCulture);
+                return ResourceManager.GetString("VirtualPC_plugin_Parent_image_is_of_different_size", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Uses vertical mirroring.
-        /// </summary>
-        internal static string Uses_vertical_mirroring {
+        internal static string VirtualPC_plugin_Deprecated_image_type_found {
             get {
-                return ResourceManager.GetString("Uses_vertical_mirroring", resourceCulture);
+                return ResourceManager.GetString("VirtualPC_plugin_Deprecated_image_type_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Using DOS skewing.
-        /// </summary>
-        internal static string Using_DOS_skewing {
+        internal static string Vhdx_Name {
             get {
-                return ResourceManager.GetString("Using_DOS_skewing", resourceCulture);
+                return ResourceManager.GetString("Vhdx_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Using ProDOS skewing.
-        /// </summary>
-        internal static string Using_ProDOS_skewing {
+        internal static string VHDX_header_not_found {
             get {
-                return ResourceManager.GetString("Using_ProDOS_skewing", resourceCulture);
+                return ResourceManager.GetString("VHDX_header_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to VirtualBox Disk Image.
-        /// </summary>
-        internal static string Vdi_Name {
+        internal static string VHDX_region_table_not_found {
             get {
-                return ResourceManager.GetString("Vdi_Name", resourceCulture);
+                return ResourceManager.GetString("VHDX_region_table_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to VDMK hardware version..
-        /// </summary>
-        internal static string VDMK_hardware_version {
+        internal static string Found_unsupported_and_required_region_Guid_0_not_proceeding_with_image {
             get {
-                return ResourceManager.GetString("VDMK_hardware_version", resourceCulture);
+                return ResourceManager.GetString("Found_unsupported_and_required_region_Guid_0_not_proceeding_with_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Verifying data block type {0} at position {1}.
-        /// </summary>
-        internal static string Verifying_data_block_type_0_at_position_1 {
+        internal static string BAT_not_found_cannot_continue {
             get {
-                return ResourceManager.GetString("Verifying_data_block_type_0_at_position_1", resourceCulture);
+                return ResourceManager.GetString("BAT_not_found_cannot_continue", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Verifying deduplication table type {0} at position {1}.
-        /// </summary>
-        internal static string Verifying_deduplication_table_type_0_at_position_1 {
+        internal static string Metadata_not_found_cannot_continue {
             get {
-                return ResourceManager.GetString("Verifying_deduplication_table_type_0_at_position_1", resourceCulture);
+                return ResourceManager.GetString("Metadata_not_found_cannot_continue", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Version: {0}.{1}.
-        /// </summary>
-        internal static string Version_0_1 {
+        internal static string Found_unsupported_and_required_metadata_Guid_0_not_proceeding_with_image {
             get {
-                return ResourceManager.GetString("Version_0_1", resourceCulture);
+                return ResourceManager.GetString("Found_unsupported_and_required_metadata_Guid_0_not_proceeding_with_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to VirtualPC.
-        /// </summary>
-        internal static string Vhd_Name {
+        internal static string File_parameters_not_found {
             get {
-                return ResourceManager.GetString("Vhd_Name", resourceCulture);
+                return ResourceManager.GetString("File_parameters_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to VHDX header not found.
-        /// </summary>
-        internal static string VHDX_header_not_found {
+        internal static string Virtual_disk_size_not_found {
             get {
-                return ResourceManager.GetString("VHDX_header_not_found", resourceCulture);
+                return ResourceManager.GetString("Virtual_disk_size_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Microsoft VHDX.
-        /// </summary>
-        internal static string Vhdx_Name {
+        internal static string Logical_sector_size_not_found {
             get {
-                return ResourceManager.GetString("Vhdx_Name", resourceCulture);
+                return ResourceManager.GetString("Logical_sector_size_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to VHDX region table not found.
-        /// </summary>
-        internal static string VHDX_region_table_not_found {
+        internal static string Physical_sector_size_not_found {
             get {
-                return ResourceManager.GetString("VHDX_region_table_not_found", resourceCulture);
+                return ResourceManager.GetString("Physical_sector_size_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Virtual disk size not found..
-        /// </summary>
-        internal static string Virtual_disk_size_not_found {
+        internal static string Found_unsupported_and_required_parent_locator_type_0_not_proceeding_with_image {
             get {
-                return ResourceManager.GetString("Virtual_disk_size_not_found", resourceCulture);
+                return ResourceManager.GetString("Found_unsupported_and_required_parent_locator_type_0_not_proceeding_with_image", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Virtual PC for unknown OS &quot;{0}&quot;.
-        /// </summary>
-        internal static string Virtual_PC_for_unknown_OS_0 {
+        internal static string Parent_locator_not_found {
             get {
-                return ResourceManager.GetString("Virtual_PC_for_unknown_OS_0", resourceCulture);
+                return ResourceManager.GetString("Parent_locator_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Virtual98 Disk Image.
-        /// </summary>
-        internal static string Virtual98_Name {
+        internal static string Image_is_differential_but_parent_cannot_be_opened {
             get {
-                return ResourceManager.GetString("Virtual98_Name", resourceCulture);
+                return ResourceManager.GetString("Image_is_differential_but_parent_cannot_be_opened", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to VirtualBox for unknown OS &quot;{0}&quot;.
-        /// </summary>
-        internal static string VirtualBox_for_unknown_OS_0 {
+        internal static string Reading_Sector_Bitmap {
             get {
-                return ResourceManager.GetString("VirtualBox_for_unknown_OS_0", resourceCulture);
+                return ResourceManager.GetString("Reading_Sector_Bitmap", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (VirtualPC plugin): Both header and footer are corrupt, image cannot be opened..
-        /// </summary>
-        internal static string VirtualPC_plugin_Both_header_and_footer_are_corrupt_image_cannot_be_opened {
+        internal static string Unsupported_sector_bitmap_block_flags_0_found_not_proceeding {
             get {
-                return ResourceManager.GetString("VirtualPC_plugin_Both_header_and_footer_are_corrupt_image_cannot_be_opened", resourceCulture);
+                return ResourceManager.GetString("Unsupported_sector_bitmap_block_flags_0_found_not_proceeding", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (VirtualPC plugin): Cannot find parent file for differencing disk image.
-        /// </summary>
-        internal static string VirtualPC_plugin_Cannot_find_parent_file_for_differencing_disk_image {
+        internal static string Virtual98_Name {
             get {
-                return ResourceManager.GetString("VirtualPC_plugin_Cannot_find_parent_file_for_differencing_disk_image", resourceCulture);
+                return ResourceManager.GetString("Virtual98_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (VirtualPC plugin): Cannot find parent image filter.
-        /// </summary>
-        internal static string VirtualPC_plugin_Cannot_find_parent_image_filter {
+        internal static string VMware_Name {
             get {
-                return ResourceManager.GetString("VirtualPC_plugin_Cannot_find_parent_image_filter", resourceCulture);
+                return ResourceManager.GetString("VMware_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (VirtualPC plugin): Deprecated image type found. Please submit a bug with an example image..
-        /// </summary>
-        internal static string VirtualPC_plugin_Deprecated_image_type_found {
+        internal static string Type_of_adapter_type {
             get {
-                return ResourceManager.GetString("VirtualPC_plugin_Deprecated_image_type_found", resourceCulture);
+                return ResourceManager.GetString("Type_of_adapter_type", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (VirtualPC plugin): Error {0} opening parent disk image.
-        /// </summary>
-        internal static string VirtualPC_plugin_Error_0_opening_parent_disk_image {
+        internal static string VDMK_hardware_version {
             get {
-                return ResourceManager.GetString("VirtualPC_plugin_Error_0_opening_parent_disk_image", resourceCulture);
+                return ResourceManager.GetString("VDMK_hardware_version", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (VirtualPC plugin): Parent image is not a Virtual PC disk image.
-        /// </summary>
-        internal static string VirtualPC_plugin_Parent_image_is_not_a_Virtual_PC_disk_image {
+        internal static string VMware_SupportedOptions_Use_sparse_extents {
             get {
-                return ResourceManager.GetString("VirtualPC_plugin_Parent_image_is_not_a_Virtual_PC_disk_image", resourceCulture);
+                return ResourceManager.GetString("VMware_SupportedOptions_Use_sparse_extents", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (VirtualPC plugin): Parent image is of different size.
-        /// </summary>
-        internal static string VirtualPC_plugin_Parent_image_is_of_different_size {
+        internal static string Split_data_file_at_2GiB {
             get {
-                return ResourceManager.GetString("VirtualPC_plugin_Parent_image_is_of_different_size", resourceCulture);
+                return ResourceManager.GetString("Split_data_file_at_2GiB", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to (VirtualPC plugin): Unknown image type {0} found. Please submit a bug with an example image..
-        /// </summary>
-        internal static string VirtualPC_plugin_Unknown_image_type_0_found {
+        internal static string Please_open_VMDK_descriptor {
             get {
-                return ResourceManager.GetString("VirtualPC_plugin_Unknown_image_type_0_found", resourceCulture);
+                return ResourceManager.GetString("Please_open_VMDK_descriptor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to VMware disk image.
-        /// </summary>
-        internal static string VMware_Name {
+        internal static string Not_a_descriptor {
             get {
-                return ResourceManager.GetString("VMware_Name", resourceCulture);
+                return ResourceManager.GetString("Not_a_descriptor", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Use sparse extents..
-        /// </summary>
-        internal static string VMware_SupportedOptions_Use_sparse_extents {
+        internal static string Did_not_find_any_extent {
             get {
-                return ResourceManager.GetString("VMware_SupportedOptions_Use_sparse_extents", resourceCulture);
+                return ResourceManager.GetString("Did_not_find_any_extent", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to V.R. Technology VT01.
-        /// </summary>
-        internal static string VR_Technology_VT01 {
+        internal static string Raw_device_image_files_are_not_supported {
             get {
-                return ResourceManager.GetString("VR_Technology_VT01", resourceCulture);
+                return ResourceManager.GetString("Raw_device_image_files_are_not_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to V.R. Technology VT02.
-        /// </summary>
-        internal static string VR_Technology_VT02 {
+        internal static string Dunno_how_to_handle_0_extents {
             get {
-                return ResourceManager.GetString("VR_Technology_VT02", resourceCulture);
+                return ResourceManager.GetString("Dunno_how_to_handle_0_extents", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to V.R. Technology VT03.
-        /// </summary>
-        internal static string VR_Technology_VT03 {
+        internal static string Extent_file_0_not_found {
             get {
-                return ResourceManager.GetString("VR_Technology_VT03", resourceCulture);
+                return ResourceManager.GetString("Extent_file_0_not_found", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to V.R. Technology VT09.
-        /// </summary>
-        internal static string VR_Technology_VT09 {
+        internal static string Cannot_access_NOACCESS_extents {
             get {
-                return ResourceManager.GetString("VR_Technology_VT09", resourceCulture);
+                return ResourceManager.GetString("Cannot_access_NOACCESS_extents", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to V.R. Technology VT32.
-        /// </summary>
-        internal static string VR_Technology_VT32 {
+        internal static string Extent_0_is_too_small {
             get {
-                return ResourceManager.GetString("VR_Technology_VT32", resourceCulture);
+                return ResourceManager.GetString("Extent_0_is_too_small", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to V.R. Technology VT369.
-        /// </summary>
-        internal static string VR_Technology_VT369 {
+        internal static string _0_is_not_an_VMware_extent {
             get {
-                return ResourceManager.GetString("VR_Technology_VT369", resourceCulture);
+                return ResourceManager.GetString("_0_is_not_an_VMware_extent", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to VS Unisystem game.
-        /// </summary>
-        internal static string VS_Unisystem_game {
+        internal static string Extent_contains_incorrect_number_of_sectors_0_1_were_expected {
             get {
-                return ResourceManager.GetString("VS_Unisystem_game", resourceCulture);
+                return ResourceManager.GetString("Extent_contains_incorrect_number_of_sectors_0_1_were_expected", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Warning! This image is missing the last 150 sectors..
-        /// </summary>
-        internal static string Warning_This_image_is_missing_the_last_150_sectors {
+        internal static string Compressed_extents_are_not_yet_supported {
             get {
-                return ResourceManager.GetString("Warning_This_image_is_missing_the_last_150_sectors", resourceCulture);
+                return ResourceManager.GetString("Compressed_extents_are_not_yet_supported", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to d2f disk image.
-        /// </summary>
-        internal static string WCDiskImage_Name {
+        internal static string There_are_sparse_extents_but_there_is_no_header_to_find_the_grain_tables_cannot_proceed {
             get {
-                return ResourceManager.GetString("WCDiskImage_Name", resourceCulture);
+                return ResourceManager.GetString("There_are_sparse_extents_but_there_is_no_header_to_find_the_grain_tables_cannot_p" +
+                        "roceed", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to World.
-        /// </summary>
-        internal static string World {
+        internal static string Some_error_occurred_setting_GD_sizes {
             get {
-                return ResourceManager.GetString("World", resourceCulture);
+                return ResourceManager.GetString("Some_error_occurred_setting_GD_sizes", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Write each track to a separate file..
-        /// </summary>
-        internal static string Write_each_track_to_a_separate_file {
+        internal static string _0_sectors_in_1_grains_in_2_tables {
             get {
-                return ResourceManager.GetString("Write_each_track_to_a_separate_file", resourceCulture);
+                return ResourceManager.GetString("_0_sectors_in_1_grains_in_2_tables", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing Aaru Metadata block to position {0}.
-        /// </summary>
-        internal static string Writing_Aaru_Metadata_block_to_position_0 {
+        internal static string Reading_grain_directory {
             get {
-                return ResourceManager.GetString("Writing_Aaru_Metadata_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Reading_grain_directory", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing apple sector tag block to position {0}.
-        /// </summary>
-        internal static string Writing_apple_sector_tag_block_to_position_0 {
+        internal static string Reading_grain_tables {
             get {
-                return ResourceManager.GetString("Writing_apple_sector_tag_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Reading_grain_tables", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing CD MODE2 subheaders block to position {0}.
-        /// </summary>
-        internal static string Writing_CD_MODE2_subheaders_block_to_position_0 {
+        internal static string Cannot_find_parent_0 {
             get {
-                return ResourceManager.GetString("Writing_CD_MODE2_subheaders_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Cannot_find_parent_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing CD sector corrected prefix block to position {0}.
-        /// </summary>
-        internal static string Writing_CD_sector_corrected_prefix_block_to_position_0 {
+        internal static string Error_0_opening_parent_1 {
             get {
-                return ResourceManager.GetString("Writing_CD_sector_corrected_prefix_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Error_0_opening_parent_1", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing CD sector corrected suffix block to position {0}.
-        /// </summary>
-        internal static string Writing_CD_sector_corrected_suffix_block_to_position_0 {
+        internal static string Invalid_adapter_type_0 {
             get {
-                return ResourceManager.GetString("Writing_CD_sector_corrected_suffix_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Invalid_adapter_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing CD sector prefix block to position {0}.
-        /// </summary>
-        internal static string Writing_CD_sector_prefix_block_to_position_0 {
+        internal static string Invalid_value_for_hwversion_option {
             get {
-                return ResourceManager.GetString("Writing_CD_sector_prefix_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_hwversion_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing CD sector suffix block to position {0}.
-        /// </summary>
-        internal static string Writing_CD_sector_suffix_block_to_position_0 {
+        internal static string Splitted_images_not_yet_implemented {
             get {
-                return ResourceManager.GetString("Writing_CD_sector_suffix_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Splitted_images_not_yet_implemented", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing CD subchannel block to position {0}.
-        /// </summary>
-        internal static string Writing_CD_subchannel_block_to_position_0 {
+        internal static string Invalid_value_for_sparse_option {
             get {
-                return ResourceManager.GetString("Writing_CD_subchannel_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Invalid_value_for_sparse_option", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing checksum block to position {0}.
-        /// </summary>
-        internal static string Writing_checksum_block_to_position_0 {
+        internal static string Sparse_images_not_yet_implemented {
             get {
-                return ResourceManager.GetString("Writing_checksum_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Sparse_images_not_yet_implemented", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing CICM XML block to position {0}.
-        /// </summary>
-        internal static string Writing_CICM_XML_block_to_position_0 {
+        internal static string WCDiskImage_Name {
             get {
-                return ResourceManager.GetString("Writing_CICM_XML_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("WCDiskImage_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing compact disc indexes to position {0}.
-        /// </summary>
-        internal static string Writing_compact_disc_indexes_to_position_0 {
+        internal static string Detected_WC_DISK_IMAGE_with_0_heads_1_tracks_and_2_sectors_per_track {
             get {
-                return ResourceManager.GetString("Writing_compact_disc_indexes_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Detected_WC_DISK_IMAGE_with_0_heads_1_tracks_and_2_sectors_per_track", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing CompactDisc sector prefix DDT to position {0}.
-        /// </summary>
-        internal static string Writing_CompactDisc_sector_prefix_DDT_to_position_0 {
+        internal static string Extra_track_1_head_0_present_reading {
             get {
-                return ResourceManager.GetString("Writing_CompactDisc_sector_prefix_DDT_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Extra_track_1_head_0_present_reading", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing CompactDisc sector suffix DDT to position {0}.
-        /// </summary>
-        internal static string Writing_CompactDisc_sector_suffix_DDT_to_position_0 {
+        internal static string Extra_track_1_head_1_present_reading {
             get {
-                return ResourceManager.GetString("Writing_CompactDisc_sector_suffix_DDT_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Extra_track_1_head_1_present_reading", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing decrypted DVD title key block to position {0}.
-        /// </summary>
-        internal static string Writing_decrypted_DVD_title_key_block_to_position_0 {
+        internal static string Extra_track_2_head_0_present_reading {
             get {
-                return ResourceManager.GetString("Writing_decrypted_DVD_title_key_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Extra_track_2_head_0_present_reading", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing dump hardware block to position {0}.
-        /// </summary>
-        internal static string Writing_dump_hardware_block_to_position_0 {
+        internal static string Extra_track_2_head_1_present_reading {
             get {
-                return ResourceManager.GetString("Writing_dump_hardware_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Extra_track_2_head_1_present_reading", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing DVD CPI_MAI block to position {0}.
-        /// </summary>
-        internal static string Writing_DVD_CPI_MAI_block_to_position_0 {
+        internal static string Comment_present_reading {
             get {
-                return ResourceManager.GetString("Writing_DVD_CPI_MAI_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Comment_present_reading", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing geometry block to position {0}.
-        /// </summary>
-        internal static string Writing_geometry_block_to_position_0 {
+        internal static string Invalid_sector_type_0_encountered {
             get {
-                return ResourceManager.GetString("Writing_geometry_block_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Invalid_sector_type_0_encountered", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing header.
-        /// </summary>
-        internal static string Writing_header {
+        internal static string Directory_listing_present_reading {
             get {
-                return ResourceManager.GetString("Writing_header", resourceCulture);
+                return ResourceManager.GetString("Directory_listing_present_reading", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing index to position {0}.
-        /// </summary>
-        internal static string Writing_index_to_position_0 {
+        internal static string reading_bad_sector_0_1_2_3 {
             get {
-                return ResourceManager.GetString("Writing_index_to_position_0", resourceCulture);
+                return ResourceManager.GetString("reading_bad_sector_0_1_2_3", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing media tags is not supported..
-        /// </summary>
-        internal static string Writing_media_tags_is_not_supported {
+        internal static string Unexpected_sector_encountered_Found_CHS_0_1_2_but_expected_3_4_5 {
             get {
-                return ResourceManager.GetString("Writing_media_tags_is_not_supported", resourceCulture);
+                return ResourceManager.GetString("Unexpected_sector_encountered_Found_CHS_0_1_2_but_expected_3_4_5", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing metadata to position {0}.
-        /// </summary>
-        internal static string Writing_metadata_to_position_0 {
+        internal static string CHS_0_1_2_CRC_mismatch_stored_CRC_3_X4_calculated_CRC_4_X4 {
             get {
-                return ResourceManager.GetString("Writing_metadata_to_position_0", resourceCulture);
+                return ResourceManager.GetString("CHS_0_1_2_CRC_mismatch_stored_CRC_3_X4_calculated_CRC_4_X4", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing sectors with tags is not supported..
-        /// </summary>
-        internal static string Writing_sectors_with_tags_is_not_supported {
+        internal static string ZZZRawImage_Name {
             get {
-                return ResourceManager.GetString("Writing_sectors_with_tags_is_not_supported", resourceCulture);
+                return ResourceManager.GetString("ZZZRawImage_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing tag type {0} to position {1}.
-        /// </summary>
-        internal static string Writing_tag_type_0_to_position_1 {
+        internal static string Found_media_tag_0 {
             get {
-                return ResourceManager.GetString("Writing_tag_type_0_to_position_1", resourceCulture);
+                return ResourceManager.GetString("Found_media_tag_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing tape files to position {0}.
-        /// </summary>
-        internal static string Writing_tape_files_to_position_0 {
+        internal static string Raw_disk_image_contains_a_disk_of_type_0 {
             get {
-                return ResourceManager.GetString("Writing_tape_files_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Raw_disk_image_contains_a_disk_of_type_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing tape partitions to position {0}.
-        /// </summary>
-        internal static string Writing_tape_partitions_to_position_0 {
+        internal static string The_specified_sector_size_does_not_correspond_with_the_requested_image_extension {
             get {
-                return ResourceManager.GetString("Writing_tape_partitions_to_position_0", resourceCulture);
+                return ResourceManager.GetString("The_specified_sector_size_does_not_correspond_with_the_requested_image_extension", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing tracks to position {0}.
-        /// </summary>
-        internal static string Writing_tracks_to_position_0 {
+        internal static string Found_Aaru_Metadata_block_at_position_0 {
             get {
-                return ResourceManager.GetString("Writing_tracks_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Found_Aaru_Metadata_block_at_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Writing user data DDT to position {0}.
-        /// </summary>
-        internal static string Writing_user_data_DDT_to_position_0 {
+        internal static string Exception_0_processing_Aaru_Metadata_block {
             get {
-                return ResourceManager.GetString("Writing_user_data_DDT_to_position_0", resourceCulture);
+                return ResourceManager.GetString("Exception_0_processing_Aaru_Metadata_block", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to zlib exception on chunk starting at sector {0}.
-        /// </summary>
-        internal static string zlib_exception_on_chunk_starting_at_sector_0 {
+        internal static string Writing_Aaru_Metadata_block_to_position_0 {
             get {
-                return ResourceManager.GetString("zlib_exception_on_chunk_starting_at_sector_0", resourceCulture);
+                return ResourceManager.GetString("Writing_Aaru_Metadata_block_to_position_0", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Raw Disk Image.
-        /// </summary>
-        internal static string ZZZRawImage_Name {
+        internal static string A2R_Name {
             get {
-                return ResourceManager.GetString("ZZZRawImage_Name", resourceCulture);
+                return ResourceManager.GetString("A2R_Name", resourceCulture);
             }
         }
     }
diff --git a/Aaru.Images/Localization/Localization.resx b/Aaru.Images/Localization/Localization.resx
index 33fae77eb..27011c819 100644
--- a/Aaru.Images/Localization/Localization.resx
+++ b/Aaru.Images/Localization/Localization.resx
@@ -2912,4 +2912,7 @@
   <data name="Writing_Aaru_Metadata_block_to_position_0" xml:space="preserve">
     <value>Writing Aaru Metadata block to position {0}</value>
   </data>
+  <data name="A2R_Name" xml:space="preserve">
+    <value>A2R</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/Aaru.Images/SuperCardPro/Read.cs b/Aaru.Images/SuperCardPro/Read.cs
index 2102106d2..f6d11eb69 100644
--- a/Aaru.Images/SuperCardPro/Read.cs
+++ b/Aaru.Images/SuperCardPro/Read.cs
@@ -255,13 +255,12 @@ public ErrorNumber Open(IFilter imageFilter)
                 _imageInfo.SectorsPerTrack = 18;
 
                 break;
-            case ScpDiskType.TandySSSD:  break;
-            case ScpDiskType.TandySSDD:  break;
-            case ScpDiskType.TandyDSSD:  break;
-            case ScpDiskType.TandyDSDD:  break;
-            case ScpDiskType.Ti994A:     break;
-            case ScpDiskType.RolandD20:  break;
-            case ScpDiskType.AmstradCPC: break;
+            case ScpDiskType.TandySSDD:  return ErrorNumber.NotImplemented;
+            case ScpDiskType.TandyDSSD:  return ErrorNumber.NotImplemented;
+            case ScpDiskType.TandyDSDD:  return ErrorNumber.NotImplemented;
+            case ScpDiskType.Ti994A:     return ErrorNumber.NotImplemented;
+            case ScpDiskType.RolandD20:  return ErrorNumber.NotImplemented;
+            case ScpDiskType.AmstradCPC: return ErrorNumber.NotImplemented;
             case ScpDiskType.Generic360K:
                 _imageInfo.MediaType = MediaType.DOS_525_DS_DD_9;
                 _imageInfo.Cylinders = (uint)int.Max(((Header.end + 1) / 2), 40);
diff --git a/Aaru.Images/SuperCardPro/Write.cs b/Aaru.Images/SuperCardPro/Write.cs
index 8ea23f378..7c91d80f8 100644
--- a/Aaru.Images/SuperCardPro/Write.cs
+++ b/Aaru.Images/SuperCardPro/Write.cs
@@ -223,7 +223,7 @@ public ErrorNumber WriteFluxCapture(ulong indexResolution, ulong dataResolution,
             IsRevolutionsSet   = true;
         }
 
-        // SCP can only have the same number of revolutions for every tracks
+        // SCP can only have the same number of revolutions for all tracks
         if(Header.revolutions != scpIndices.Count)
             return ErrorNumber.NotSupported;
 
diff --git a/Aaru/Commands/Image/Convert.cs b/Aaru/Commands/Image/Convert.cs
index 05a763bca..cdb83645b 100644
--- a/Aaru/Commands/Image/Convert.cs
+++ b/Aaru/Commands/Image/Convert.cs
@@ -1475,7 +1475,7 @@ or MediaType.Playdia or MediaType.Pippin or MediaType.VideoNow or MediaType.Vide
                                                                           out byte[] dataBuffer);
 
                                                 outputFlux.WriteFluxCapture(indexResolution, dataResolution,
-                                                                            indexBuffer, dataBuffer, head, track, 0,
+                                                                            indexBuffer, dataBuffer, head, track, subTrackIndex,
                                                                             captureIndex);
                                             }
                                         }