// /***************************************************************************
// Aaru Data Preservation Suite
// ----------------------------------------------------------------------------
//
// Filename       : Features.cs
// Author(s)      : Natalia Portillo <claunia@claunia.com>
//
// Component      : Device structures decoders.
//
// --[ Description ] ----------------------------------------------------------
//
//     Decodes SCSI MMC feature structures.
//
// --[ 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 Natalia Portillo
// ****************************************************************************/


using System;
using System.Collections.Generic;
using System.Text;
using Aaru.CommonTypes.Structs.Devices.SCSI;
using Aaru.Helpers;
using Aaru.Localization;

// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable UnusedType.Global
// ReSharper disable NotAccessedField.Global
// ReSharper disable InconsistentNaming
// ReSharper disable MemberCanBeInternal
// ReSharper disable UnusedMember.Global

namespace Aaru.Decoders.SCSI.MMC;

/// <summary>MMC Feature enumeration</summary>
public enum FeatureNumber : ushort
{
    /// <summary>Lists all profiles</summary>
    ProfileList = 0x0000,
    /// <summary>Mandatory behaviour</summary>
    Core = 0x0001,
    /// <summary>Operational changes</summary>
    Morphing = 0x0002,
    /// <summary>Removable medium</summary>
    Removable = 0x0003,
    /// <summary>Ability to control write protection status</summary>
    WriteProtect = 0x0004,
    /// <summary>Ability to read sectors with random addressing</summary>
    RandomRead = 0x0010,
    /// <summary>Reads on OSTA Multi-Read</summary>
    MultiRead = 0x001D,
    /// <summary>Able to read CD structures</summary>
    CDRead = 0x001E,
    /// <summary>Able to read DVD structures</summary>
    DVDRead = 0x001F,
    /// <summary>Ability to write sectors with random addressing</summary>
    RandomWrite = 0x0020,
    /// <summary>Ability to sequentially write</summary>
    IncrementalWrite = 0x0021,
    /// <summary>Support for media that requires erase before write</summary>
    SectorErasable = 0x0022,
    /// <summary>Supports formatting media</summary>
    Formattable = 0x0023,
    /// <summary>Ability to provide defect-free space</summary>
    HardwareDefectMgmt = 0x0024,
    /// <summary>Supports for write-once media in random order</summary>
    WriteOnce = 0x0025,
    /// <summary>Supports for media that shall be written from blocking boundaries</summary>
    RestrictedOverwrite = 0x0026,
    /// <summary>Supports high speed CD-RW</summary>
    CDRWCAV = 0x0027,
    /// <summary>Read and optionally write MRW</summary>
    MRW = 0x0028,
    /// <summary>Ability to control RECOVERED ERROR reporting</summary>
    EnDefectReport = 0x0029,
    /// <summary>Ability to recognize, read and optionally write DVD+RW</summary>
    DVDRWPlus = 0x002A,
    /// <summary>Ability to read DVD+R</summary>
    DVDRPlus = 0x002B,
    RigidOverWrite = 0x002C,
    /// <summary>Ability to write CD in Track-at-Once</summary>
    CDTAO = 0x002D,
    /// <summary>Ability to write CD in Session-at-Once or RAW</summary>
    CDMastering = 0x002E,
    /// <summary>Ability to write DVD structures</summary>
    DVDRWrite = 0x002F,
    /// <summary>Ability to read DDCD</summary>
    DDCD = 0x0030,
    /// <summary>Ability to write DDCD-R</summary>
    DDCDR = 0x0031,
    /// <summary>Ability to write DDCD-RW</summary>
    DDCDRW = 0x0032,
    /// <summary>Ability to record in layer jump mode</summary>
    LayerJump = 0x0033,
    /// <summary>Ability to perform Layer Jump recording on Rigid Restricted Overwrite</summary>
    LJRigid = 0x0034,
    /// <summary>Ability to stop the long immediate operation</summary>
    StopLong = 0x0035,
    /// <summary>Ability to report CD-RW media sub-types supported for write</summary>
    CDRWMediaWrite = 0x0037,
    /// <summary>Logical block overwrite service on BD-R formatted as SRM+POW</summary>
    BDRPOW = 0x0038,
    /// <summary>Ability to read DVD+RW DL</summary>
    DVDRWDLPlus = 0x003A,
    /// <summary>Ability to read DVD+R DL</summary>
    DVDRDLPlus = 0x003B,
    /// <summary>Ability to read BD discs</summary>
    BDRead = 0x0040,
    /// <summary>Ability to write BD discs</summary>
    BDWrite = 0x0041,
    /// <summary>Timely, Safe Recording</summary>
    TSR = 0x0042,
    /// <summary>Ability to read HD DVD</summary>
    HDDVDRead = 0x0050,
    /// <summary>Ability to write HD DVD</summary>
    HDDVDWrite = 0x0051,
    /// <summary>Ability to write HD DVD-RW fragmented</summary>
    HDDVDRWFragment = 0x0052,
    /// <summary>Supports some Hybrid Discs</summary>
    Hybrid = 0x0080,
    /// <summary>Host and device directed power management</summary>
    PowerMgmt = 0x0100,
    /// <summary>Supports S.M.A.R.T.</summary>
    SMART = 0x0101,
    /// <summary>Single machanism multiple disc changer</summary>
    Changer = 0x0102,
    /// <summary>Ability to play CD audio to an analogue output</summary>
    CDAudioExt = 0x0103,
    /// <summary>Ability to accept new microcode</summary>
    MicrocodeUpgrade = 0x0104,
    /// <summary>Ability to respond to all commands within a specific time</summary>
    Timeout = 0x0105,
    /// <summary>Supports DVD CSS/CPPM</summary>
    CSS = 0x0106,
    /// <summary>Ability to read and write using host requested performance parameters</summary>
    RTS = 0x0107,
    /// <summary>Drive has a unique identifier</summary>
    DriveSerial = 0x0108,
    /// <summary>Ability to return unique Media Serial Number</summary>
    MediaSerial = 0x0109,
    /// <summary>Ability to read and/or write DCBs</summary>
    DCBs = 0x010A,
    /// <summary>Supports DVD CPRM</summary>
    CPRM = 0x010B,
    /// <summary>Firmware creation date report</summary>
    FirmwareInfo = 0x010C,
    /// <summary>Ability to decode and optionally encode AACS</summary>
    AACS = 0x010D,
    /// <summary>Ability to perform DVD CSS managed recording</summary>
    CSSManagedRec = 0x010E,
    /// <summary>Ability to decode and optionally encode VCPS</summary>
    VCPS = 0x0110,
    /// <summary>Supports SecurDisc</summary>
    SecurDisc = 0x0113,
    /// <summary>TCG Optical Security Subsystem Class</summary>
    OSSC = 0x0142
}

/// <summary>MMC Profile enumeration</summary>
public enum ProfileNumber : ushort
{
    /// <summary>Not to use</summary>
    Reserved = 0x0000,
    /// <summary>Non-removable disk profile</summary>
    NonRemovable = 0x0001,
    /// <summary>Rewritable with removable media</summary>
    Removable = 0x0002,
    /// <summary>Magneto-Optical with sector erase</summary>
    MOErasable = 0x0003,
    /// <summary>Optical write once</summary>
    OpticalWORM = 0x0004,
    /// <summary>Advance Storage - Magneto-Optical</summary>
    ASMO = 0x0005,
    /// <summary>Read-only Compact Disc</summary>
    CDROM = 0x0008,
    /// <summary>Write-once Compact Disc</summary>
    CDR = 0x0009,
    /// <summary>Re-writable Compact Disc</summary>
    CDRW = 0x000A,
    /// <summary>Read-only DVD</summary>
    DVDROM = 0x0010,
    /// <summary>Write-once sequentially recorded DVD-R</summary>
    DVDRSeq = 0x0011,
    /// <summary>DVD-RAM</summary>
    DVDRAM = 0x0012,
    /// <summary>Restricted overwrite DVD-RW</summary>
    DVDRWRes = 0x0013,
    /// <summary>Sequential recording DVD-RW</summary>
    DVDRWSeq = 0x0014,
    /// <summary>Sequential recording DVD-R DL</summary>
    DVDRDLSeq = 0x0015,
    /// <summary>Layer jump recording DVD-R DL</summary>
    DVDRDLJump = 0x0016,
    /// <summary>DVD-RW DL</summary>
    DVDRWDL = 0x0017,
    /// <summary>DVD-Download</summary>
    DVDDownload = 0x0018,
    /// <summary>DVD+RW</summary>
    DVDRWPlus = 0x001A,
    /// <summary>DVD+R</summary>
    DVDRPlus = 0x001B,
    /// <summary>DDCD-ROM</summary>
    DDCDROM = 0x0020,
    /// <summary>DDCD-R</summary>
    DDCDR = 0x0021,
    /// <summary>DDCD-RW</summary>
    DDCDRW = 0x0022,
    /// <summary>DVD+RW DL</summary>
    DVDRWDLPlus = 0x002A,
    /// <summary>DVD+R DL</summary>
    DVDRDLPlus = 0x002B,
    /// <summary>BD-ROM</summary>
    BDROM = 0x0040,
    /// <summary>BD-R SRM</summary>
    BDRSeq = 0x0041,
    /// <summary>BD-R RRM</summary>
    BDRRdm = 0x0042,
    /// <summary>BD-RE</summary>
    BDRE = 0x0043,
    /// <summary>HD DVD-ROM</summary>
    HDDVDROM = 0x0050,
    /// <summary>HD DVD-R</summary>
    HDDVDR = 0x0051,
    /// <summary>HD DVD-RAM</summary>
    HDDVDRAM = 0x0052,
    /// <summary>HD DVD-RW</summary>
    HDDVDRW = 0x0053,
    /// <summary>HD DVD-R DL</summary>
    HDDVDRDL = 0x0058,
    /// <summary>HD DVD-RW DL</summary>
    HDDVDRWDL = 0x005A,
    /// <summary>HDBurn CD-ROM</summary>
    HDBURNROM = 0x0080,
    /// <summary>HDBurn CD-R</summary>
    HDBURNR = 0x0081,
    /// <summary>HDBurn CD-RW</summary>
    HDBURNRW = 0x0082,
    /// <summary>Drive does not conform to any profiles</summary>
    Unconforming = 0xFFFF
}

public struct Profile
{
    public ProfileNumber Number;
    public bool          Current;
}

/// <summary>Profile List Feature (0000h)</summary>
public struct Feature_0000
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>All supported profiles</summary>
    public Profile[] Profiles;
}

/// <summary>Core Feature (0001h)</summary>
public struct Feature_0001
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Currently in-use physical interface standard</summary>
    public PhysicalInterfaces PhysicalInterfaceStandard;
    /// <summary>Supports EVPD, Page Code and 16-bit Allocation Length as defined in SPC-3</summary>
    public bool INQ2;
    /// <summary>Supports Device Busy Event</summary>
    public bool DBE;
}

/// <summary>Morphing Feature (0002h)</summary>
public struct Feature_0002
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports Operational Change Request/Nofitication Class Events of GET EVENT/STATUS NOTIFICATION</summary>
    public bool OCEvent;
    /// <summary>Supports asynchronous GET EVENT/STATUS NOTIFICATION</summary>
    public bool Async;
}

/// <summary>Removable Medium Feature (0003h)</summary>
public struct Feature_0003
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Mechanism type</summary>
    public byte LoadingMechanismType;
    /// <summary>Drive is able to load the medium</summary>
    public bool Load;
    /// <summary>Device can eject medium</summary>
    public bool Eject;
    /// <summary>Device starts in medium ejection/insertion allow</summary>
    public bool PreventJumper;
    /// <summary>Reports Device Busy Class events during medium loading/unloading</summary>
    public bool DBML;
    /// <summary>Medium is currently locked</summary>
    public bool Lock;
}

/// <summary>Write Protect Feature (0004h)</summary>
public struct Feature_0004
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Drive can read/write Disc Write Protect PAC on BD-R/-RE media</summary>
    public bool DWP;
    /// <summary>Supports reading/writing Write Inhibit DCB on DVD+RW media.</summary>
    public bool WDCB;
    /// <summary>Supports PWP status</summary>
    public bool SPWP;
    /// <summary>Supports SWPP bit of mode page 1Dh</summary>
    public bool SSWPP;
}

/// <summary>Random Readable Feature (0010h)</summary>
public struct Feature_0010
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Bytes per logical block</summary>
    public uint LogicalBlockSize;
    /// <summary>Number of logical blocks per device readable unit</summary>
    public ushort Blocking;
    /// <summary>Read/Write Error Recovery page is present</summary>
    public bool PP;
}

/// <summary>Multi-Read Feature (001Dh)</summary>
public struct Feature_001D
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>CD Read Feature (001Eh)</summary>
public struct Feature_001E
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports DAP bit in READ CD and READ CD MSF</summary>
    public bool DAP;
    /// <summary>Supports C2 Error Pointers</summary>
    public bool C2;
    /// <summary>Can read CD-Text with READ TOC/PMA/ATIP</summary>
    public bool CDText;
}

/// <summary>DVD Read Feature (001Fh)</summary>
public struct Feature_001F
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Compliant with DVD Multi Drive Read-only specifications</summary>
    public bool MULTI110;
    /// <summary>Supports reading all DVD-RW DL</summary>
    public bool DualRW;
    /// <summary>Supports reading all DVD-R DL including remapping</summary>
    public bool DualR;
}

/// <summary>Random Writable Feature (0020h)</summary>
public struct Feature_0020
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Last logical block address</summary>
    public uint LastLBA;
    /// <summary>Bytes per logical block</summary>
    public uint LogicalBlockSize;
    /// <summary>Number of logical blocks per device readable unit</summary>
    public ushort Blocking;
    /// <summary>Read/Write Error Recovery page is present</summary>
    public bool PP;
}

/// <summary>Incremental Streaming Writable Feature (0021h)</summary>
public struct Feature_0021
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Bitmask of supported data types</summary>
    public ushort DataTypeSupported;
    /// <summary>Can report Track Resources Information of READ DISC INFORMATION</summary>
    public bool TRIO;
    /// <summary>Supports Address Mode in RESERVE TRACK</summary>
    public bool ARSV;
    /// <summary>Zero loss linking</summary>
    public bool BUF;
    /// <summary>Logical blocks per link</summary>
    public byte[] LinkSizes;
}

/// <summary>Sector Erasable Feature (0022h)</summary>
public struct Feature_0022
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>Formattable Feature (0023h)</summary>
public struct Feature_0023
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports formatting BD-RE without spare area</summary>
    public bool RENoSA;
    /// <summary>Supports expansion of the spare area on BD-RE</summary>
    public bool Expand;
    /// <summary>Supports FORMAT type 30h sub-type 11b</summary>
    public bool QCert;
    /// <summary>Supports FORMAT type 30h sub-type 10b</summary>
    public bool Cert;
    /// <summary>Supports FORMAT type 18h</summary>
    public bool FRF;
    /// <summary>Supports FORMAT type 00h/32h sub-type 10b on BD-R</summary>
    public bool RRM;
}

/// <summary>Hardware Defect Management Feature (0024h)</summary>
public struct Feature_0024
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports READ DISC STRUCTURE with Format Code 0Ah (Spare Area Information)</summary>
    public bool SSA;
}

/// <summary>Write Once Feature (0025h)</summary>
public struct Feature_0025
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Bytes per logical block</summary>
    public uint LogicalBlockSize;
    /// <summary>Number of logical blocks per device readable unit</summary>
    public ushort Blocking;
    /// <summary>Read/Write Error Recovery page is present</summary>
    public bool PP;
}

/// <summary>Restricted Overwrite Feature (0026h)</summary>
public struct Feature_0026
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>CD-RW CAV Write Feature (0027h)</summary>
public struct Feature_0027
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>MRW Feature (0028h)</summary>
public struct Feature_0028
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Can read DVD+MRW discs</summary>
    public bool DVDPRead;
    /// <summary>Can write DVD+MRW discs</summary>
    public bool DVDPWrite;
    /// <summary>Can format and write to CD-MRW discs</summary>
    public bool Write;
}

/// <summary>Enhanced Defect Reporting Feature (0029h)</summary>
public struct Feature_0029
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports DRT-DM</summary>
    public bool DRTDM;
    /// <summary>Maximum number of DBI cache zones device can handle separately</summary>
    public byte DBICacheZones;
    /// <summary>Number of entries in worst case to case DBI overflow</summary>
    public ushort Entries;
}

/// <summary>DVD+RW Feature (002Ah)</summary>
public struct Feature_002A
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Can format DVD+RW discs</summary>
    public bool Write;
    /// <summary>FORMAT UNIT supports quick start formatting</summary>
    public bool QuickStart;
    /// <summary>Drive only supports read compatibility stop</summary>
    public bool CloseOnly;
}

/// <summary>DVD+R Feature (002Bh)</summary>
public struct Feature_002B
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Can write DVD+R</summary>
    public bool Write;
}

/// <summary>Rigid Restricted Overwrite Feature (002Ch)</summary>
public struct Feature_002C
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Can generate Defect Status Data during formatting</summary>
    public bool DSDG;
    /// <summary>Can read Defect Status Data recorded on medium</summary>
    public bool DSDR;
    /// <summary>Supports writing on an intermediate state Session and quick formatting</summary>
    public bool Intermediate;
    /// <summary>Supports BLANK command types 00h and 01h</summary>
    public bool Blank;
}

/// <summary>CD Track at Once Feature (002Dh)</summary>
public struct Feature_002D
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports zero loss linking</summary>
    public bool BUF;
    /// <summary>Supports writing R-W subchannels in raw mode</summary>
    public bool RWRaw;
    /// <summary>Supports writing R-W subchannels in packed mode</summary>
    public bool RWPack;
    /// <summary>Can perform test writes</summary>
    public bool TestWrite;
    /// <summary>Supports overwriting a TAO track with another</summary>
    public bool CDRW;
    /// <summary>Can write R-W subchannels with user provided data</summary>
    public bool RWSubchannel;
    /// <summary>Bitmask of supported data types</summary>
    public ushort DataTypeSupported;
}

/// <summary>CD Mastering (Session at Once) Feature (002Eh)</summary>
public struct Feature_002E
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports zero loss linking</summary>
    public bool BUF;
    /// <summary>Can write in Session at Once</summary>
    public bool SAO;
    /// <summary>Can write multi-session in RAW</summary>
    public bool RAWMS;
    /// <summary>Can write in RAW</summary>
    public bool RAW;
    /// <summary>Can perform test writes</summary>
    public bool TestWrite;
    /// <summary>Can overwrite previously recorded data</summary>
    public bool CDRW;
    /// <summary>Can write R-W subchannels with user provided data</summary>
    public bool RW;
    /// <summary>Maximum length of a Cue Sheet for Session at Once</summary>
    public uint MaxCueSheet;
}

/// <summary>DVD-R/-RW Write Feature (002Fh)</summary>
public struct Feature_002F
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Buffer Under-run protection</summary>
    public bool BUF;
    /// <summary>Supports writing DVD-R DL</summary>
    public bool RDL;
    /// <summary>Test write</summary>
    public bool TestWrite;
    /// <summary>Can write and erase DVD-RW</summary>
    public bool DVDRW;
}

/// <summary>Double Density CD Read Feature (0030h)</summary>
public struct Feature_0030
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>Double Density CD-R Write Feature (0031h)</summary>
public struct Feature_0031
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Test write</summary>
    public bool TestWrite;
}

/// <summary>Double Density CD-RW Write Feature (0032h)</summary>
public struct Feature_0032
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports quick formatting</summary>
    public bool Intermediate;
    /// <summary>Supports BLANK command</summary>
    public bool Blank;
}

/// <summary>Layer Jump Recording Feature (0033h)</summary>
public struct Feature_0033
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    public byte[] LinkSizes;
}

/// <summary>Stop Long Operation Feature (0035h)</summary>
public struct Feature_0035
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>CD-RW Media Write Support Feature (0037h)</summary>
public struct Feature_0037
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Bitmask of supported CD-RW media sub-types</summary>
    public byte SubtypeSupport;
}

/// <summary>BD-R Pseudo-Overwrite (POW) Feature (0038h)</summary>
public struct Feature_0038
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>DVD+RW Dual Layer Feature (003Ah)</summary>
public struct Feature_003A
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Can format DVD+RW DL discs</summary>
    public bool Write;
    /// <summary>FORMAT UNIT supports quick start formatting</summary>
    public bool QuickStart;
    /// <summary>Drive only supports read compatibility stop</summary>
    public bool CloseOnly;
}

/// <summary>DVD+R Dual Layer Feature (003Bh)</summary>
public struct Feature_003B
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Can format DVD+R DL discs</summary>
    public bool Write;
    /// <summary>FORMAT UNIT supports quick start formatting</summary>
    public bool QuickStart;
    /// <summary>Drive only supports read compatibility stop</summary>
    public bool CloseOnly;
}

/// <summary>BD Read Feature (0040h)</summary>
public struct Feature_0040
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Can read BCA</summary>
    public bool BCA;
    /// <summary>Supports reading BD-RE Ver.2</summary>
    public bool RE2;
    /// <summary>Supports reading BD-RE Ver.1</summary>
    public bool RE1;
    /// <summary>Obsolete</summary>
    public bool OldRE;
    /// <summary>Supports reading BD-R Ver.1</summary>
    public bool R;
    /// <summary>Obsolete</summary>
    public bool OldR;
    /// <summary>Supports reading BD-ROM Ver.1</summary>
    public bool ROM;
    /// <summary>Obsolete</summary>
    public bool OldROM;
}

/// <summary>BD Write Feature (0041h)</summary>
public struct Feature_0041
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports verify not required</summary>
    public bool SVNR;
    /// <summary>Supports writing BD-RE Ver.2</summary>
    public bool RE2;
    /// <summary>Supports writing BD-RE Ver.1</summary>
    public bool RE1;
    /// <summary>Obsolete</summary>
    public bool OldRE;
    /// <summary>Supports writing BD-R Ver.1</summary>
    public bool R;
    /// <summary>Obsolete</summary>
    public bool OldR;
}

/// <summary>TSR Feature (0042h)</summary>
public struct Feature_0042
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>HD DVD Read Feature (0050h)</summary>
public struct Feature_0050
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Can read HD DVD-R</summary>
    public bool HDDVDR;
    /// <summary>Can read HD DVD-RAM</summary>
    public bool HDDVDRAM;
}

/// <summary>HD DVD Write Feature (0051h)</summary>
public struct Feature_0051
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Can write HD DVD-R</summary>
    public bool HDDVDR;
    /// <summary>Can write HD DVD-RAM</summary>
    public bool HDDVDRAM;
}

/// <summary>Hybrid Disc Feature (0080h)</summary>
public struct Feature_0080
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Reset immunity</summary>
    public bool RI;
}

/// <summary>Power Management Feature (0100h)</summary>
public struct Feature_0100
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>S.M.A.R.T. Feature (0101h)</summary>
public struct Feature_0101
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Mode Page 1Ch is present</summary>
    public bool PP;
}

/// <summary>Embedded Changer Feature (0102h)</summary>
public struct Feature_0102
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Side change capable</summary>
    public bool SCC;
    /// <summary>Supports Disc Present</summary>
    public bool SDP;
    /// <summary>Number of slots - 1</summary>
    public byte HighestSlotNumber;
}

/// <summary>CD Audio External Play Feature (0103h)</summary>
public struct Feature_0103
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports SCAN command</summary>
    public bool Scan;
    /// <summary>Separate Channel Mute</summary>
    public bool SCM;
    /// <summary>Separate Volume</summary>
    public bool SV;
    /// <summary>Number of volume levels</summary>
    public ushort VolumeLevels;
}

/// <summary>Microcode Upgrade Feature (0104h)</summary>
public struct Feature_0104
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports validating 5-bit mode field of READ BUFFER and WRITE BUFFER commands.</summary>
    public bool M5;
}

/// <summary>Time-Out Feature (0105h)</summary>
public struct Feature_0105
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports G3Enable bit and Group3 Timeout field in Mode Page 1Dh</summary>
    public bool Group3;
    /// <summary>Indicates a unit of block length, in sectors, corresponding to increase a unit of Group 3 time unit</summary>
    public ushort UnitLength;
}

/// <summary>DVD-CSS Feature (0106h)</summary>
public struct Feature_0106
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>CSS version</summary>
    public byte CSSVersion;
}

/// <summary>Real Time Streaming Feature (0107h)</summary>
public struct Feature_0107
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports Set Minimum Performance bit in SET STREAMING</summary>
    public bool SMP;
    /// <summary>Supports READ BUFFER CAPACITY with block bit set</summary>
    public bool RBCB;
    /// <summary>Supports SET CD SPEED</summary>
    public bool SCS;
    /// <summary>Has Mode Page 2Ah with Speed Performance Descriptors</summary>
    public bool MP2A;
    /// <summary>Supports type 03h of GET PERFORMANCE</summary>
    public bool WSPD;
    /// <summary>Supports stream recording</summary>
    public bool SW;
}

/// <summary>Drive serial number (0108h)</summary>
public struct Feature_0108
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Drive serial number</summary>
    public string Serial;
}

/// <summary>Media Serial Number Feature (0109h)</summary>
public struct Feature_0109
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>Disc Control Blocks Feature (010Ah)</summary>
public struct Feature_010A
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    public uint[] DCBs;
}

/// <summary>DVD CPRM Feature (010Bh)</summary>
public struct Feature_010B
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>CPRM version</summary>
    public byte CPRMVersion;
}

/// <summary>Firmware Information Feature (010Ch)</summary>
public struct Feature_010C
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    public ushort Century;
    public ushort Year;
    public ushort Month;
    public ushort Day;
    public ushort Hour;
    public ushort Minute;
    public ushort Second;
}

/// <summary>AACS Feature (010Dh)</summary>
public struct Feature_010D
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Drive supports reading drive certificate</summary>
    public bool RDC;
    /// <summary>Drive can read media key block of CPRM</summary>
    public bool RMC;
    /// <summary>Drive can write bus encrypted blocks</summary>
    public bool WBE;
    /// <summary>Drive supports bus encryption</summary>
    public bool BEC;
    /// <summary>Drive supports generating the binding nonce</summary>
    public bool BNG;
    /// <summary>Blocks required to store the binding nonce for the media</summary>
    public byte BindNonceBlocks;
    /// <summary>Maximum number of AGIDs supported concurrently</summary>
    public byte AGIDs;
    /// <summary>AACS version</summary>
    public byte AACSVersion;
}

/// <summary>DVD CSS Managed Recording Feature (010Eh)</summary>
public struct Feature_010E
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Maximum number of Scramble Extent information entries in a single SEND DISC STRUCTURE</summary>
    public byte MaxScrambleExtent;
}

/// <summary>SecurDisc Feature (0113h)</summary>
public struct Feature_0113
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

/// <summary>OSSC Feature (0142h)</summary>
public struct Feature_0142
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
    /// <summary>Supports PSA updates on write-once media</summary>
    public bool PSAU;
    /// <summary>Supports linked OSPBs</summary>
    public bool LOSPB;
    /// <summary>Restricted to recording only OSSC disc format</summary>
    public bool ME;
    public ushort[] Profiles;
}

/// <summary>VCPS Feature (0110h)</summary>
public struct Feature_0110
{
    /// <summary>Feature version</summary>
    public byte Version;
    /// <summary>Feature is persistent</summary>
    public bool Persistent;
    /// <summary>Feature is currently in use</summary>
    public bool Current;
}

public static class Features
{
    public static Feature_0000? Decode_0000(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0000)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0000();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        var           offset       = 4;
        List<Profile> listProfiles = new();

        while(offset < feature.Length)
        {
            var prof = new Profile
            {
                Number = (ProfileNumber)((feature[offset] << 8) + feature[offset + 1])
            };

            prof.Current |= (feature[offset + 2] & 0x01) == 0x01;
            listProfiles.Add(prof);
            offset += 4;
        }

        decoded.Profiles = listProfiles.ToArray();

        return decoded;
    }

    public static Feature_0001? Decode_0001(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0001)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0001();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.PhysicalInterfaceStandard =
            (PhysicalInterfaces)((feature[4] << 24) + (feature[5] << 16) + (feature[6] << 8) + feature[7]);

        if(decoded.Version >= 1 && feature.Length >= 12)
            decoded.DBE |= (feature[8] & 0x01) == 0x01;

        if(decoded.Version >= 2 && feature.Length >= 12)
            decoded.INQ2 |= (feature[8] & 0x02) == 0x02;

        return decoded;
    }

    public static Feature_0002? Decode_0002(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0002)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0002();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.Async |= (feature[4] & 0x01) == 0x01;

        if(decoded.Version >= 1)
            decoded.OCEvent |= (feature[4] & 0x02) == 0x02;

        return decoded;
    }

    public static Feature_0003? Decode_0003(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0003)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0003();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.LoadingMechanismType =  (byte)((feature[4] & 0xE0) >> 5);
        decoded.Eject                |= (feature[4] & 0x08) == 0x08;
        decoded.PreventJumper        |= (feature[4] & 0x04) == 0x04;
        decoded.Lock                 |= (feature[4] & 0x01) == 0x01;

        if(decoded.Version < 2)
            return decoded;

        decoded.Load |= (feature[4] & 0x10) == 0x10;
        decoded.DBML |= (feature[4] & 0x02) == 0x02;

        return decoded;
    }

    public static Feature_0004? Decode_0004(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0004)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0004();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.SPWP  |= (feature[4] & 0x02) == 0x02;
        decoded.SSWPP |= (feature[4] & 0x01) == 0x01;

        if(decoded.Version >= 1)
            decoded.WDCB |= (feature[4] & 0x04) == 0x04;

        if(decoded.Version >= 2)
            decoded.DWP |= (feature[4] & 0x08) == 0x08;

        return decoded;
    }

    public static Feature_0010? Decode_0010(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 12)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0010)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0010();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.LogicalBlockSize = (uint)((feature[4] << 24) + (feature[5] << 16) + (feature[6] << 8) + feature[7]);

        decoded.Blocking = (ushort)((feature[8] << 8) + feature[9]);

        decoded.PP |= (feature[10] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_001D? Decode_001D(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x001D)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_001D();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_001E? Decode_001E(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x001E)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_001E();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        if(decoded.Version >= 1)
        {
            decoded.C2     |= (feature[4] & 0x02) == 0x02;
            decoded.CDText |= (feature[4] & 0x01) == 0x01;
        }

        if(decoded.Version >= 2)
            decoded.DAP |= (feature[4] & 0x80) == 0x80;

        return decoded;
    }

    public static Feature_001F? Decode_001F(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x001F)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_001F();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        if(decoded.Version >= 2 && feature.Length >= 8)
        {
            decoded.MULTI110 |= (feature[4] & 0x01) == 0x01;
            decoded.DualR    |= (feature[6] & 0x01) == 0x01;
        }

        // TODO: Check this
        if(decoded.Version >= 2 && feature.Length >= 8)
            decoded.DualRW |= (feature[6] & 0x02) == 0x02;

        return decoded;
    }

    public static Feature_0020? Decode_0020(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 16)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0020)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0020();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        if(decoded.Version < 1)
            return decoded;

        decoded.LastLBA = (uint)((feature[4] << 24) + (feature[5] << 16) + (feature[6] << 8) + feature[7]);

        decoded.LogicalBlockSize = (uint)((feature[8] << 24) + (feature[9] << 16) + (feature[10] << 8) + feature[11]);

        decoded.Blocking =  (ushort)((feature[12] << 8) + feature[13]);
        decoded.PP       |= (feature[14] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_0021? Decode_0021(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0021)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0021();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        if(decoded.Version >= 1)
        {
            decoded.DataTypeSupported =  (ushort)((feature[4] << 8) + feature[5]);
            decoded.BUF               |= (feature[6] & 0x01) == 0x01;
            decoded.LinkSizes         =  new byte[feature[7]];

            if(feature.Length > feature[7] + 8)
                Array.Copy(feature, 8, decoded.LinkSizes, 0, feature[7]);
        }

        if(decoded.Version < 3)
            return decoded;

        decoded.TRIO |= (feature[6] & 0x04) == 0x04;
        decoded.ARSV |= (feature[6] & 0x02) == 0x02;

        return decoded;
    }

    public static Feature_0022? Decode_0022(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0022)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0022();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_0023? Decode_0023(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0023)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0023();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        if(decoded.Version >= 1 && feature.Length >= 12)
        {
            decoded.RENoSA |= (feature[4] & 0x08) == 0x08;
            decoded.Expand |= (feature[4] & 0x04) == 0x04;
            decoded.QCert  |= (feature[4] & 0x02) == 0x02;
            decoded.Cert   |= (feature[4] & 0x01) == 0x01;
            decoded.RRM    |= (feature[8] & 0x01) == 0x01;
        }

        if(decoded.Version >= 2 && feature.Length >= 12)
            decoded.FRF |= (feature[4] & 0x80) == 0x80;

        return decoded;
    }

    public static Feature_0024? Decode_0024(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0024)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0024();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        if(decoded.Version >= 1 && feature.Length >= 8)
            decoded.SSA |= (feature[4] & 0x80) == 0x80;

        return decoded;
    }

    public static Feature_0025? Decode_0025(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 12)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0025)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0025();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.LogicalBlockSize = (uint)((feature[4] << 24) + (feature[5] << 16) + (feature[6] << 8) + feature[7]);

        decoded.Blocking = (ushort)((feature[8] << 8) + feature[9]);

        decoded.PP |= (feature[10] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_0026? Decode_0026(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0026)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0026();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_0027? Decode_0027(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0027)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0027();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_0028? Decode_0028(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0028)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0028();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.Write |= (feature[4] & 0x01) == 0x01;

        if(decoded.Version < 1)
            return decoded;

        decoded.DVDPWrite |= (feature[4] & 0x04) == 0x04;
        decoded.DVDPRead  |= (feature[4] & 0x02) == 0x02;

        return decoded;
    }

    public static Feature_0029? Decode_0029(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0029)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0029();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.DRTDM         |= (feature[4] & 0x01) == 0x01;
        decoded.DBICacheZones =  feature[5];
        decoded.Entries       =  (ushort)((feature[6] << 8) + feature[7]);

        return decoded;
    }

    public static Feature_002A? Decode_002A(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x002A)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_002A();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.Write     |= (feature[4] & 0x01) == 0x01;
        decoded.CloseOnly |= (feature[5] & 0x01) == 0x01;

        if(decoded.Version >= 1)
            decoded.QuickStart |= (feature[5] & 0x02) == 0x02;

        return decoded;
    }

    public static Feature_002B? Decode_002B(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x002B)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_002B();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.Write |= (feature[4] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_002C? Decode_002C(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x002C)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_002C();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.DSDG         |= (feature[4] & 0x08) == 0x08;
        decoded.DSDR         |= (feature[4] & 0x04) == 0x04;
        decoded.Intermediate |= (feature[4] & 0x02) == 0x02;
        decoded.Blank        |= (feature[4] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_002D? Decode_002D(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x002D)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_002D();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.TestWrite         |= (feature[4] & 0x04) == 0x04;
        decoded.CDRW              |= (feature[4] & 0x02) == 0x02;
        decoded.RWSubchannel      |= (feature[4] & 0x01) == 0x01;
        decoded.DataTypeSupported =  (ushort)((feature[6] << 8) + feature[7]);

        if(decoded.Version < 2)
            return decoded;

        decoded.BUF    |= (feature[4] & 0x40) == 0x40;
        decoded.RWRaw  |= (feature[4] & 0x10) == 0x10;
        decoded.RWPack |= (feature[4] & 0x08) == 0x08;

        return decoded;
    }

    public static Feature_002E? Decode_002E(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x002E)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_002E();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.SAO         |= (feature[4] & 0x20) == 0x20;
        decoded.RAWMS       |= (feature[4] & 0x10) == 0x10;
        decoded.RAW         |= (feature[4] & 0x08) == 0x08;
        decoded.TestWrite   |= (feature[4] & 0x04) == 0x04;
        decoded.CDRW        |= (feature[4] & 0x02) == 0x02;
        decoded.RW          |= (feature[4] & 0x01) == 0x01;
        decoded.MaxCueSheet =  (uint)((feature[5] << 16) + (feature[6] << 8) + feature[7]);

        if(decoded.Version >= 1)
            decoded.BUF |= (feature[4] & 0x40) == 0x40;

        return decoded;
    }

    public static Feature_002F? Decode_002F(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x002F)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_002F();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.BUF       |= (feature[4] & 0x40) == 0x40;
        decoded.TestWrite |= (feature[4] & 0x04) == 0x04;

        if(decoded.Version >= 1)
            decoded.DVDRW |= (feature[4] & 0x02) == 0x02;

        if(decoded.Version >= 2)
            decoded.RDL |= (feature[4] & 0x08) == 0x08;

        return decoded;
    }

    public static Feature_0030? Decode_0030(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0030)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0030();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_0031? Decode_0031(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0031)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0031();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.TestWrite |= (feature[4] & 0x04) == 0x04;

        return decoded;
    }

    public static Feature_0032? Decode_0032(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0032)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0032();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.Intermediate |= (feature[4] & 0x02) == 0x02;
        decoded.Blank        |= (feature[4] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_0033? Decode_0033(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0033)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0033();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        if(feature[7] <= 0 || feature.Length <= feature[7] + 8)
            return decoded;

        decoded.LinkSizes = new byte[feature[7]];
        Array.Copy(feature, 8, decoded.LinkSizes, 0, feature[7]);

        return decoded;
    }

    public static Feature_0035? Decode_0035(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0035)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0035();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_0037? Decode_0037(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0037)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0037();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.SubtypeSupport = feature[5];

        return decoded;
    }

    public static Feature_0038? Decode_0038(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0038)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0038();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_003A? Decode_003A(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x003A)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_003A();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.Write      |= (feature[4] & 0x01) == 0x01;
        decoded.QuickStart |= (feature[5] & 0x02) == 0x02;
        decoded.CloseOnly  |= (feature[5] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_003B? Decode_003B(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x003B)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_003B();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.Write |= (feature[4] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_0040? Decode_0040(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 32)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0040)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0040();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.OldRE  |= (feature[9]  & 0x01) == 0x01;
        decoded.OldR   |= (feature[17] & 0x01) == 0x01;
        decoded.OldROM |= (feature[25] & 0x01) == 0x01;

        if(decoded.Version < 1)
            return decoded;

        decoded.BCA |= (feature[4]  & 0x01) == 0x01;
        decoded.RE2 |= (feature[9]  & 0x04) == 0x04;
        decoded.RE1 |= (feature[9]  & 0x02) == 0x02;
        decoded.R   |= (feature[17] & 0x02) == 0x02;
        decoded.ROM |= (feature[25] & 0x02) == 0x02;

        return decoded;
    }

    public static Feature_0041? Decode_0041(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 24)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0041)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0041();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.SVNR  |= (feature[4]  & 0x01) == 0x01;
        decoded.OldRE |= (feature[9]  & 0x01) == 0x01;
        decoded.OldR  |= (feature[17] & 0x01) == 0x01;

        if(decoded.Version < 1)
            return decoded;

        decoded.RE2 |= (feature[9]  & 0x04) == 0x04;
        decoded.RE1 |= (feature[9]  & 0x02) == 0x02;
        decoded.R   |= (feature[17] & 0x02) == 0x02;

        return decoded;
    }

    public static Feature_0042? Decode_0042(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0042)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0042();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_0050? Decode_0050(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0050)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0050();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.HDDVDR   |= (feature[4] & 0x01) == 0x01;
        decoded.HDDVDRAM |= (feature[6] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_0051? Decode_0051(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0051)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0051();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.HDDVDR   |= (feature[4] & 0x01) == 0x01;
        decoded.HDDVDRAM |= (feature[6] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_0080? Decode_0080(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0080)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0080();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.RI |= (feature[4] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_0100? Decode_0100(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0100)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0100();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_0101? Decode_0101(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0101)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0101();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.PP |= (feature[4] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_0102? Decode_0102(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0102)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0102();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.SCC               |= (feature[4]       & 0x10) == 0x10;
        decoded.SDP               |= (feature[4]       & 0x04) == 0x04;
        decoded.HighestSlotNumber =  (byte)(feature[7] & 0x1F);

        return decoded;
    }

    public static Feature_0103? Decode_0103(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0103)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0103();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.Scan         |= (feature[4] & 0x04) == 0x04;
        decoded.SCM          |= (feature[4] & 0x02) == 0x02;
        decoded.SV           |= (feature[4] & 0x01) == 0x01;
        decoded.VolumeLevels =  (ushort)((feature[6] << 8) + feature[7]);

        return decoded;
    }

    public static Feature_0104? Decode_0104(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0104)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0104();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        if(decoded.Version >= 1 && feature.Length >= 8)
            decoded.M5 |= (feature[4] & 0x01) == 0x01;

        return decoded;
    }

    public static Feature_0105? Decode_0105(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0105)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0105();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        if(decoded.Version < 1 || feature.Length < 8)
            return decoded;

        decoded.Group3     |= (feature[4] & 0x01) == 0x01;
        decoded.UnitLength =  (ushort)((feature[6] << 8) + feature[7]);

        return decoded;
    }

    public static Feature_0106? Decode_0106(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0106)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0106();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.CSSVersion = feature[7];

        return decoded;
    }

    public static Feature_0107? Decode_0107(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0107)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0107();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        if(decoded.Version >= 3 && feature.Length >= 8)
        {
            decoded.RBCB |= (feature[4] & 0x10) == 0x10;
            decoded.SCS  |= (feature[4] & 0x08) == 0x08;
            decoded.MP2A |= (feature[4] & 0x04) == 0x04;
            decoded.WSPD |= (feature[4] & 0x02) == 0x02;
            decoded.SW   |= (feature[4] & 0x01) == 0x01;
        }

        if(decoded.Version < 5 || feature.Length < 8)
            return decoded;

        decoded.SMP  |= (feature[4] & 0x20) == 0x20;
        decoded.RBCB |= (feature[4] & 0x10) == 0x10;

        return decoded;
    }

    public static Feature_0108? Decode_0108(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0108)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0108();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        var serial = new byte[feature.Length];
        Array.Copy(feature, 4, serial, 0, feature.Length - 4);
        decoded.Serial = StringHandlers.CToString(serial).Trim();

        return decoded;
    }

    public static Feature_0109? Decode_0109(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0109)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0109();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_010A? Decode_010A(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x010A)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_010A();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.DCBs = new uint[feature[3] / 4];

        for(var i = 0; i < decoded.DCBs.Length; i++)
        {
            decoded.DCBs[i] = (uint)((feature[0 + 4 + i * 4] << 24) +
                                     (feature[1 + 4 + i * 4] << 16) +
                                     (feature[2 + 4 + i * 4] << 8)  +
                                     feature[3 + 4 + i * 4]);
        }

        return decoded;
    }

    public static Feature_010B? Decode_010B(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x010B)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_010B();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.CPRMVersion = feature[7];

        return decoded;
    }

    public static Feature_010C? Decode_010C(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 20)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x010C)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_010C();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.Century = (ushort)((feature[4]  << 8) + feature[5]);
        decoded.Year    = (ushort)((feature[6]  << 8) + feature[7]);
        decoded.Month   = (ushort)((feature[8]  << 8) + feature[9]);
        decoded.Day     = (ushort)((feature[10] << 8) + feature[11]);
        decoded.Hour    = (ushort)((feature[12] << 8) + feature[13]);
        decoded.Minute  = (ushort)((feature[14] << 8) + feature[15]);
        decoded.Second  = (ushort)((feature[16] << 8) + feature[17]);

        return decoded;
    }

    public static Feature_010D? Decode_010D(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x010D)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_010D();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.BNG             |= (feature[4] & 0x01) == 0x01;
        decoded.BindNonceBlocks =  feature[5];
        decoded.AGIDs           =  (byte)(feature[6] & 0x0F);
        decoded.AACSVersion     =  feature[7];

        if(decoded.Version < 2)
            return decoded;

        decoded.RDC |= (feature[4] & 0x10) == 0x10;
        decoded.RMC |= (feature[4] & 0x08) == 0x08;
        decoded.WBE |= (feature[4] & 0x04) == 0x04;
        decoded.BEC |= (feature[4] & 0x02) == 0x02;

        return decoded;
    }

    public static Feature_010E? Decode_010E(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x010E)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_010E();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.MaxScrambleExtent = feature[4];

        return decoded;
    }

    public static Feature_0110? Decode_0110(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 8)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0110)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0110();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_0113? Decode_0113(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 4)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0113)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0113();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        return decoded;
    }

    public static Feature_0142? Decode_0142(byte[] feature)
    {
        if(feature == null)
            return null;

        if(feature.Length < 6)
            return null;

        var number = (ushort)((feature[0] << 8) + feature[1]);

        if(number != 0x0142)
            return null;

        if(feature[3] + 4 != feature.Length)
            return null;

        var decoded = new Feature_0142();

        decoded.Current    |= (feature[2] & 0x01) == 0x01;
        decoded.Persistent |= (feature[2] & 0x02) == 0x02;
        decoded.Version    =  (byte)((feature[2] & 0x3C) >> 2);

        decoded.PSAU     |= (feature[4] & 0x80) == 0x80;
        decoded.LOSPB    |= (feature[4] & 0x40) == 0x40;
        decoded.ME       |= (feature[4] & 0x01) == 0x01;
        decoded.Profiles =  new ushort[feature[5]];

        if(feature[5] * 2 + 6 != feature.Length)
            return decoded;

        for(var i = 0; i < feature[5]; i++)
            decoded.Profiles[i] = (ushort)((feature[0 + 6 + 2 * i] << 8) + feature[1 + 6 + 2 * i]);

        return decoded;
    }

    public static string Prettify_0000(Feature_0000? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0000 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Supported_Profiles);

        if(ftr.Profiles == null)
            return sb.ToString();

        foreach(Profile prof in ftr.Profiles)
        {
            switch(prof.Number)
            {
                case ProfileNumber.Reserved:
                    sb.Append("\t" + Localization.Drive_reported_a_reserved_profile_number);

                    break;
                case ProfileNumber.NonRemovable:
                    sb.Append("\t" + Localization.Drive_supports_non_removable_changeable_media);

                    break;
                case ProfileNumber.Removable:
                    sb.Append("\t" + Localization.Drive_supports_rewritable_and_removable_media);

                    break;
                case ProfileNumber.MOErasable:
                    sb.Append("\t" + Localization.Drive_supports_Magneto_Optical_media);

                    break;
                case ProfileNumber.OpticalWORM:
                    sb.Append("\t" + Localization.Drive_supports_optical_write_once_media);

                    break;
                case ProfileNumber.ASMO:
                    sb.Append("\t" + Localization.Drive_supports_Advanced_Storage_Magneto_Optical);

                    break;
                case ProfileNumber.CDROM:
                    sb.Append("\t" + Localization.Drive_supports_CD_ROM);

                    break;
                case ProfileNumber.CDR:
                    sb.Append("\t" + Localization.Drive_supports_CD_R);

                    break;
                case ProfileNumber.CDRW:
                    sb.Append("\t" + Localization.Drive_supports_CD_RW);

                    break;
                case ProfileNumber.DVDROM:
                    sb.Append("\t" + Localization.Drive_supports_DVD_ROM);

                    break;
                case ProfileNumber.DVDRSeq:
                    sb.Append("\t" + Localization.Drive_supports_DVD_R);

                    break;
                case ProfileNumber.DVDRAM:
                    sb.Append("\t" + Localization.Drive_supports_DVD_RAM);

                    break;
                case ProfileNumber.DVDRWRes:
                    sb.Append("\t" + Localization.Drive_supports_restricted_overwrite_DVD_RW);

                    break;
                case ProfileNumber.DVDRWSeq:
                    sb.Append("\t" + Localization.Drive_supports_sequentially_recorded_DVD_RW);

                    break;
                case ProfileNumber.DVDRDLSeq:
                    sb.Append("\t" + Localization.Drive_supports_sequentially_recorded_DVD_R_DL);

                    break;
                case ProfileNumber.DVDRDLJump:
                    sb.Append("\t" + Localization.Drive_supports_layer_jump_recorded_DVD_R_DL);

                    break;
                case ProfileNumber.DVDRWDL:
                    sb.Append("\t" + Localization.Drive_supports_DVD_RW_DL);

                    break;
                case ProfileNumber.DVDDownload:
                    sb.Append("\t" + Localization.Drive_supports_DVD_Download);

                    break;
                case ProfileNumber.DVDRWPlus:
                    sb.Append("\t" + Localization.Drive_supports_DVD_Plus_RW);

                    break;
                case ProfileNumber.DVDRPlus:
                    sb.Append("\t" + Localization.Drive_supports_DVD_Plus_R);

                    break;
                case ProfileNumber.DDCDROM:
                    sb.Append("\t" + Localization.Drive_supports_DDCD_ROM);

                    break;
                case ProfileNumber.DDCDR:
                    sb.Append("\t" + Localization.Drive_supports_DDCD_R);

                    break;
                case ProfileNumber.DDCDRW:
                    sb.Append("\t" + Localization.Drive_supports_DDCD_RW);

                    break;
                case ProfileNumber.DVDRWDLPlus:
                    sb.Append("\t" + Localization.Drive_supports_DVD_Plus_RW_DL);

                    break;
                case ProfileNumber.DVDRDLPlus:
                    sb.Append("\t" + Localization.Drive_supports_DVD_Plus_R_DL);

                    break;
                case ProfileNumber.BDROM:
                    sb.Append("\t" + Localization.Drive_supports_BD_ROM);

                    break;
                case ProfileNumber.BDRSeq:
                    sb.Append("\t" + Localization.Drive_supports_BD_R_SRM);

                    break;
                case ProfileNumber.BDRRdm:
                    sb.Append("\t" + Localization.Drive_supports_BD_R_RRM);

                    break;
                case ProfileNumber.BDRE:
                    sb.Append("\t" + Localization.Drive_supports_BD_RE);

                    break;
                case ProfileNumber.HDDVDROM:
                    sb.Append("\t" + Localization.Drive_supports_HD_DVD_ROM);

                    break;
                case ProfileNumber.HDDVDR:
                    sb.Append("\t" + Localization.Drive_supports_HD_DVD_R);

                    break;
                case ProfileNumber.HDDVDRAM:
                    sb.Append("\t" + Localization.Drive_supports_HD_DVD_RAM);

                    break;
                case ProfileNumber.HDDVDRW:
                    sb.Append("\t" + Localization.Drive_supports_HD_DVD_RW);

                    break;
                case ProfileNumber.HDDVDRDL:
                    sb.Append("\t" + Localization.Drive_supports_HD_DVD_R_DL);

                    break;
                case ProfileNumber.HDDVDRWDL:
                    sb.Append("\t" + Localization.Drive_supports_HD_DVD_RW_DL);

                    break;
                case ProfileNumber.HDBURNROM:
                    sb.Append("\t" + Localization.Drive_supports_HDBurn_CD_ROM);

                    break;
                case ProfileNumber.HDBURNR:
                    sb.Append("\t" + Localization.Drive_supports_HDBurn_CD_R);

                    break;
                case ProfileNumber.HDBURNRW:
                    sb.Append("\t" + Localization.Drive_supports_HDBurn_CD_RW);

                    break;
                case ProfileNumber.Unconforming:
                    sb.Append("\t" + Localization.Drive_is_not_conforming_to_any_profile);

                    break;
                default:
                    sb.AppendFormat("\t" + Localization.Drive_informs_of_unknown_profile_0, (ushort)prof.Number);

                    break;
            }

            if(prof.Current)
                sb.AppendLine(Localization.current);
            else
                sb.AppendLine();
        }

        return sb.ToString();
    }

    public static string Prettify_0001(Feature_0001? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0001 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Core_Feature);
        sb.Append("\t");

        switch(ftr.PhysicalInterfaceStandard)
        {
            case PhysicalInterfaces.Unspecified:
                sb.AppendLine(Localization.Drive_uses_an_unspecified_physical_interface);

                break;
            case PhysicalInterfaces.SCSI:
                sb.AppendLine(Localization.Drive_uses_a_SCSI_interface);

                break;
            case PhysicalInterfaces.ATAPI:
                sb.AppendLine(Localization.Drive_uses_an_ATAPI_interface);

                break;
            case PhysicalInterfaces.IEEE1394:
                sb.AppendLine(Localization.Drive_uses_an_IEEE_1394_interface);

                break;
            case PhysicalInterfaces.IEEE1394A:
                sb.AppendLine(Localization.Drive_uses_an_IEEE_1394A_interface);

                break;
            case PhysicalInterfaces.FC:
                sb.AppendLine(Localization.Drive_uses_a_Fibre_Channel_interface);

                break;
            case PhysicalInterfaces.IEEE1394B:
                sb.AppendLine(Localization.Drive_uses_an_IEEE_1394B_interface);

                break;
            case PhysicalInterfaces.SerialATAPI:
                sb.AppendLine(Localization.Drive_uses_a_Serial_ATAPI_interface);

                break;
            case PhysicalInterfaces.USB:
                sb.AppendLine(Localization.Drive_uses_an_USB_interface);

                break;
            case PhysicalInterfaces.Vendor:
                sb.AppendLine(Localization.Drive_uses_a_vendor_unique_interface);

                break;
            default:
                sb.AppendFormat(Localization.Drive_uses_an_unknown_interface_with_code_0,
                                (uint)ftr.PhysicalInterfaceStandard).
                   AppendLine();

                break;
        }

        if(ftr.DBE)
            sb.AppendLine("\t" + Localization.Drive_supports_Device_Busy_events);

        if(ftr.INQ2)
        {
            sb.AppendLine("\t" +
                          Localization.
                              Drive_supports_EVPD_Page_Code_and_16_bit_Allocation_Length_as_described_in_SPC_3);
        }

        return sb.ToString();
    }

    public static string Prettify_0002(Feature_0002? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0002 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Morphing);

        sb.AppendLine(ftr.Async
                          ? "\t" + Localization.Drive_supports_polling_and_asynchronous_GET_EVENT_STATUS_NOTIFICATION
                          : "\t" + Localization.Drive_supports_only_polling_GET_EVENT_STATUS_NOTIFICATION);

        if(ftr.OCEvent)
            sb.AppendLine("\t" + Localization.Drive_supports_operational_change_request_notification_class_events);

        return sb.ToString();
    }

    public static string Prettify_0003(Feature_0003? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0003 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.Features_Prettify_0003_MMC_Removable_Medium);

        switch(ftr.LoadingMechanismType)
        {
            case 0:
                sb.AppendLine("\t" + Localization.Features_Prettify_0003_Drive_uses_media_caddy);

                break;
            case 1:
                sb.AppendLine("\t" + Localization.Features_Prettify_0003_Drive_uses_a_tray);

                break;
            case 2:
                sb.AppendLine("\t" + Localization.Features_Prettify_0003_Drive_is_pop_up);

                break;
            case 4:
                sb.AppendLine("\t" +
                              Localization.
                                  Features_Prettify_0003_Drive_is_a_changer_with_individually_changeable_discs);

                break;
            case 5:
                sb.AppendLine("\t" + Localization.Features_Prettify_0003_Drive_is_a_changer_using_cartridges);

                break;
            default:
                sb.AppendFormat("\t" + Localization.Features_Prettify_0003_Drive_uses_unknown_loading_mechanism_type_0,
                                ftr.LoadingMechanismType).
                   AppendLine();

                break;
        }

        if(ftr.Lock)
            sb.AppendLine("\t" + Localization.Features_Prettify_0003_Drive_can_lock_media);

        if(ftr.PreventJumper)
            sb.AppendLine("\t" + Localization.Features_Prettify_0003_Drive_power_ups_locked);

        if(ftr.Eject)
            sb.AppendLine("\t" + Localization.Features_Prettify_0003_Drive_can_eject_media);

        if(ftr.Load)
            sb.AppendLine("\t" + Localization.Features_Prettify_0003_Drive_can_load_media);

        if(ftr.DBML)
        {
            sb.AppendLine("\t" +
                          Localization.
                              Features_Prettify_0003_Drive_reports_Device_Busy_Class_events_during_medium_loading_unloading);
        }

        return sb.ToString();
    }

    public static string Prettify_0004(Feature_0004? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0004 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Write_Protect);

        if(ftr.DWP)
        {
            sb.AppendLine("\t" +
                          Localization.Drive_supports_reading_writing_the_Disc_Write_Protect_PAC_on_BD_R_RE_media);
        }

        if(ftr.WDCB)
            sb.AppendLine("\t" + Localization.Drive_supports_writing_the_Write_Inhibit_DCB_on_DVD_RW_media);

        if(ftr.SPWP)
            sb.AppendLine("\t" + Localization.Drive_supports_set_release_of_PWP_status);

        if(ftr.SSWPP)
            sb.AppendLine("\t" + Localization.Drive_supports_the_SWPP_bit_of_the_Timeout_and_Protect_mode_page);

        return sb.ToString();
    }

    public static string Prettify_0010(Feature_0010? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0010 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.MMC_Random_Readable);

        if(ftr.Current)
            sb.Append(Localization.current);

        sb.AppendLine(":");

        if(ftr.PP)
            sb.AppendLine("\t" + Localization.Drive_shall_report_Read_Write_Error_Recovery_mode_page);

        if(ftr.LogicalBlockSize > 0)
            sb.AppendFormat("\t" + Localization._0_bytes_per_logical_block, ftr.LogicalBlockSize).AppendLine();

        if(ftr.Blocking > 1)
            sb.AppendFormat("\t" + Localization._0_logical_blocks_per_media_readable_unit, ftr.Blocking).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_001D(Feature_001D? feature) =>
        !feature.HasValue
            ? null
            : Localization.Drive_claims_capability_to_read_all_CD_formats_according_to_OSTA_Multi_Read_Specification +
              "\n";

    public static string Prettify_001E(Feature_001E? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_001E ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.MMC_CD_Read);

        if(ftr.Current)
            sb.Append(Localization.current);

        sb.AppendLine(":");

        if(ftr.DAP)
            sb.AppendLine("\t" + Localization.Drive_supports_the_DAP_bit_in_the_READ_CD_and_READ_CD_MSF_commands);

        if(ftr.C2)
            sb.AppendLine("\t" + Localization.Drive_supports_C2_Error_Pointers);

        if(ftr.CDText)
            sb.AppendLine("\t" + Localization.Drive_can_return_CD_Text_from_Lead_In);

        return sb.ToString();
    }

    public static string Prettify_001F(Feature_001F? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_001F ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.MMC_DVD_Read);

        if(ftr.Current)
            sb.Append(Localization.current);

        sb.AppendLine(":");
        sb.AppendLine("\t" + Localization.Drive_can_read_DVD_media);

        if(ftr.DualR)
            sb.AppendLine("\t" + Localization.Drive_can_read_DVD_R_DL_from_all_recording_modes);

        if(ftr.DualRW)
            sb.AppendLine("\t" + Localization.Drive_can_read_DVD_RW_DL_from_all_recording_modes);

        if(ftr.MULTI110)
            sb.AppendLine("\t" + Localization.Drive_conforms_to_DVD_Multi_Drive_Read_only_Specifications);

        return sb.ToString();
    }

    public static string Prettify_0020(Feature_0020? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0020 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.MMC_Random_Writable);

        if(ftr.Current)
            sb.Append(Localization.current);

        sb.AppendLine(":");

        if(ftr.PP)
            sb.AppendLine("\t" + Localization.Drive_shall_report_Read_Write_Error_Recovery_mode_page);

        if(ftr.LogicalBlockSize > 0)
            sb.AppendFormat("\t" + Localization._0_bytes_per_logical_block, ftr.LogicalBlockSize).AppendLine();

        if(ftr.Blocking > 1)
            sb.AppendFormat("\t" + Localization._0_logical_blocks_per_media_writable_unit, ftr.Blocking).AppendLine();

        if(ftr.LastLBA > 0)
            sb.AppendFormat("\t" + Localization.Last_addressable_logical_block_is_0, ftr.LastLBA).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0021(Feature_0021? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0021 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Incremental_Streaming_Writable);

        if(ftr.DataTypeSupported > 0)
        {
            sb.Append("\t" + Localization.Drive_supports_data_block_types);

            if((ftr.DataTypeSupported & 0x0001) == 0x0001)
                sb.Append(" 0");

            if((ftr.DataTypeSupported & 0x0002) == 0x0002)
                sb.Append(" 1");

            if((ftr.DataTypeSupported & 0x0004) == 0x0004)
                sb.Append(" 2");

            if((ftr.DataTypeSupported & 0x0008) == 0x0008)
                sb.Append(" 3");

            if((ftr.DataTypeSupported & 0x0010) == 0x0010)
                sb.Append(" 4");

            if((ftr.DataTypeSupported & 0x0020) == 0x0020)
                sb.Append(" 5");

            if((ftr.DataTypeSupported & 0x0040) == 0x0040)
                sb.Append(" 6");

            if((ftr.DataTypeSupported & 0x0080) == 0x0080)
                sb.Append(" 7");

            if((ftr.DataTypeSupported & 0x0100) == 0x0100)
                sb.Append(" 8");

            if((ftr.DataTypeSupported & 0x0200) == 0x0200)
                sb.Append(" 9");

            if((ftr.DataTypeSupported & 0x0400) == 0x0400)
                sb.Append(" 10");

            if((ftr.DataTypeSupported & 0x0800) == 0x0800)
                sb.Append(" 11");

            if((ftr.DataTypeSupported & 0x1000) == 0x1000)
                sb.Append(" 12");

            if((ftr.DataTypeSupported & 0x2000) == 0x2000)
                sb.Append(" 13");

            if((ftr.DataTypeSupported & 0x4000) == 0x4000)
                sb.Append(" 14");

            if((ftr.DataTypeSupported & 0x8000) == 0x8000)
                sb.Append(" 15");

            sb.AppendLine();
        }

        if(ftr.TRIO)
            sb.AppendLine("\t" + Localization.Drive_claims_support_to_report_Track_Resources_Information);

        if(ftr.ARSV)
            sb.AppendLine("\t" + Localization.Drive_supports_address_mode_reservation_on_the_RESERVE_TRACK_command);

        if(ftr.BUF)
            sb.AppendLine("\t" + Localization.Drive_is_capable_of_zero_loss_linking);

        return sb.ToString();
    }

    public static string Prettify_0022(Feature_0022? feature) =>
        !feature.HasValue ? null : Localization.Drive_supports_media_that_require_erasing_before_writing + "\n";

    public static string Prettify_0023(Feature_0023? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0023 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Formattable);
        sb.AppendLine("\t" + Localization.Drive_can_format_media_into_logical_blocks);

        if(ftr.RENoSA)
            sb.AppendLine("\t" + Localization.Drive_can_format_BD_RE_with_no_spares_allocated);

        if(ftr.Expand)
            sb.AppendLine("\t" + Localization.Drive_can_expand_the_spare_area_on_a_formatted_BD_RE_disc);

        if(ftr.QCert)
            sb.AppendLine("\t" + Localization.Drive_can_format_BD_RE_discs_with_quick_certification);

        if(ftr.Cert)
            sb.AppendLine("\t" + Localization.Drive_can_format_BD_RE_discs_with_full_certification);

        if(ftr.FRF)
            sb.AppendLine("\t" + Localization.Drive_can_fast_re_format_BD_RE_discs);

        if(ftr.RRM)
            sb.AppendLine("\t" + Localization.Drive_can_format_BD_R_discs_with_RRM_format);

        return sb.ToString();
    }

    public static string Prettify_0024(Feature_0024? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0024 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Hardware_Defect_Management);
        sb.AppendLine("\t" + Localization.Drive_shall_be_able_to_provide_a_defect_free_contiguous_address_space);

        if(ftr.SSA)
            sb.AppendLine("\t" + Localization.Drive_can_return_Spare_Area_Information);

        return sb.ToString();
    }

    public static string Prettify_0025(Feature_0025? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0025 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.MMC_Write_Once);

        if(ftr.Current)
            sb.Append(Localization.current);

        sb.AppendLine(":");

        if(ftr.PP)
            sb.AppendLine("\t" + Localization.Drive_shall_report_Read_Write_Error_Recovery_mode_page);

        if(ftr.LogicalBlockSize > 0)
            sb.AppendFormat("\t" + Localization._0_bytes_per_logical_block, ftr.LogicalBlockSize).AppendLine();

        if(ftr.Blocking > 1)
            sb.AppendFormat("\t" + Localization._0_logical_blocks_per_media_writable_unit, ftr.Blocking).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0026(Feature_0026? feature) =>
        !feature.HasValue
            ? null
            : Localization.Drive_shall_have_the_ability_to_overwrite_logical_blocks_only_in_fixed_sets_at_a_time + "\n";

    public static string Prettify_0027(Feature_0027? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0027 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.Drive_can_write_High_Speed_CD_RW);

        if(ftr.Current)
            sb.AppendLine(Localization.current);
        else
            sb.AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0028(Feature_0028? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0028 ftr = feature.Value;
        var          sb  = new StringBuilder();

        if(ftr.Write && ftr is { DVDPRead: true, DVDPWrite: true })
            sb.Append(Localization.Drive_can_read_and_write_CD_MRW_and_DVD_MRW);
        else if(ftr is { DVDPRead: true, DVDPWrite: true })
            sb.Append(Localization.Drive_can_read_and_write_DVD_MRW);
        else
        {
            switch(ftr.Write)
            {
                case true when ftr.DVDPRead:
                    sb.Append(Localization.Drive_and_read_DVD_MRW_and_read_and_write_CD_MRW);

                    break;
                case true:
                    sb.Append(Localization.Drive_can_read_and_write_CD_MRW);

                    break;
                default:
                {
                    sb.Append(ftr.DVDPRead
                                  ? Localization.Drive_can_read_CD_MRW_and_DVD_MRW
                                  : Localization.Drive_can_read_CD_MRW);

                    break;
                }
            }
        }

        if(ftr.Current)
            sb.AppendLine(Localization.current);
        else
            sb.AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0029(Feature_0029? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0029 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Enhanced_Defect_Reporting_Feature);

        sb.AppendLine(ftr.DRTDM
                          ? "\t" + Localization.Drive_supports_DRT_DM_mode
                          : "\t" + Localization.Drive_supports_Persistent_DM_mode);

        if(ftr.DBICacheZones > 0)
            sb.AppendFormat("\t" + Localization.Drive_has_0_DBI_cache_zones, ftr.DBICacheZones).AppendLine();

        if(ftr.Entries > 0)
            sb.AppendFormat("\t" + Localization.Drive_has_0_DBI_entries, ftr.Entries).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_002A(Feature_002A? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_002A ftr = feature.Value;
        var          sb  = new StringBuilder();

        if(ftr.Write)
        {
            sb.Append(Localization.Drive_can_read_and_write_DVD_RW);

            if(ftr.Current)
                sb.AppendLine(Localization.current);
            else
                sb.AppendLine();

            sb.AppendLine(ftr.CloseOnly
                              ? "\t" + Localization.Drive_supports_only_the_read_compatibility_stop
                              : "\t" + Localization.Drive_supports_both_forms_of_background_format_stopping);

            if(ftr.QuickStart)
                sb.AppendLine("\t" + Localization.Drive_can_do_a_quick_start_formatting);
        }
        else
        {
            sb.Append(Localization.Drive_can_read_DVD_Plus_RW);

            if(ftr.Current)
                sb.AppendLine(Localization.current);
            else
                sb.AppendLine();
        }

        return sb.ToString();
    }

    public static string Prettify_002B(Feature_002B? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_002B ftr = feature.Value;
        var          sb  = new StringBuilder();

        if(ftr.Write)
        {
            sb.Append(Localization.Drive_can_read_and_write_DVD_Plus_R);

            if(ftr.Current)
                sb.AppendLine(Localization.current);
            else
                sb.AppendLine();
        }
        else
        {
            sb.Append(Localization.Drive_can_read_DVD_Plus_R);

            if(ftr.Current)
                sb.AppendLine(Localization.current);
            else
                sb.AppendLine();
        }

        return sb.ToString();
    }

    public static string Prettify_002C(Feature_002C? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_002C ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.MMC_Rigid_Restricted_Overwrite);
        sb.AppendLine(ftr.Current ? $"{Localization.current}:" : ":");

        if(ftr.Blank)
            sb.AppendLine("\t" + Localization.Drive_supports_the_BLANK_command);

        if(ftr.Intermediate)
        {
            sb.AppendLine("\t" +
                          Localization.Drive_supports_writing_on_an_intermediate_state_session_and_quick_formatting);
        }

        if(ftr.DSDR)
            sb.AppendLine("\t" + Localization.Drive_can_read_Defect_Status_data_recorded_on_the_medium);

        if(ftr.DSDG)
            sb.AppendLine("\t" + Localization.Drive_can_generate_Defect_Status_data_during_formatting);

        return sb.ToString();
    }

    public static string Prettify_002D(Feature_002D? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_002D ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.Drive_can_write_CDs_in_Track_at_Once_Mode);

        if(ftr.RWSubchannel)
        {
            sb.AppendLine("\t" + Localization.Drive_can_write_user_provided_data_in_the_R_W_subchannels);

            if(ftr.RWRaw)
                sb.AppendLine("\t" + Localization.Drive_accepts_RAW_R_W_subchannel_data);

            if(ftr.RWPack)
                sb.AppendLine("\t" + Localization.Drive_accepts_Packed_R_W_subchannel_data);
        }

        if(ftr.CDRW)
            sb.AppendLine("\t" + Localization.Drive_can_overwrite_a_TAO_track_with_another_in_CD_RWs);

        if(ftr.TestWrite)
            sb.AppendLine("\t" + Localization.Drive_can_do_a_test_writing);

        if(ftr.BUF)
            sb.AppendLine("\t" + Localization.Drive_supports_zero_loss_linking);

        if(ftr.DataTypeSupported <= 0)
            return sb.ToString();

        sb.Append("\t" + Localization.Drive_supports_data_block_types);

        if((ftr.DataTypeSupported & 0x0001) == 0x0001)
            sb.Append(" 0");

        if((ftr.DataTypeSupported & 0x0002) == 0x0002)
            sb.Append(" 1");

        if((ftr.DataTypeSupported & 0x0004) == 0x0004)
            sb.Append(" 2");

        if((ftr.DataTypeSupported & 0x0008) == 0x0008)
            sb.Append(" 3");

        if((ftr.DataTypeSupported & 0x0010) == 0x0010)
            sb.Append(" 4");

        if((ftr.DataTypeSupported & 0x0020) == 0x0020)
            sb.Append(" 5");

        if((ftr.DataTypeSupported & 0x0040) == 0x0040)
            sb.Append(" 6");

        if((ftr.DataTypeSupported & 0x0080) == 0x0080)
            sb.Append(" 7");

        if((ftr.DataTypeSupported & 0x0100) == 0x0100)
            sb.Append(" 8");

        if((ftr.DataTypeSupported & 0x0200) == 0x0200)
            sb.Append(" 9");

        if((ftr.DataTypeSupported & 0x0400) == 0x0400)
            sb.Append(" 10");

        if((ftr.DataTypeSupported & 0x0800) == 0x0800)
            sb.Append(" 11");

        if((ftr.DataTypeSupported & 0x1000) == 0x1000)
            sb.Append(" 12");

        if((ftr.DataTypeSupported & 0x2000) == 0x2000)
            sb.Append(" 13");

        if((ftr.DataTypeSupported & 0x4000) == 0x4000)
            sb.Append(" 14");

        if((ftr.DataTypeSupported & 0x8000) == 0x8000)
            sb.Append(" 15");

        sb.AppendLine();

        return sb.ToString();
    }

    public static string Prettify_002E(Feature_002E? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_002E ftr = feature.Value;
        var          sb  = new StringBuilder();

        switch(ftr.SAO)
        {
            case true when !ftr.RAW:
                sb.AppendLine(Localization.Drive_can_write_CDs_in_Session_at_Once_Mode);

                break;
            case false when ftr.RAW:
                sb.AppendLine(Localization.Drive_can_write_CDs_in_raw_Mode);

                break;
            default:
                sb.AppendLine(Localization.Drive_can_write_CDs_in_Session_at_Once_and_in_Raw_Modes);

                break;
        }

        if(ftr is { RAW: true, RAWMS: true })
            sb.AppendLine("\t" + Localization.Drive_can_write_multi_session_CDs_in_raw_mode);

        if(ftr.RW)
            sb.AppendLine("\t" + Localization.Drive_can_write_user_provided_data_in_the_R_W_subchannels);

        if(ftr.CDRW)
            sb.AppendLine("\t" + Localization.Drive_can_write_CD_RW);

        if(ftr.TestWrite)
            sb.AppendLine("\t" + Localization.Drive_can_do_a_test_writing);

        if(ftr.BUF)
            sb.AppendLine("\t" + Localization.Drive_supports_zero_loss_linking);

        if(ftr.MaxCueSheet > 0)
        {
            sb.AppendFormat("\t" + Localization.Drive_supports_a_maximum_of_0_bytes_in_a_single_cue_sheet,
                            ftr.MaxCueSheet).
               AppendLine();
        }

        return sb.ToString();
    }

    public static string Prettify_002F(Feature_002F? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_002F ftr = feature.Value;
        var          sb  = new StringBuilder();

        if(ftr is { DVDRW: true, RDL: true })
            sb.AppendLine(Localization.Drive_supports_writing_DVD_R_DVD_RW_and_DVD_R_DL);
        else if(ftr.RDL)
            sb.AppendLine(Localization.Drive_supports_writing_DVD_R_and_DVD_R_DL);
        else if(ftr.DVDRW)
            sb.AppendLine(Localization.Drive_supports_writing_DVD_R_and_DVD_RW);
        else
            sb.AppendLine(Localization.Drive_supports_writing_DVD_R);

        if(ftr.TestWrite)
            sb.AppendLine("\t" + Localization.Drive_can_do_a_test_writing);

        if(ftr.BUF)
            sb.AppendLine("\t" + Localization.Drive_supports_zero_loss_linking);

        return sb.ToString();
    }

    public static string Prettify_0030(Feature_0030? feature) =>
        !feature.HasValue ? null : Localization.Drive_can_read_DDCDs + "\n";

    public static string Prettify_0031(Feature_0031? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0031 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.Drive_supports_writing_DDCD_R);

        if(ftr.TestWrite)
            sb.AppendLine("\t" + Localization.Drive_can_do_a_test_writing);

        return sb.ToString();
    }

    public static string Prettify_0032(Feature_0032? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0032 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.Drive_supports_writing_DDCD_RW);

        if(ftr.Blank)
            sb.AppendLine("\t" + Localization.Drive_supports_the_BLANK_command);

        if(ftr.Intermediate)
            sb.AppendLine("\t" + Localization.Drive_supports_quick_formatting);

        return sb.ToString();
    }

    public static string Prettify_0033(Feature_0033? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0033 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Layer_Jump_Recording);

        if(ftr.LinkSizes == null)
            return sb.ToString();

        foreach(byte link in ftr.LinkSizes)
            sb.AppendFormat("\t" + Localization.Current_media_has_a_0_bytes_link_available, link).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0035(Feature_0035? feature) =>
        !feature.HasValue ? null : Localization.Drive_can_stop_a_long_immediate_operation + "\n";

    public static string Prettify_0037(Feature_0037? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0037 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.Drive_can_write_CD_RW);

        if(ftr.SubtypeSupport <= 0)
            return sb.ToString();

        sb.Append("\t" + Localization.Drive_supports_CD_RW_subtypes);

        if((ftr.SubtypeSupport & 0x01) == 0x01)
            sb.Append(" 0");

        if((ftr.SubtypeSupport & 0x02) == 0x02)
            sb.Append(" 1");

        if((ftr.SubtypeSupport & 0x04) == 0x04)
            sb.Append(" 2");

        if((ftr.SubtypeSupport & 0x08) == 0x08)
            sb.Append(" 3");

        if((ftr.SubtypeSupport & 0x10) == 0x10)
            sb.Append(" 4");

        if((ftr.SubtypeSupport & 0x20) == 0x20)
            sb.Append(" 5");

        if((ftr.SubtypeSupport & 0x40) == 0x40)
            sb.Append(" 6");

        if((ftr.SubtypeSupport & 0x80) == 0x80)
            sb.Append(" 7");

        sb.AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0038(Feature_0038? feature) =>
        !feature.HasValue ? null : Localization.Drive_can_write_BD_R_on_Pseudo_OVerwrite_SRM_mode + "\n";

    public static string Prettify_003A(Feature_003A? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_003A ftr = feature.Value;
        var          sb  = new StringBuilder();

        if(ftr.Write)
        {
            sb.Append(Localization.Drive_can_read_and_write_DVD_Plus_RW_DL);

            if(ftr.Current)
                sb.AppendLine(Localization.current);
            else
                sb.AppendLine();

            sb.AppendLine(ftr.CloseOnly
                              ? "\t" + Localization.Drive_supports_only_the_read_compatibility_stop
                              : "\t" + Localization.Drive_supports_both_forms_of_background_format_stopping);

            if(ftr.QuickStart)
                sb.AppendLine("\t" + Localization.Drive_can_do_a_quick_start_formatting);
        }
        else
        {
            sb.Append(Localization.Drive_can_read_DVD_Plus_RW_DL);

            if(ftr.Current)
                sb.AppendLine(Localization.current);
            else
                sb.AppendLine();
        }

        return sb.ToString();
    }

    public static string Prettify_003B(Feature_003B? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_003B ftr = feature.Value;
        var          sb  = new StringBuilder();

        if(ftr.Write)
        {
            sb.Append(Localization.Drive_can_read_and_write_DVD_Plus_R_DL);

            if(ftr.Current)
                sb.AppendLine(Localization.current);
            else
                sb.AppendLine();
        }
        else
        {
            sb.Append(Localization.Features_Prettify_003B_Drive_can_read_DVD_Plus_R_DL);

            if(ftr.Current)
                sb.AppendLine(Localization.current);
            else
                sb.AppendLine();
        }

        return sb.ToString();
    }

    public static string Prettify_0040(Feature_0040? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0040 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.MMC_BD_Read);
        sb.AppendLine(ftr.Current ? $"{Localization.current}:" : ":");

        if(ftr.OldROM)
            sb.AppendLine("\t" + Localization.Drive_can_read_BD_ROM_pre_1_0);

        if(ftr.ROM)
            sb.AppendLine("\t" + Localization.Drive_can_read_BD_ROM_Ver_1);

        if(ftr.OldR)
            sb.AppendLine("\t" + Localization.Drive_can_read_BD_R_pre_1_0);

        if(ftr.R)
            sb.AppendLine("\t" + Localization.Drive_can_read_BD_R_Ver_1);

        if(ftr.OldRE)
            sb.AppendLine("\t" + Localization.Drive_can_read_BD_RE_pre_1_0);

        if(ftr.RE1)
            sb.AppendLine("\t" + Localization.Drive_can_read_BD_RE_Ver_1);

        if(ftr.RE2)
            sb.AppendLine("\t" + Localization.Drive_can_read_BD_RE_Ver_2);

        if(ftr.BCA)
            sb.AppendLine("\t" + Localization.Drive_can_read_BDs_Burst_Cutting_Area);

        return sb.ToString();
    }

    public static string Prettify_0041(Feature_0041? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0041 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.MMC_BD_Write);
        sb.AppendLine(ftr.Current ? $"{Localization.current}:" : ":");

        if(ftr.OldR)
            sb.AppendLine("\t" + Localization.Drive_can_write_BD_R_pre_1_0);

        if(ftr.R)
            sb.AppendLine("\t" + Localization.Drive_can_write_BD_R_Ver_1);

        if(ftr.OldRE)
            sb.AppendLine("\t" + Localization.Drive_can_write_BD_RE_pre_1_0);

        if(ftr.RE1)
            sb.AppendLine("\t" + Localization.Drive_can_write_BD_RE_Ver_1);

        if(ftr.RE2)
            sb.AppendLine("\t" + Localization.Drive_can_write_BD_RE_Ver_2);

        if(ftr.SVNR)
            sb.AppendLine("\t" + Localization.Drive_supports_write_without_verify_requirement);

        return sb.ToString();
    }

    public static string Prettify_0042(Feature_0042? feature) =>
        !feature.HasValue
            ? null
            : Localization.
                  Features_Prettify_0042_Drive_is_able_to_detect_and_report_defective_writable_unit_and_behave_accordingly +
              "\n";

    public static string Prettify_0050(Feature_0050? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0050 ftr = feature.Value;
        var          sb  = new StringBuilder();

        switch(ftr.HDDVDR)
        {
            case true when ftr.HDDVDRAM:
                sb.Append(Localization.Drive_can_read_HD_DVD_ROM_HD_DVD_RW_HD_DVD_R_and_HD_DVD_RAM);

                break;
            case true:
                sb.Append(Localization.Drive_can_read_HD_DVD_ROM_HD_DVD_RW_and_HD_DVD_R);

                break;
            default:
            {
                sb.Append(ftr.HDDVDRAM
                              ? Localization.Drive_can_read_HD_DVD_ROM_HD_DVD_RW_and_HD_DVD_RAM
                              : Localization.Drive_can_read_HD_DVD_ROM_and_HD_DVD_RW);

                break;
            }
        }

        if(ftr.Current)
            sb.AppendLine(Localization.current);
        else
            sb.AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0051(Feature_0051? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0051 ftr = feature.Value;
        var          sb  = new StringBuilder();

        switch(ftr.HDDVDR)
        {
            case true when ftr.HDDVDRAM:
                sb.Append(Localization.Drive_can_write_HD_DVD_RW_HD_DVD_R_and_HD_DVD_RAM);

                break;
            case true:
                sb.Append(Localization.Drive_can_write_HD_DVD_RW_and_HD_DVD_R);

                break;
            default:
            {
                sb.Append(ftr.HDDVDRAM
                              ? Localization.Drive_can_write_HD_DVD_RW_and_HD_DVD_RAM
                              : Localization.Drive_can_write_HD_DVD_RW);

                break;
            }
        }

        if(ftr.Current)
            sb.AppendLine(Localization.current);
        else
            sb.AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0080(Feature_0080? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0080 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.Drive_is_able_to_access_Hybrid_discs);

        if(ftr.Current)
            sb.AppendLine(Localization.current);
        else
            sb.AppendLine();

        if(ftr.RI)
        {
            sb.AppendLine("\t" +
                          Localization.
                              Drive_is_able_to_maintain_the_online_format_layer_through_reset_and_power_cycling);
        }

        return sb.ToString();
    }

    public static string Prettify_0100(Feature_0100? feature) =>
        !feature.HasValue
            ? null
            : Localization.Drive_is_able_to_perform_host_and_drive_directed_power_management + "\n";

    public static string Prettify_0101(Feature_0101? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0101 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.Drive_supports_SMART);

        if(ftr.PP)
            sb.AppendLine("\t" + Localization.Drive_supports_the_Informational_Exceptions_Control_mode_page_1Ch);

        return sb.ToString();
    }

    public static string Prettify_0102(Feature_0102? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0102 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Embedded_Changer);

        if(ftr.SCC)
            sb.AppendLine("\t" + Localization.Drive_can_change_disc_side);

        if(ftr.SDP)
            sb.AppendLine("\t" + Localization.Drive_is_able_to_report_slots_contents_after_a_reset_or_change);

        sb.AppendFormat("\t" + Localization.Drive_has_0_slots, ftr.HighestSlotNumber + 1).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0103(Feature_0103? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0103 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.Drive_has_an_analogue_audio_output);

        if(ftr.Scan)
            sb.AppendLine("\t" + Localization.Drive_supports_the_SCAN_command);

        if(ftr.SCM)
            sb.AppendLine("\t" + Localization.Drive_is_able_to_mute_channels_separately);

        if(ftr.SV)
            sb.AppendLine("\t" + Localization.Drive_supports_separate_volume_per_channel);

        sb.AppendFormat("\t" + Localization.Drive_has_0_volume_levels, ftr.VolumeLevels + 1).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0104(Feature_0104? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0104 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.Drive_supports_Microcode_Upgrade);

        if(ftr.M5)
        {
            sb.AppendLine(Localization.
                              Drive_supports_validating_the_5_bit_Mode_of_the_READ_BUFFER_and_WRITE_BUFFER_commands);
        }

        return sb.ToString();
    }

    public static string Prettify_0105(Feature_0105? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0105 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.Drive_supports_Timeout_Protect_mode_page_1Dh);

        if(!ftr.Group3)
            return sb.ToString();

        sb.AppendLine("\t" + Localization.Drive_supports_the_Group3_in_Timeout_Protect_mode_page_1Dh);

        if(ftr.UnitLength > 0)
            sb.AppendFormat("\t" + Localization.Drive_has_0_increase_of_Group_3_time_unit, ftr.UnitLength).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0106(Feature_0106? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0106 ftr = feature.Value;
        var          sb  = new StringBuilder();

        if(ftr.Current)
        {
            sb.AppendFormat(Localization.Drive_supports_DVD_CSS_CPPM_version_0_and_current_disc_is_encrypted,
                            ftr.CSSVersion).
               AppendLine();
        }
        else
            sb.AppendFormat(Localization.Drive_supports_DVD_CSS_CPPM_version_0, ftr.CSSVersion).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0107(Feature_0107? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0107 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.MMC_Real_Time_Streaming_);

        if(ftr.SMP)
            sb.AppendLine("\t" + Localization.Drive_supports_Set_Minimum_Performance_with_the_SET_STREAMING_command);

        if(ftr.RBCB)
            sb.AppendLine("\t" + Localization.Drive_supports_the_block_bit_in_the_READ_BUFFER_CAPACITY_command);

        if(ftr.SCS)
            sb.AppendLine("\t" + Localization.Drive_supports_the_SET_CD_SPEED_command);

        if(ftr.MP2A)
        {
            sb.AppendLine("\t" +
                          Localization.
                              Drive_supports_the_Write_Speed_Performance_Descriptor_Blocks_in_the_MMC_mode_page_2Ah);
        }

        if(ftr.WSPD)
        {
            sb.AppendLine("\t" +
                          Localization.
                              Drive_supports_the_Write_Speed_data_of_GET_PERFORMANCE_and_the_WRC_field_of_SET_STREAMING);
        }

        if(ftr.SW)
            sb.AppendLine("\t" + Localization.Drive_supports_stream_recording);

        return sb.ToString();
    }

    public static string Prettify_0108(Feature_0108? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0108 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendFormat(Core.Drive_serial_number_0, ftr.Serial).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0109(Feature_0109? feature) =>
        !feature.HasValue ? null : Localization.Drive_is_able_to_read_media_serial_number + "\n";

    public static string Prettify_010A(Feature_010A? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_010A ftr = feature.Value;
        var          sb  = new StringBuilder();

        if(ftr.DCBs == null)
            return sb.ToString();

        foreach(uint dcb in ftr.DCBs)
            sb.AppendFormat(Localization.Drive_supports_DCB_0, dcb).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_010B(Feature_010B? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_010B ftr = feature.Value;
        var          sb  = new StringBuilder();

        if(ftr.Current)
        {
            sb.AppendFormat(Localization.Drive_supports_DVD_CPRM_version_0_and_current_disc_is_or_can_be_encrypted,
                            ftr.CPRMVersion).
               AppendLine();
        }
        else
            sb.AppendFormat(Localization.Drive_supports_DVD_CPRM_version_0, ftr.CPRMVersion).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_010C(Feature_010C? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_010C ftr = feature.Value;
        var          sb  = new StringBuilder();

        var temp = new byte[4];
        temp[0] = (byte)((ftr.Century & 0xFF00) >> 8);
        temp[1] = (byte)(ftr.Century & 0xFF);
        temp[2] = (byte)((ftr.Year & 0xFF00) >> 8);
        temp[3] = (byte)(ftr.Year & 0xFF);
        string syear = Encoding.ASCII.GetString(temp);
        temp    = new byte[2];
        temp[0] = (byte)((ftr.Month & 0xFF00) >> 8);
        temp[1] = (byte)(ftr.Month & 0xFF);
        string smonth = Encoding.ASCII.GetString(temp);
        temp    = new byte[2];
        temp[0] = (byte)((ftr.Day & 0xFF00) >> 8);
        temp[1] = (byte)(ftr.Day & 0xFF);
        string sday = Encoding.ASCII.GetString(temp);
        temp    = new byte[2];
        temp[0] = (byte)((ftr.Hour & 0xFF00) >> 8);
        temp[1] = (byte)(ftr.Hour & 0xFF);
        string shour = Encoding.ASCII.GetString(temp);
        temp    = new byte[2];
        temp[0] = (byte)((ftr.Minute & 0xFF00) >> 8);
        temp[1] = (byte)(ftr.Minute & 0xFF);
        string sminute = Encoding.ASCII.GetString(temp);
        temp    = new byte[2];
        temp[0] = (byte)((ftr.Second & 0xFF00) >> 8);
        temp[1] = (byte)(ftr.Second & 0xFF);
        string ssecond = Encoding.ASCII.GetString(temp);

        try
        {
            var fwDate = new DateTime(int.Parse(syear), int.Parse(smonth), int.Parse(sday), int.Parse(shour),
                                      int.Parse(sminute), int.Parse(ssecond), DateTimeKind.Utc);

            sb.AppendFormat(Localization.Drive_firmware_is_dated_0, fwDate).AppendLine();
        }
    #pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body
        catch
        {
            // ignored
        }
    #pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body

        return sb.ToString();
    }

    public static string Prettify_010D(Feature_010D? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_010D ftr = feature.Value;
        var          sb  = new StringBuilder();

        if(ftr.Current)
        {
            sb.AppendFormat(Localization.Drive_supports_AACS_version_0_and_current_disc_is_encrypted, ftr.AACSVersion).
               AppendLine();
        }
        else
            sb.AppendFormat(Localization.Drive_supports_AACS_version_0, ftr.AACSVersion).AppendLine();

        if(ftr.RDC)
            sb.AppendLine("\t" + Localization.Drive_supports_reading_the_Drive_Certificate);

        if(ftr.RMC)
            sb.AppendLine("\t" + Localization.Drive_supports_reading_Media_Key_Block_of_CPRM);

        if(ftr.WBE)
            sb.AppendLine("\t" + Localization.Drive_supports_writing_with_bus_encryption);

        if(ftr.BEC)
            sb.AppendLine("\t" + Localization.Drive_supports_bus_encryption);

        if(ftr.BNG)
        {
            sb.AppendLine("\t" + Localization.Drive_supports_generating_the_binding_nonce);

            if(ftr.BindNonceBlocks > 0)
            {
                sb.AppendFormat("\t" + Localization._0_media_blocks_are_required_for_the_binding_nonce,
                                ftr.BindNonceBlocks).
                   AppendLine();
            }
        }

        if(ftr.AGIDs > 0)
            sb.AppendFormat("\t" + Localization.Drive_supports_0_AGIDs_concurrently, ftr.AGIDs).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_010E(Feature_010E? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_010E ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.Append(Localization.Drive_supports_DVD_Download);

        if(ftr.Current)
            sb.AppendLine(Localization.current);
        else
            sb.AppendLine();

        if(ftr.MaxScrambleExtent > 0)
        {
            sb.AppendFormat("\t" + Localization.Maximum_0_scramble_extent_information_entries, ftr.MaxScrambleExtent).
               AppendLine();
        }

        return sb.ToString();
    }

    public static string Prettify_0110(Feature_0110? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0110 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(ftr.Current
                          ? Localization.Drive_and_currently_inserted_media_support_VCPS
                          : Localization.Drive_supports_VCPS);

        return sb.ToString();
    }

    public static string Prettify_0113(Feature_0113? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0113 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(ftr.Current
                          ? Localization.Drive_and_currently_inserted_media_support_SecurDisc
                          : Localization.Drive_supports_SecurDisc);

        return sb.ToString();
    }

    public static string Prettify_0142(Feature_0142? feature)
    {
        if(!feature.HasValue)
            return null;

        Feature_0142 ftr = feature.Value;
        var          sb  = new StringBuilder();

        sb.AppendLine(Localization.Drive_supports_the_Trusted_Computing_Group_Optical_Security_Subsystem_Class);

        if(ftr.Current)
            sb.AppendLine("\t" + Localization.Current_media_is_initialized_with_TCG_OSSC);

        if(ftr.PSAU)
            sb.AppendLine("\t" + Localization.Drive_supports_PSA_updates_on_write_once_media);

        if(ftr.LOSPB)
            sb.AppendLine("\t" + Localization.Drive_supports_linked_OSPBs);

        if(ftr.ME)
            sb.AppendLine("\t" + Localization.Drive_will_only_record_on_the_OSSC_Disc_Format);

        if(ftr.Profiles == null)
            return sb.ToString();

        for(var i = 0; i < ftr.Profiles.Length; i++)
            sb.AppendFormat("\t" + Localization.Profile_0_1, i, ftr.Profiles[i]).AppendLine();

        return sb.ToString();
    }

    public static string Prettify_0000(byte[] feature) => Prettify_0000(Decode_0000(feature));

    public static string Prettify_0001(byte[] feature) => Prettify_0001(Decode_0001(feature));

    public static string Prettify_0002(byte[] feature) => Prettify_0002(Decode_0002(feature));

    public static string Prettify_0003(byte[] feature) => Prettify_0003(Decode_0003(feature));

    public static string Prettify_0004(byte[] feature) => Prettify_0004(Decode_0004(feature));

    public static string Prettify_0010(byte[] feature) => Prettify_0010(Decode_0010(feature));

    public static string Prettify_001D(byte[] feature) => Prettify_001D(Decode_001D(feature));

    public static string Prettify_001E(byte[] feature) => Prettify_001E(Decode_001E(feature));

    public static string Prettify_001F(byte[] feature) => Prettify_001F(Decode_001F(feature));

    public static string Prettify_0020(byte[] feature) => Prettify_0020(Decode_0020(feature));

    public static string Prettify_0021(byte[] feature) => Prettify_0021(Decode_0021(feature));

    public static string Prettify_0022(byte[] feature) => Prettify_0022(Decode_0022(feature));

    public static string Prettify_0023(byte[] feature) => Prettify_0023(Decode_0023(feature));

    public static string Prettify_0024(byte[] feature) => Prettify_0024(Decode_0024(feature));

    public static string Prettify_0025(byte[] feature) => Prettify_0025(Decode_0025(feature));

    public static string Prettify_0026(byte[] feature) => Prettify_0026(Decode_0026(feature));

    public static string Prettify_0027(byte[] feature) => Prettify_0027(Decode_0027(feature));

    public static string Prettify_0028(byte[] feature) => Prettify_0028(Decode_0028(feature));

    public static string Prettify_0029(byte[] feature) => Prettify_0029(Decode_0029(feature));

    public static string Prettify_002A(byte[] feature) => Prettify_002A(Decode_002A(feature));

    public static string Prettify_002B(byte[] feature) => Prettify_002B(Decode_002B(feature));

    public static string Prettify_002C(byte[] feature) => Prettify_002C(Decode_002C(feature));

    public static string Prettify_002D(byte[] feature) => Prettify_002D(Decode_002D(feature));

    public static string Prettify_002E(byte[] feature) => Prettify_002E(Decode_002E(feature));

    public static string Prettify_002F(byte[] feature) => Prettify_002F(Decode_002F(feature));

    public static string Prettify_0030(byte[] feature) => Prettify_0030(Decode_0030(feature));

    public static string Prettify_0031(byte[] feature) => Prettify_0031(Decode_0031(feature));

    public static string Prettify_0032(byte[] feature) => Prettify_0032(Decode_0032(feature));

    public static string Prettify_0033(byte[] feature) => Prettify_0033(Decode_0033(feature));

    public static string Prettify_0035(byte[] feature) => Prettify_0035(Decode_0035(feature));

    public static string Prettify_0037(byte[] feature) => Prettify_0037(Decode_0037(feature));

    public static string Prettify_0038(byte[] feature) => Prettify_0038(Decode_0038(feature));

    public static string Prettify_003A(byte[] feature) => Prettify_003A(Decode_003A(feature));

    public static string Prettify_003B(byte[] feature) => Prettify_003B(Decode_003B(feature));

    public static string Prettify_0040(byte[] feature) => Prettify_0040(Decode_0040(feature));

    public static string Prettify_0041(byte[] feature) => Prettify_0041(Decode_0041(feature));

    public static string Prettify_0042(byte[] feature) => Prettify_0042(Decode_0042(feature));

    public static string Prettify_0050(byte[] feature) => Prettify_0050(Decode_0050(feature));

    public static string Prettify_0051(byte[] feature) => Prettify_0051(Decode_0051(feature));

    public static string Prettify_0080(byte[] feature) => Prettify_0080(Decode_0080(feature));

    public static string Prettify_0100(byte[] feature) => Prettify_0100(Decode_0100(feature));

    public static string Prettify_0101(byte[] feature) => Prettify_0101(Decode_0101(feature));

    public static string Prettify_0102(byte[] feature) => Prettify_0102(Decode_0102(feature));

    public static string Prettify_0103(byte[] feature) => Prettify_0103(Decode_0103(feature));

    public static string Prettify_0104(byte[] feature) => Prettify_0104(Decode_0104(feature));

    public static string Prettify_0105(byte[] feature) => Prettify_0105(Decode_0105(feature));

    public static string Prettify_0106(byte[] feature) => Prettify_0106(Decode_0106(feature));

    public static string Prettify_0107(byte[] feature) => Prettify_0107(Decode_0107(feature));

    public static string Prettify_0108(byte[] feature) => Prettify_0108(Decode_0108(feature));

    public static string Prettify_0109(byte[] feature) => Prettify_0109(Decode_0109(feature));

    public static string Prettify_010A(byte[] feature) => Prettify_010A(Decode_010A(feature));

    public static string Prettify_010B(byte[] feature) => Prettify_010B(Decode_010B(feature));

    public static string Prettify_010C(byte[] feature) => Prettify_010C(Decode_010C(feature));

    public static string Prettify_010D(byte[] feature) => Prettify_010D(Decode_010D(feature));

    public static string Prettify_010E(byte[] feature) => Prettify_010E(Decode_010E(feature));

    public static string Prettify_0110(byte[] feature) => Prettify_0110(Decode_0110(feature));

    public static string Prettify_0113(byte[] feature) => Prettify_0113(Decode_0113(feature));

    public static string Prettify_0142(byte[] feature) => Prettify_0142(Decode_0142(feature));

    public static SeparatedFeatures Separate(byte[] response)
    {
        var dec = new SeparatedFeatures
        {
            DataLength     = (uint)((response[0]   << 24) + (response[1] << 16) + (response[2] << 8) + response[4]),
            CurrentProfile = (ushort)((response[6] << 8)  + response[7])
        };

        uint                    offset  = 8;
        List<FeatureDescriptor> descLst = new();

        while(offset + 4 < response.Length)
        {
            var desc = new FeatureDescriptor
            {
                Code = (ushort)((response[offset + 0] << 8) + response[offset + 1]),
                Data = new byte[response[offset + 3] + 4]
            };

            if(desc.Data.Length + offset > response.Length)
                desc.Data = new byte[response.Length - offset];

            Array.Copy(response, offset, desc.Data, 0, desc.Data.Length);
            offset += (uint)desc.Data.Length;

            descLst.Add(desc);
        }

        dec.Descriptors = descLst.ToArray();

        return dec;
    }

#region Nested type: FeatureDescriptor

    public struct FeatureDescriptor
    {
        public ushort Code;
        public byte[] Data;
    }

#endregion

#region Nested type: SeparatedFeatures

    public struct SeparatedFeatures
    {
        public uint                DataLength;
        public ushort              CurrentProfile;
        public FeatureDescriptor[] Descriptors;
    }

#endregion
}