// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename       : Sense.cs
// Author(s)      : Natalia Portillo <claunia@claunia.com>
//
// Component      : Device structures decoders.
//
// --[ Description ] ----------------------------------------------------------
//
//     Decodes SCSI SENSE.
//
// --[ 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-2019 Natalia Portillo
// ****************************************************************************/

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Text;
using DiscImageChef.Decoders.ATA;

namespace DiscImageChef.Decoders.SCSI
{
    public enum SenseType
    {
        StandardSense, ExtendedSenseFixedCurrent, ExtendedSenseFixedPast,
        ExtendedSenseDescriptorCurrent, ExtendedSenseDescriptorPast, Invalid,
        Unknown
    }

    [SuppressMessage("ReSharper", "MemberCanBeInternal"), SuppressMessage("ReSharper", "NotAccessedField.Global"),
     SuppressMessage("ReSharper", "InconsistentNaming")]
    public struct StandardSense
    {
        /// <summary>If set, <see cref="LBA" /> is valid</summary>
        public bool AddressValid;
        /// <summary>Error class, 0 to 6</summary>
        public byte ErrorClass;
        /// <summary>Error type</summary>
        public byte ErrorType;
        /// <summary>Private usage</summary>
        public byte Private;
        /// <summary>LBA where error happened</summary>
        public uint LBA;
    }

    public enum SenseKeys : byte
    {
        /// <summary>No information to be reported, but bits should be checked</summary>
        NoSense = 0, /// <summary>Target performed some recovery to successfully complete last command</summary>
        RecoveredError = 1, /// <summary>Target is not ready</summary>
        NotReady = 2, /// <summary>Non-recoverable medium error occurred</summary>
        MediumError = 3, /// <summary>Non-recoverable hardware error occurred</summary>
        HardwareError = 4, /// <summary>Target has received an illegal request</summary>
        IllegalRequest = 5, /// <summary>Target requires initiator attention</summary>
        UnitAttention = 6, /// <summary>A protected command has been denied</summary>
        DataProtect = 7, /// <summary>A blank block has been tried to read or a non-rewritable one to write</summary>
        BlankCheck = 8, /// <summary>For private/vendor usage</summary>
        PrivateUse = 9, /// <summary>COPY command aborted</summary>
        CopyAborted = 0xA, /// <summary>Command aborted</summary>
        AbortedCommand = 0xB, /// <summary>SEARCH command has been satisfied</summary>
        Equal = 0xC, /// <summary>End-of-medium reached with data remaining in buffer</summary>
        VolumeOverflow = 0xD, /// <summary>COMPARE failed</summary>
        Miscompare = 0xE, /// <summary>Complated</summary>
        Completed = 0xF
    }

    [SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
     SuppressMessage("ReSharper", "MemberCanBePrivate.Global"), SuppressMessage("ReSharper", "UnassignedField.Global"),
     SuppressMessage("ReSharper", "NotAccessedField.Global")]
    public struct FixedSense
    {
        /// <summary>If set, <see cref="Information" /> is valid</summary>
        public bool InformationValid;
        /// <summary>Contains number of current segment descriptor</summary>
        public byte SegmentNumber;
        /// <summary>If set indicates current command has read a filemark or a setmark</summary>
        public bool Filemark;
        /// <summary>If set indicates device has arrived end-of-medium</summary>
        public bool EOM;
        /// <summary>Means the requested logical block length did not match the logical block length on the medium</summary>
        public bool ILI;
        /// <summary>Contains the sense key</summary>
        public SenseKeys SenseKey;
        /// <summary>Additional information</summary>
        public uint Information;
        /// <summary>Additional sense length</summary>
        public byte AdditionalLength;
        /// <summary>Command specific information field</summary>
        public uint CommandSpecific;
        /// <summary>Additional sense code</summary>
        public byte ASC;
        /// <summary>Additional sense code qualifier</summary>
        public byte ASCQ;
        public byte FieldReplaceable;
        /// <summary>If set, <see cref="SenseKeySpecific" /> is valid</summary>
        public bool SKSV;
        public uint   SenseKeySpecific;
        public byte[] AdditionalSense;
    }

    [SuppressMessage("ReSharper", "MemberCanBeInternal"), SuppressMessage("ReSharper", "InconsistentNaming"),
     SuppressMessage("ReSharper", "NotAccessedField.Global")]
    public struct DescriptorSense
    {
        /// <summary>Contains the sense key</summary>
        public SenseKeys SenseKey;
        /// <summary>Additional sense code</summary>
        public byte ASC;
        /// <summary>Additional sense code qualifier</summary>
        public byte ASCQ;
        public bool Overflow;
        /// <summary>The descriptors, indexed by type</summary>
        public Dictionary<byte, byte[]> Descriptors;
    }

    [SuppressMessage("ReSharper", "MemberCanBeInternal"), SuppressMessage("ReSharper", "InconsistentNaming"),
     SuppressMessage("ReSharper", "NotAccessedField.Global")]
    public struct AnotherProgressIndicationSenseDescriptor
    {
        public SenseKeys SenseKey;
        public byte      ASC;
        public byte      ASCQ;
        public ushort    Progress;
    }

    [SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
    public static class Sense
    {
        /// <summary>Gets the SCSI SENSE type to help chosing the correct decoding function</summary>
        /// <returns>The type.</returns>
        /// <param name="sense">Sense bytes.</param>
        public static SenseType GetType(byte[] sense)
        {
            if(sense == null)
                return SenseType.Invalid;

            if(sense.Length < 4)
                return SenseType.Invalid;

            if((sense[0] & 0x70) != 0x70)
                return sense.Length != 4 ? SenseType.Invalid : SenseType.StandardSense;

            switch(sense[0] & 0x0F)
            {
                case 0:  return SenseType.ExtendedSenseFixedCurrent;
                case 1:  return SenseType.ExtendedSenseFixedPast;
                case 2:  return SenseType.ExtendedSenseDescriptorCurrent;
                case 3:  return SenseType.ExtendedSenseDescriptorPast;
                default: return SenseType.Unknown;
            }
        }

        public static StandardSense? DecodeStandard(byte[] sense)
        {
            if(GetType(sense) != SenseType.StandardSense)
                return null;

            var decoded = new StandardSense();
            decoded.AddressValid |= (sense[0] & 0x80) == 0x80;
            decoded.ErrorClass   =  (byte)((sense[0] & 0x70) >> 4);
            decoded.ErrorType    =  (byte)(sense[0] & 0x0F);
            decoded.Private      =  (byte)((sense[1] & 0x80) >> 4);
            decoded.LBA          =  (uint)(((sense[1] & 0x0F) << 16) + (sense[2] << 8) + sense[3]);

            return decoded;
        }

        public static FixedSense? DecodeFixed(byte[] sense) => DecodeFixed(sense, out _);

        public static FixedSense? DecodeFixed(byte[] sense, out string senseDescription)
        {
            senseDescription = null;

            if((sense[0] & 0x7F) != 0x70 &&
               (sense[0] & 0x7F) != 0x71)
                return null;

            if(sense.Length < 8)
                return null;

            var decoded = new FixedSense
            {
                InformationValid = (sense[0]            & 0x80) == 0x80, SegmentNumber = sense[1],
                Filemark         = (sense[2]            & 0x80) == 0x80, EOM           = (sense[2] & 0x40) == 0x40,
                ILI              = (sense[2]            & 0x20) == 0x20,
                SenseKey         = (SenseKeys)(sense[2] & 0x0F),
                Information      = (uint)((sense[3] << 24) + (sense[4] << 16) + (sense[5] << 8) + sense[6]),
                AdditionalLength = sense[7]
            };

            if(sense.Length >= 12)
                decoded.CommandSpecific = (uint)((sense[8] << 24) + (sense[9] << 16) + (sense[10] << 8) + sense[11]);

            if(sense.Length >= 14)
            {
                decoded.ASC      = sense[12];
                decoded.ASCQ     = sense[13];
                senseDescription = GetSenseDescription(decoded.ASC, decoded.ASCQ);
            }

            if(sense.Length >= 15)
                decoded.FieldReplaceable = sense[14];

            if(sense.Length >= 18)
                decoded.SenseKeySpecific = (uint)((sense[15] << 16) + (sense[16] << 8) + sense[17]);

            if(sense.Length <= 18)
                return decoded;

            decoded.AdditionalSense = new byte[sense.Length - 18];
            Array.Copy(sense, 18, decoded.AdditionalSense, 0, decoded.AdditionalSense.Length);

            return decoded;
        }

        public static DescriptorSense? DecodeDescriptor(byte[] sense) => DecodeDescriptor(sense, out _);

        public static DescriptorSense? DecodeDescriptor(byte[] sense, out string senseDescription)
        {
            senseDescription = null;

            if(sense == null)
                return null;

            if(sense.Length < 8)
                return null;

            var decoded = new DescriptorSense
            {
                SenseKey = (SenseKeys)(sense[1] & 0x0F), ASC                 = sense[2], ASCQ = sense[3],
                Overflow = (sense[4]            & 0x80) == 0x80, Descriptors = new Dictionary<byte, byte[]>()
            };

            senseDescription = GetSenseDescription(decoded.ASC, decoded.ASCQ);

            int offset = 8;

            while(offset < sense.Length)
                if(offset + 2 < sense.Length)
                {
                    byte descType = sense[offset];
                    int  descLen  = sense[offset + 1] + 1;

                    byte[] desc = new byte[descLen];
                    Array.Copy(sense, offset, desc, 0, descLen);

                    if(!decoded.Descriptors.ContainsKey(descType))
                        decoded.Descriptors.Add(descType, desc);

                    offset += descLen;
                }
                else
                    break;

            return decoded;
        }

        public static string PrettifySense(byte[] sense)
        {
            SenseType type = GetType(sense);

            switch(type)
            {
                case SenseType.StandardSense: return PrettifySense(DecodeStandard(sense));
                case SenseType.ExtendedSenseFixedCurrent:
                case SenseType.ExtendedSenseFixedPast: return PrettifySense(DecodeFixed(sense));
                case SenseType.ExtendedSenseDescriptorCurrent:
                case SenseType.ExtendedSenseDescriptorPast: return PrettifySense(DecodeDescriptor(sense));
                default: return null;
            }
        }

        public static string PrettifySense(StandardSense? sense)
        {
            if(!sense.HasValue)
                return null;

            return sense.Value.AddressValid
                       ? $"Error class {sense.Value.ErrorClass} type {sense.Value.ErrorType} happened on block {sense.Value.LBA}\n"
                       : $"Error class {sense.Value.ErrorClass} type {sense.Value.ErrorType}\n";
        }

        public static string PrettifySense(FixedSense? sense)
        {
            if(!sense.HasValue)
                return null;

            FixedSense decoded = sense.Value;

            var sb = new StringBuilder();

            sb.AppendFormat("SCSI SENSE: {0}", GetSenseKey(decoded.SenseKey)).AppendLine();

            if(decoded.SegmentNumber > 0)
                sb.AppendFormat("On segment {0}", decoded.SegmentNumber).AppendLine();

            if(decoded.Filemark)
                sb.AppendLine("Filemark or setmark found");

            if(decoded.EOM)
                sb.AppendLine("End-of-medium/partition found");

            if(decoded.ILI)
                sb.AppendLine("Incorrect length indicator");

            if(decoded.InformationValid)
                sb.AppendFormat("On logical block {0}", decoded.Information).AppendLine();

            if(decoded.AdditionalLength < 6)
                return sb.ToString();

            sb.AppendLine(GetSenseDescription(decoded.ASC, decoded.ASCQ));

            if(decoded.AdditionalLength < 10)
                return sb.ToString();

            if(!decoded.SKSV)
                return sb.ToString();

            switch(decoded.SenseKey)
            {
                case SenseKeys.IllegalRequest:
                {
                    sb.AppendLine((decoded.SenseKeySpecific & 0x400000) == 0x400000 ? "Illegal field in CDB"
                                      : "Illegal field in data parameters");

                    if((decoded.SenseKeySpecific & 0x200000) == 0x200000)
                        sb.AppendFormat("Invalid value in bit {0} in field {1} of CDB",
                                        (decoded.SenseKeySpecific & 0x70000) >> 16, decoded.SenseKeySpecific & 0xFFFF).
                           AppendLine();
                    else
                        sb.AppendFormat("Invalid value in field {0} of CDB", decoded.SenseKeySpecific & 0xFFFF).
                           AppendLine();
                }

                    break;
                case SenseKeys.NotReady:
                    sb.AppendFormat("Format progress {0:P}", (double)(decoded.SenseKeySpecific & 0xFFFF) / 65536).
                       AppendLine();

                    break;
                case SenseKeys.RecoveredError:
                case SenseKeys.HardwareError:
                case SenseKeys.MediumError:
                    sb.AppendFormat("Actual retry count is {0}", decoded.SenseKeySpecific & 0xFFFF).AppendLine();

                    break;
            }

            return sb.ToString();
        }

        public static string PrettifySense(DescriptorSense? sense)
        {
            if(!sense.HasValue)
                return null;

            DescriptorSense decoded = sense.Value;

            var sb = new StringBuilder();

            sb.AppendFormat("SCSI SENSE: {0}", GetSenseKey(decoded.SenseKey)).AppendLine();
            sb.AppendLine(GetSenseDescription(decoded.ASC, decoded.ASCQ));

            if(decoded.Descriptors       == null ||
               decoded.Descriptors.Count == 0)
                return sb.ToString();

            foreach(KeyValuePair<byte, byte[]> kvp in decoded.Descriptors)
                switch(kvp.Key)
                {
                    case 0x00:
                        sb.AppendLine(PrettifyDescriptor00(kvp.Value));

                        break;
                }

            return sb.ToString();
        }

        /// <summary>Decodes the information sense data descriptor</summary>
        /// <returns>The information value</returns>
        /// <param name="descriptor">Descriptor.</param>
        public static ulong DecodeDescriptor00(byte[] descriptor)
        {
            if(descriptor.Length != 12 ||
               descriptor[0]     != 0x00)
                return 0;

            byte[] temp = new byte[8];

            temp[0] = descriptor[11];
            temp[1] = descriptor[10];
            temp[2] = descriptor[9];
            temp[3] = descriptor[8];
            temp[4] = descriptor[7];
            temp[5] = descriptor[6];
            temp[6] = descriptor[5];
            temp[7] = descriptor[4];

            return BitConverter.ToUInt64(temp, 0);
        }

        /// <summary>Decodes the command-specific information sense data descriptor</summary>
        /// <returns>The command-specific information sense data descriptor.</returns>
        /// <param name="descriptor">Descriptor.</param>
        public static ulong DecodeDescriptor01(byte[] descriptor)
        {
            if(descriptor.Length != 12 ||
               descriptor[0]     != 0x01)
                return 0;

            byte[] temp = new byte[8];

            temp[0] = descriptor[11];
            temp[1] = descriptor[10];
            temp[2] = descriptor[9];
            temp[3] = descriptor[8];
            temp[4] = descriptor[7];
            temp[5] = descriptor[6];
            temp[6] = descriptor[5];
            temp[7] = descriptor[4];

            return BitConverter.ToUInt64(temp, 0);
        }

        /// <summary>Decodes the sense key specific sense data descriptor</summary>
        /// <returns>The sense key specific sense data descriptor.</returns>
        /// <param name="descriptor">Descriptor.</param>
        public static byte[] DecodeDescriptor02(byte[] descriptor)
        {
            if(descriptor.Length != 8 ||
               descriptor[0]     != 0x02)
                return null;

            byte[] temp = new byte[3];
            Array.Copy(descriptor, 4, temp, 0, 3);

            return temp;
        }

        /// <summary>Decodes the field replaceable unit sense data descriptor</summary>
        /// <returns>The field replaceable unit sense data descriptor.</returns>
        /// <param name="descriptor">Descriptor.</param>
        public static byte DecodeDescriptor03(byte[] descriptor)
        {
            if(descriptor.Length != 4 ||
               descriptor[0]     != 0x03)
                return 0;

            return descriptor[3];
        }

        /// <summary>Decodes the another progress indication sense data descriptor</summary>
        /// <returns>The another progress indication sense data descriptor.</returns>
        /// <param name="descriptor">Descriptor.</param>
        public static AnotherProgressIndicationSenseDescriptor? DecodeDescriptor0A(byte[] descriptor)
        {
            if(descriptor.Length != 8 ||
               descriptor[0]     != 0x0A)
                return null;

            return new AnotherProgressIndicationSenseDescriptor
            {
                SenseKey = (SenseKeys)descriptor[2], ASC = descriptor[3], ASCQ = descriptor[4],
                Progress = (ushort)((descriptor[6] << 8) + descriptor[7])
            };
        }

        public static void DecodeDescriptor04(byte[] descriptor) => throw new NotImplementedException("Check SSC-4");

        public static void DecodeDescriptor05(byte[] descriptor) => throw new NotImplementedException("Check SBC-3");

        public static void DecodeDescriptor06(byte[] descriptor) => throw new NotImplementedException("Check OSD");

        public static void DecodeDescriptor07(byte[] descriptor) => throw new NotImplementedException("Check OSD");

        public static void DecodeDescriptor08(byte[] descriptor) => throw new NotImplementedException("Check OSD");

        public static AtaErrorRegistersLba48 DecodeDescriptor09(byte[] descriptor) => new AtaErrorRegistersLba48
        {
            Error      = descriptor[3], SectorCount = (ushort)((descriptor[4] << 8) + descriptor[5]),
            LbaLow     = (ushort)((descriptor[6]                              << 8) + descriptor[7]),
            LbaMid     = (ushort)((descriptor[8]                              << 8) + descriptor[9]),
            LbaHigh    = (ushort)((descriptor[10]                             << 8) + descriptor[11]),
            DeviceHead = descriptor[12],
            Status     = descriptor[13]
        };

        public static void DecodeDescriptor0B(byte[] descriptor) => throw new NotImplementedException("Check SBC-3");

        public static void DecodeDescriptor0D(byte[] descriptor) => throw new NotImplementedException("Check SBC-3");

        public static string PrettifyDescriptor00(ulong information) => $"On logical block {information}\n";

        public static string PrettifyDescriptor00(byte[] descriptor) =>
            PrettifyDescriptor00(DecodeDescriptor00(descriptor));

        public static string GetSenseKey(SenseKeys key)
        {
            switch(key)
            {
                case SenseKeys.AbortedCommand: return"ABORTED COMMAND";
                case SenseKeys.BlankCheck:     return"BLANK CHECK";
                case SenseKeys.CopyAborted:    return"COPY ABORTED";
                case SenseKeys.DataProtect:    return"DATA PROTECT";
                case SenseKeys.Equal:          return"EQUAL";
                case SenseKeys.HardwareError:  return"HARDWARE ERROR";
                case SenseKeys.IllegalRequest: return"ILLEGAL REQUEST";
                case SenseKeys.MediumError:    return"MEDIUM ERROR";
                case SenseKeys.Miscompare:     return"MISCOMPARE";
                case SenseKeys.NoSense:        return"NO SENSE";
                case SenseKeys.PrivateUse:     return"PRIVATE USE";
                case SenseKeys.RecoveredError: return"RECOVERED ERROR";
                case SenseKeys.Completed:      return"COMPLETED";
                case SenseKeys.UnitAttention:  return"UNIT ATTENTION";
                case SenseKeys.VolumeOverflow: return"VOLUME OVERFLOW";
                default:                       return"UNKNOWN";
            }
        }

        [SuppressMessage("ReSharper", "InconsistentNaming")]
        public static string GetSenseDescription(byte ASC, byte ASCQ)
        {
            switch(ASC)
            {
                case 0x00:
                    switch(ASCQ)
                    {
                        case 0x00: return"NO ADDITIONAL SENSE INFORMATION";
                        case 0x01: return"FILEMARK DETECTED";
                        case 0x02: return"END-OF-PARTITION/MEDIUM DETECTED";
                        case 0x03: return"SETMARK DETECTED";
                        case 0x04: return"BEGINNING-OF-PARTITION/MEDIUM DETECTED";
                        case 0x05: return"END-OF-DATA DETECTED";
                        case 0x06: return"I/O PROCESS TERMINATED";
                        case 0x07: return"PROGRAMMABLE EARLY WARNING DETECTED";
                        case 0x11: return"AUDIO PLAY OPERATION IN PROGRESS";
                        case 0x12: return"AUDIO PLAY OPERATION PAUSED";
                        case 0x13: return"AUDIO PLAY OPERATION SUCCESSFULLY COMPLETED";
                        case 0x14: return"AUDIO PLAY OPERATION STOPPED DUE TO ERROR";
                        case 0x15: return"NO CURRENT AUDIO STATUS TO RETURN";
                        case 0x16: return"OPERATION IN PROGRESS";
                        case 0x17: return"CLEANING REQUESTED";
                        case 0x18: return"ERASE OPERATION IN PROGRESS";
                        case 0x19: return"LOCATE OPERATION IN PROGRESS";
                        case 0x1A: return"REWIND OPERATION IN PROGRESS";
                        case 0x1B: return"SET CAPACITY OPERATION IN PROGRESS";
                        case 0x1C: return"VERIFY OPERATION IN PROGRESS";
                        case 0x1D: return"ATA PASS THROUGH INFORMATION AVAILABLE";
                        case 0x1E: return"CONFLICTING SA CREATION REQUEST";
                        case 0x1F: return"LOGICAL UNIT TRANSITIONING TO ANOTHER POWER CONDITION";
                        case 0x20: return"EXTENDED COPY INFORMATION AVAILABLE";
                        case 0x21: return"ATOMIC COMMAND ABORTED DUE TO ACA";
                    }

                    break;
                case 0x01:
                    switch(ASCQ)
                    {
                        case 0x00: return"NO INDEX/SECTOR SIGNAL";
                    }

                    break;
                case 0x02:
                    switch(ASCQ)
                    {
                        case 0x00: return"NO SEEK COMPLETE";
                    }

                    break;
                case 0x03:
                    switch(ASCQ)
                    {
                        case 0x00: return"PERIPHERAL DEVICE WRITE FAULT";
                        case 0x01: return"NO WRITE CURRENT";
                        case 0x02: return"EXCESSIVE WRITE ERRORS";
                    }

                    break;
                case 0x04:
                    switch(ASCQ)
                    {
                        case 0x00: return"LOGICAL UNIT NOT READY, CAUSE NOT REPORTABLE";
                        case 0x01: return"LOGICAL UNIT IS IN PROCESS OF BECOMING READY";
                        case 0x02: return"LOGICAL UNIT NOT READY, INITIALIZING COMMAND REQUIRED";
                        case 0x03: return"LOGICAL UNIT NOT READY, MANUAL INTERVENTION REQUIRED";
                        case 0x04: return"LOGICAL UNIT NOT READY, FORMAT IN PROGRESS";
                        case 0x05: return"LOGICAL UNIT NOT READY, REBUILD IN PROGRESS";
                        case 0x06: return"LOGICAL UNIT NOT READY, RECALCULATION IN PROGRESS";
                        case 0x07: return"LOGICAL UNIT NOT READY, OPERATION IN PROGRESS";
                        case 0x08: return"LOGICAL UNIT NOT READY, LONG WRITE IN PROGRESS";
                        case 0x09: return"LOGICAL UNIT NOT READY, SELF-TEST IN PROGRESS";
                        case 0x0A: return"LOGICAL UNIT NOT ACCESSIBLE, ASYMMETRIC ACCESS STATE TRANSITION";
                        case 0x0B: return"LOGICAL UNIT NOT ACCESSIBLE, TARGET IN STANDBY STATE";
                        case 0x0C: return"LOGICAL UNIT NOT ACCESSIBLE, TARGET PORT IN UNAVAILABLE STATE";
                        case 0x0D: return"LOGICAL UNIT NOT READY, STRUCTURE CHECK REQUIRED";
                        case 0x0E: return"LOGICAL UNIT NOT READY, SECURITY SESSION IN PROGRESS";
                        case 0x10: return"LOGICAL UNIT NOT READY, AUXILIARY MEMORY NOT ACCESSIBLE";
                        case 0x11: return"LOGICAL UNIT NOT READY, NOTIFY (ENABLE SPINUP) REQUIRED";
                        case 0x12: return"LOGICAL UNIT NOT READY, OFFLINE";
                        case 0x13: return"LOGICAL UNIT NOT READY, SA CREATION IN PROGRESS";
                        case 0x14: return"LOGICAL UNIT NOT READY, SPACE ALLOCATION IN PROGRESS";
                        case 0x15: return"LOGICAL UNIT NOT READY, ROBOTICS DISABLED";
                        case 0x16: return"LOGICAL UNIT NOT READY, CONFIGURATION REQUIRED";
                        case 0x17: return"LOGICAL UNIT NOT READY, CALIBRATION REQUIRED";
                        case 0x18: return"LOGICAL UNIT NOT READY, A DOOR IS OPEN";
                        case 0x19: return"LOGICAL UNIT NOT READY, OPERATING IN SEQUENTIAL MODE";
                        case 0x1A: return"LOGICAL UNIT NOT READY, START STOP UNIT IN PROGRESS";
                        case 0x1B: return"LOGICAL UNIT NOT READY, SANITIZE IN PROGRESS";
                        case 0x1C: return"LOGICAL UNIT NOT READY, ADDITIONAL POWER USE NOT YET GRANTED";
                        case 0x1D: return"LOGICAL UNIT NOT READY, CONFIGURATION IN PROGRESS";
                        case 0x1E: return"LOGICAL UNIT NOT READY, MICROCODE ACTIVATION REQUIRED";
                        case 0x1F: return"LOGICAL UNIT NOT READY, MICROCODE DOWNLOAD REQUIRED";
                        case 0x20: return"LOGICAL UNIT NOT READY, LOGICAL UNIT RESET REQUIRED";
                        case 0x21: return"LOGICAL UNIT NOT READY, HARD RESET REQUIRED";
                        case 0x22: return"LOGICAL UNIT NOT READY, POWER CYCLE REQUIRED";
                    }

                    break;
                case 0x05:
                    switch(ASCQ)
                    {
                        case 0x00: return"LOGICAL UNIT DOES NOT RESPOND TO SELECTION";
                    }

                    break;
                case 0x06:
                    switch(ASCQ)
                    {
                        case 0x00: return"NO REFERENCE POSITION FOUND";
                    }

                    break;
                case 0x07:
                    switch(ASCQ)
                    {
                        case 0x00: return"MULTIPLE PERIPHERAL DEVICES SELECTED";
                    }

                    break;
                case 0x08:
                    switch(ASCQ)
                    {
                        case 0x00: return"LOGICAL UNIT COMMUNICATION FAILURE";
                        case 0x01: return"LOGICAL UNIT COMMUNICATION TIME-OUT";
                        case 0x02: return"LOGICAL UNIT COMMUNICATION PARITY ERROR";
                        case 0x03: return"LOGICAL UNIT COMMUNICATION CRC ERROR";
                        case 0x04: return"UNREACHABLE COPY TARGET";
                    }

                    break;
                case 0x09:
                    switch(ASCQ)
                    {
                        case 0x00: return"TRACK FLOLLOWING ERROR";
                        case 0x01: return"TRACKING SERVO FAILURE";
                        case 0x02: return"FOCUS SERVO FAILURE";
                        case 0x03: return"SPINDLE SERVO FAILURE";
                        case 0x04: return"HEAD SELECT FAULT";
                        case 0x05: return"VIBRATION INDUCED TRACKING ERROR";
                    }

                    break;
                case 0x0A:
                    switch(ASCQ)
                    {
                        case 0x00: return"ERROR LOG OVERFLOW";
                    }

                    break;
                case 0x0B:
                    switch(ASCQ)
                    {
                        case 0x00: return"WARNING";
                        case 0x01: return"WARNING - SPECIFIED TEMPERATURE EXCEEDED";
                        case 0x02: return"WARNING - ENCLOSURE DEGRADED";
                        case 0x03: return"WARNING - BACKGROUND SELF-TEST FAILED";
                        case 0x04: return"WARNING - BACKGROUND PRE-SCAN DETECTED MEDIUM ERROR";
                        case 0x05: return"WARNING - BACKGROUND MEDIUM SCAN DETECTED MEDIUM ERROR";
                        case 0x06: return"WARNING - NON-VOLATILE CACHE NOW VOLATILE";
                        case 0x07: return"WARNING - DEGRADED POWER TO NON-VOLATILE CACHE";
                        case 0x08: return"WARNING - POWER LOSS EXPECTED";
                        case 0x09: return"WARNING - DEVICE STATISTICS NOTIFICATION ACTIVE";
                        case 0x0A: return"WARNING - HIGH CRITICAL TEMPERATURE LIMIT EXCEEDED";
                        case 0x0B: return"WARNING - LOW CRITICAL TEMPERATURE LIMIT EXCEEDED";
                        case 0x0C: return"WARNING - HIGH OPERATING TEMPERATURE LIMIT EXCEEDED";
                        case 0x0D: return"WARNING - LOW OPERATING TEMPERATURE LIMIT EXCEEDED";
                        case 0x0E: return"WARNING - HIGH CRITICAL HUMIDITY LIMIT EXCEEDED";
                        case 0x0F: return"WARNING - LOW CRITICAL HUMIDITY LIMIT EXCEEDED";
                        case 0x10: return"WARNING - HIGH OPERATING HUMIDITY LIMIT EXCEEDED";
                        case 0x11: return"WARNING - LOW OPERATING HUMIDITY LIMIT EXCEEDED";
                    }

                    break;
                case 0x0C:
                    switch(ASCQ)
                    {
                        case 0x00: return"WRITE ERROR";
                        case 0x01: return"WRITE ERROR - RECOVERED WITH AUTO REALLOCATION";
                        case 0x02: return"WRITE ERROR - AUTO REALLOCATION FAILED";
                        case 0x03: return"WRITE ERROR - RECOMMENDED REASSIGNMENT";
                        case 0x04: return"COMPRESSION CHECK MISCOMPARE ERROR";
                        case 0x05: return"DATA EXPANSION OCCURRED DURING COMPRESSION";
                        case 0x06: return"BLOCK NOT COMPRESSIBLE";
                        case 0x07: return"WRITE ERROR - RECOVERY NEEDED";
                        case 0x08: return"WRITE ERROR - RECOVERY FAILED";
                        case 0x09: return"WRITE ERROR - LOSS OF STREAMING";
                        case 0x0A: return"WRITE ERROR - PADDING BLOCKS ADDED";
                        case 0x0B: return"AUXILIARY MEMORY WRITE ERROR";
                        case 0x0C: return"WRITE ERROR - UNEXPECTED UNSOLICITED DATA";
                        case 0x0D: return"WRITE ERROR - NOT ENOUGH UNSOLICITED DATA";
                        case 0x0E: return"MULTIPLE WRITE ERRORS";
                        case 0x0F: return"DEFECTS IN ERROR WINDOW";
                        case 0x10: return"INCOMPLETE MULTIPLE ATOMIC WRITE OPERATIONS";
                        case 0x11: return"WRITE ERROR - RECOVERY SCAN NEEDED";
                        case 0x12: return"WRITE ERROR - INSUFFICIENT ZONE RESOURCES";
                    }

                    break;
                case 0x0D:
                    switch(ASCQ)
                    {
                        case 0x00: return"ERROR DETECTED BY THIRD PARTY TEMPORARY INITIATOR";
                        case 0x01: return"THIRD PARTY DEVICE FAILURE";
                        case 0x02: return"COPY TARGET DEVICE NOT REACHABLE";
                        case 0x03: return"INCORRECT COPY TARGET DEVICE TYPE";
                        case 0x04: return"COPY TARGET DEVICE DATA UNDERRUN";
                        case 0x05: return"COPY TARGET DEVICE DATA OVERRUN";
                    }

                    break;
                case 0x0E:
                    switch(ASCQ)
                    {
                        case 0x00: return"INVALID INFORMATION UNIT";
                        case 0x01: return"INFORMATION UNIT TOO SHORT";
                        case 0x02: return"INFORMATION UNIT TOO LONG";
                        case 0x03: return"INVALID FIELD IN COMMAND INFORMATION UNIT";
                    }

                    break;
                case 0x10:
                    switch(ASCQ)
                    {
                        case 0x00: return"ID CRC OR ECC ERROR";
                        case 0x01: return"LOGICAL BLOCK GUARD CHECK FAILED";
                        case 0x02: return"LOGICAL BLOCK APPLICATION TAG CHECK FAILED";
                        case 0x03: return"LOGICAL BLOCK REFERENCE TAG CHECK FAILED";
                        case 0x04: return"LOGICAL BLOCK PROTECTION ERROR ON RECOVER BUFFERED DATA";
                        case 0x05: return"LOGICAL BLOCK PROTECTION METHOD ERROR";
                    }

                    break;
                case 0x11:
                    switch(ASCQ)
                    {
                        case 0x00: return"UNRECOVERED READ ERROR";
                        case 0x01: return"READ RETRIES EXHAUSTED";
                        case 0x02: return"ERROR TOO LONG TO CORRECT";
                        case 0x03: return"MULTIPLE READ ERRORS";
                        case 0x04: return"UNRECOVERED READ ERROR - AUTO REALLOCATE FAILED";
                        case 0x05: return"L-EC UNCORRECTABLE ERROR";
                        case 0x06: return"CIRC UNRECOVERED ERROR";
                        case 0x07: return"DATA RESYNCHRONIZATION ERROR";
                        case 0x08: return"INCOMPLETE BLOCK READ";
                        case 0x09: return"NO GAP FOUND";
                        case 0x0A: return"MISCORRECTED ERROR";
                        case 0x0B: return"UNRECOVERED READ ERROR - RECOMMENDED REASSIGNMENT";
                        case 0x0C: return"UNRECOVERED READ ERROR - RECOMMENDED REWRITE THE DATA";
                        case 0x0D: return"DE-COMPRESSION CRC ERROR";
                        case 0x0E: return"CANNOT DECOMPRESS USING DECLARED ALGORITHM";
                        case 0x0F: return"ERROR READING UPC/EAN NUMBER";
                        case 0x10: return"ERROR READING ISRC NUMBER";
                        case 0x11: return"READ ERROR - LOSS OF STREAMING";
                        case 0x12: return"AUXILIARY MEMORY READ ERROR";
                        case 0x13: return"READ ERROR - FAILED RETRANSMISSITION REQUEST";
                        case 0x14: return"READ ERROR - LBA MARKED BAD BY APPLICATION CLIENT";
                        case 0x15: return"WRITE AFTER SANITIZE REQUIRED";
                    }

                    break;
                case 0x12:
                    switch(ASCQ)
                    {
                        case 0x00: return"ADDRESS MARK NOT FOUND FOR ID FIELD";
                    }

                    break;
                case 0x13:
                    switch(ASCQ)
                    {
                        case 0x00: return"ADDRESS MARK NOT FOUND FOR DATA FIELD";
                    }

                    break;
                case 0x14:
                    switch(ASCQ)
                    {
                        case 0x00: return"RECORDED ENTITY NOT FOUND";
                        case 0x01: return"RECORD NOT FOUND";
                        case 0x02: return"FILEMARK OR SETMARK NOT FOUND";
                        case 0x03: return"END-OF-DATA NOT FOUND";
                        case 0x04: return"BLOCK SEQUENCE ERROR";
                        case 0x05: return"RECORD NOT FOUND - RECOMMENDAD REASSIGNMENT";
                        case 0x06: return"RECORD NOT FOUND - DATA AUTO-REALLOCATED";
                        case 0x07: return"LOCATE OPERATION FAILURE";
                    }

                    break;
                case 0x15:
                    switch(ASCQ)
                    {
                        case 0x00: return"RANDOM POSITIONING ERROR";
                        case 0x01: return"MECHANICAL POSITIONING ERROR";
                        case 0x02: return"POSITIONING ERROR DETECTED BY READ OF MEDIUM";
                    }

                    break;
                case 0x16:
                    switch(ASCQ)
                    {
                        case 0x00: return"DATA SYNCHRONIZATION MARK ERROR";
                        case 0x01: return"DATA SYNC ERROR - DATA REWRITTEN";
                        case 0x02: return"DATA SYNC ERROR - RECOMMENDED REWRITE";
                        case 0x03: return"DATA SYNC ERROR - DATA AUTO-REALLOCATED";
                        case 0x04: return"DATA SYNC ERROR - RECOMMENDED REASSIGNMENT";
                    }

                    break;
                case 0x17:
                    switch(ASCQ)
                    {
                        case 0x00: return"RECOVERED DATA WITH NO ERROR CORRECTION APPLIED";
                        case 0x01: return"RECOVERED DATA WITH RETRIES";
                        case 0x02: return"RECOVERED DATA WITH POSITIVE HEAD OFFSET";
                        case 0x03: return"RECOVERED DATA WITH NEGATIVE HEAD OFFSET";
                        case 0x04: return"RECOVERED DATA WITH RETRIES AND/OR CIRC APPLIED";
                        case 0x05: return"RECOVERED DATA USING PREVIOUS SECTOR ID";
                        case 0x06: return"RECOVERED DATA WITHOUT ECC - DATA AUTO-REALLOCATED";
                        case 0x07: return"RECOVERED DATA WITHOUT ECC - RECOMMENDED REASSIGNMENT";
                        case 0x08: return"RECOVERED DATA WITHOUT ECC - RECOMMENDED REWRITE";
                        case 0x09: return"RECOVERED DATA WITHOUT ECC - DATA REWRITTEN";
                    }

                    break;
                case 0x18:
                    switch(ASCQ)
                    {
                        case 0x00: return"RECOVERED DATA WITH ERROR CORRECTION APPLIED";
                        case 0x01: return"RECOVERED DATA WITH ERROR CORRECTION & RETRIES APPLIED";
                        case 0x02: return"RECOVERED DATA - DATA AUTO-REALLOCATED";
                        case 0x03: return"RECOVERED DATA WITH CIRC";
                        case 0x04: return"RECOVERED DATA WITH L-EC";
                        case 0x05: return"RECOVERED DATA - RECOMMENDED REASSIGNMENT";
                        case 0x06: return"RECOVERED DATA - RECOMMENDED REWRITE";
                        case 0x07: return"RECOVERED DATA WITH ECC - DATA REWRITTEN";
                        case 0x08: return"RECOVERED DATA WITH LINKING";
                    }

                    break;
                case 0x19:
                    switch(ASCQ)
                    {
                        case 0x00: return"DEFECT LIST ERROR";
                        case 0x01: return"DEFECT LIST NOT AVAILABLE";
                        case 0x02: return"DEFECT LIST ERROR IN PRIMARY LIST";
                        case 0x03: return"DEFECT LIST ERROR IN GROWN LIST";
                    }

                    break;
                case 0x1A:
                    switch(ASCQ)
                    {
                        case 0x00: return"PARAMETER LIST LENGTH ERROR";
                    }

                    break;
                case 0x1B:
                    switch(ASCQ)
                    {
                        case 0x00: return"SYNCHRONOUS DATA TRANSFER ERROR";
                    }

                    break;
                case 0x1C:
                    switch(ASCQ)
                    {
                        case 0x00: return"DEFECT LIST NOT FOUND";
                        case 0x01: return"PRIMARY DEFECT LIST NOT FOUND";
                        case 0x02: return"GROWN DEFECT LIST NOT FOUND";
                    }

                    break;
                case 0x1D:
                    switch(ASCQ)
                    {
                        case 0x00: return"MISCOMPARE DURING VERIFY OPERATION";
                        case 0x01: return"MISCOMPARE VERIFY OF UNMAPPED LBA";
                    }

                    break;
                case 0x1E:
                    switch(ASCQ)
                    {
                        case 0x00: return"RECOVERED ID WITH ECC CORRECTION";
                    }

                    break;
                case 0x1F:
                    switch(ASCQ)
                    {
                        case 0x00: return"PARTIAL DEFECT LIST TRANSFER";
                    }

                    break;
                case 0x20:
                    switch(ASCQ)
                    {
                        case 0x00: return"INVALID COMMAND OPERATION CODE";
                        case 0x01: return"ACCESS DENIED - INITIATOR PENDING-ENROLLED";
                        case 0x02: return"ACCESS DENIED - NO ACCESS RIGHTS";
                        case 0x03: return"ACCESS DENIED - INVALID MGMT ID KEY";
                        case 0x04: return"ILLEGAL COMMAND WHILE IN WRITE CAPABLE STATE";
                        case 0x05: return"ILLEGAL COMMAND WHILE IN READ CAPABLE STATE";
                        case 0x06: return"ILLEGAL COMMAND WHILE IN EXPLICIT ADDRESS MODE";
                        case 0x07: return"ILLEGAL COMMAND WHILE IN IMPLICIT ADDRESS MODE";
                        case 0x08: return"ACCESS DENIED - ENROLLMENT CONFLICT";
                        case 0x09: return"ACCESS DENIED - INVALID LUN IDENTIFIER";
                        case 0x0A: return"ACCESS DENIED - INVALID PROXY TOKEN";
                        case 0x0B: return"ACCESS DENIED - ACL LUN CONFLICT";
                        case 0x0C: return"ILLEGAL COMMAND WHEN NOT IN APPEND-ONLY MODE";
                    }

                    break;
                case 0x21:
                    switch(ASCQ)
                    {
                        case 0x00: return"LOGICAL BLOCK ADDRESS OUT OF RANGE";
                        case 0x01: return"INVALID ELEMENT ADDRESS";
                        case 0x02: return"INVALID ADDRESS FOR WRITE";
                        case 0x03: return"INVALID WRITE CROSSING LAYER JUMP";
                        case 0x04: return"UNALIGNED WRITE COMMAND";
                        case 0x05: return"WRITE BOUNDARY VIOLATION";
                        case 0x06: return"ATTEMPT TO READ INVALID DATA";
                        case 0x07: return"READ BOUNDARY VIOLATION";
                    }

                    break;
                case 0x22:
                    switch(ASCQ)
                    {
                        case 0x00: return"ILLEGAL FUNCTION";
                    }

                    break;
                case 0x23:
                    switch(ASCQ)
                    {
                        case 0x00: return"INVALID TOKEN OPERATION, CAUSE NOT REPORTABLE";
                        case 0x01: return"INVALID TOKEN OPERATION, UNSUPPORTED TOKEN TYPE";
                        case 0x02: return"INVALID TOKEN OPERATION, REMOTE TOKEN USAGE NOT SUPPORTED";
                        case 0x03: return"INVALID TOKEN OPERATION, REMOTE ROD TOKEN CREATION NOT SUPPORTED";
                        case 0x04: return"INVALID TOKEN OPERATION, TOKEN UNKNOWN";
                        case 0x05: return"INVALID TOKEN OPERATION, TOKEN CORRUPT";
                        case 0x06: return"INVALID TOKEN OPERATION, TOKEN REVOKED";
                        case 0x07: return"INVALID TOKEN OPERATION, TOKEN EXPIRED";
                        case 0x08: return"INVALID TOKEN OPERATION, TOKEN CANCELLED";
                        case 0x09: return"INVALID TOKEN OPERATION, TOKEN DELETED";
                        case 0x0A: return"INVALID TOKEN OPERATION, INVALID TOKEN LENGTH";
                    }

                    break;
                case 0x24:
                    switch(ASCQ)
                    {
                        case 0x00: return"ILLEGAL FIELD IN CDB";
                        case 0x01: return"CDB DECRYPTION ERROR";
                        case 0x02: return"INVALID CDB FIELD WHILE IN EXPLICIT BLOCK ADDRESS MODEL";
                        case 0x03: return"INVALID CDB FIELD WHILE IN IMPLICIT BLOCK ADDRESS MODEL";
                        case 0x04: return"SECURITY AUDIT VALUE FROZEN";
                        case 0x05: return"SECURITY WORKING KEY FROZEN";
                        case 0x06: return"NONCE NOT UNIQUE";
                        case 0x07: return"NONCE TIMESTAMP OUT OF RANGE";
                        case 0x08: return"INVALID XCDB";
                    }

                    break;
                case 0x25:
                    switch(ASCQ)
                    {
                        case 0x00: return"LOGICAL UNIT NOT SUPPORTED";
                    }

                    break;
                case 0x26:
                    switch(ASCQ)
                    {
                        case 0x00: return"INVALID FIELD IN PARAMETER LIST";
                        case 0x01: return"PARAMETER NOT SUPPORTED";
                        case 0x02: return"PARAMETER VALUE INVALID";
                        case 0x03: return"THRESHOLD PARAMETERS NOT SUPPORTED";
                        case 0x04: return"INVALID RELEASE OF PERSISTENT RESERVATION";
                        case 0x05: return"DATA DECRYPTION ERROR";
                        case 0x06: return"TOO MANY TARGET DESCRIPTORS";
                        case 0x07: return"UNSUPPORTED TARGET DESCRIPTOR TYPE CODE";
                        case 0x08: return"TOO MANY SEGMENT DESCRIPTORS";
                        case 0x09: return"UNSUPPORTED SEGMENT DESCRIPTOR TYPE CODE";
                        case 0x0A: return"UNEXPECTED INEXACT SEGMENT";
                        case 0x0B: return"INLINE DATA LENGTH EXCEEDED";
                        case 0x0C: return"INVALID OPERATION FOR COPY SOURCE OR DESTINATION";
                        case 0x0D: return"COPY SEGMENT GRANULARITY VIOLATION";
                        case 0x0E: return"INVALID PARAMETER WHILE PORT IS ENABLED";
                        case 0x0F: return"INVALID DATA-OUT BUFFER INTEGRITY CHECK VALUE";
                        case 0x10: return"DATA DECRYPTION KEY FAIL LIMIT REACHED";
                        case 0x11: return"INCOMPLETE KEY-ASSOCIATED DATA SET";
                        case 0x12: return"VENDOR SPECIFIC KEY REFERENCE NOT FOUND";
                        case 0x13: return"APPLICATION TAG MODE PAGE IS INVALID";
                    }

                    break;
                case 0x27:
                    switch(ASCQ)
                    {
                        case 0x00: return"WRITE PROTECTED";
                        case 0x01: return"HARDWARE WRITE PROTECTED";
                        case 0x02: return"LOGICAL UNIT SOFTWARE WRITE PROTECTED";
                        case 0x03: return"ASSOCIATED WRITE PROTECT";
                        case 0x04: return"PERSISTENT WRITE PROTECT";
                        case 0x05: return"PERMANENT WRITE PROTECT";
                        case 0x06: return"CONDITIONAL WRITE PROTECT";
                        case 0x07: return"SPACE ALLOCATION FAILED WRITE PROTECT";
                        case 0x08: return"ZONE IS READ ONLY";
                    }

                    break;
                case 0x28:
                    switch(ASCQ)
                    {
                        case 0x00: return"NOT READY TO READY CHANGE (MEDIUM MAY HAVE CHANGED)";
                        case 0x01: return"IMPORT OR EXPORT ELEMENT ACCESSED";
                        case 0x02: return"FORMAT-LAYER MAY HAVE CHANGED";
                        case 0x03: return"IMPORT/EXPORT ELEMENT ACCESSED, MEDIUM CHANGED";
                    }

                    break;
                case 0x29:
                    switch(ASCQ)
                    {
                        case 0x00: return"POWER ON, RESET, OR BUS DEVICE RESET OCCURRED";
                        case 0x01: return"POWER ON OCCURRED";
                        case 0x02: return"SCSI BUS RESET OCCURRED";
                        case 0x03: return"BUS DEVICE RESET FUNCTION OCCURRED";
                        case 0x04: return"DEVICE INTERNAL RESET";
                        case 0x05: return"TRANSCEIVER MODE CHANGED TO SINGLE-ENDED";
                        case 0x06: return"TRANSCEIVER MODE CHANGED TO LVD";
                        case 0x07: return"I_T NEXUS LOSS OCCURRED";
                    }

                    break;
                case 0x2A:
                    switch(ASCQ)
                    {
                        case 0x00: return"PARAMETERS CHANGED";
                        case 0x01: return"MODE PARAMETERS CHANGED";
                        case 0x02: return"LOG PARAMETERS CHANGED";
                        case 0x03: return"RESERVATIONS PREEMPTED";
                        case 0x04: return"RESERVATIONS RELEASED";
                        case 0x05: return"REGISTRATIONS PREEMPTED";
                        case 0x06: return"ASYMMETRIC ACCESS STATE CHANGED";
                        case 0x07: return"IMPLICIT ASYMMETRIC ACCESS STATE TRANSITION FAILED";
                        case 0x08: return"PRIORITY CHANGED";
                        case 0x09: return"CAPACITY DATA HAS CHANGED";
                        case 0x0A: return"ERROR HISTORY I_T NEXUS CLEARED";
                        case 0x0B: return"ERROR HISTORY SNAPSHOT RELEASED";
                        case 0x0C: return"ERROR RECOVERY ATTRIBUTES HAVE CHANGED";
                        case 0x0D: return"DATA ENCRYPTION CAPABILITIES CHANGED";
                        case 0x10: return"TIMESTAMP CHANGED";
                        case 0x11: return"DATA ENCRYPTION PARAMETERS CHANGED BY ANOTHER I_T NEXUS";
                        case 0x12: return"DATA ENCRYPTION PARAMETERS CHANGED BY VENDOR SPECIFIC EVENT";
                        case 0x13: return"DATA ENCRYPTION KEY INSTANCE COUNTER HAS CHANGED";
                        case 0x14: return"SA CREATION CAPABILITIES DATA HAS CHANGED";
                        case 0x15: return"MEDIUM REMOVAL PREVENTION PREEMPTED";
                    }

                    break;
                case 0x2B:
                    switch(ASCQ)
                    {
                        case 0x00: return"COPY CANNOT EXECUTE SINCE HOST CANNOT DISCONNECT";
                    }

                    break;
                case 0x2C:
                    switch(ASCQ)
                    {
                        case 0x00: return"COMMAND SEQUENCE ERROR";
                        case 0x01: return"TOO MANY WINDOWS SPECIFIED";
                        case 0x02: return"INVALID COMBINATION OF WINDOWS SPECIFIED";
                        case 0x03: return"CURRENT PROGRAM AREA IS NOT EMPTY";
                        case 0x04: return"CURRENT PROGRAM AREA IS EMPTY";
                        case 0x05: return"ILLEGAL POWER CONDITION REQUEST";
                        case 0x06: return"PERSISTENT PREVENT CONFLICT";
                        case 0x07: return"PREVIOUS BUSY STATUS";
                        case 0x08: return"PREVIOUS TASK SET FULL STATUS";
                        case 0x09: return"PREVIOUS RESERVATION CONFLICT STATUS";
                        case 0x0A: return"PARTITION OR COLLECTION CONTAINS USER OBJECTS";
                        case 0x0B: return"NOT RESERVED";
                        case 0x0C: return"ORWRITE GENERATION DOES NOT MATCH";
                        case 0x0D: return"RESET WRITE POINTER NOT ALLOWED";
                        case 0x0E: return"ZONE IS OFFLINE";
                        case 0x0F: return"STREAM NOT OPEN";
                        case 0x10: return"UNWRITTEN DATA IN ZONE";
                    }

                    break;
                case 0x2D:
                    switch(ASCQ)
                    {
                        case 0x00: return"OVERWRITE ERROR ON UPDATE IN PLACE";
                    }

                    break;
                case 0x2E:
                    switch(ASCQ)
                    {
                        case 0x00: return"INSUFFICIENT TIME FOR OPERATION";
                        case 0x01: return"COMMAND TIMEOUT BEFORE PROCESSING";
                        case 0x02: return"COMMAND TIMEOUT DURING PROCESSING";
                        case 0x03: return"COMMAND TIMEOUT DURING PROCESSING DUE TO ERROR RECOVERY";
                    }

                    break;
                case 0x2F:
                    switch(ASCQ)
                    {
                        case 0x00: return"COMMANDS CLEARED BY ANOTHER INITIATOR";
                        case 0x01: return"COMMANDS CLEARED BY POWER LOSS NOTIFICATION";
                        case 0x02: return"COMMANDS CLEARED BY DEVICE SERVER";
                        case 0x03: return"SOME COMMANDS CLEARED BY QUEUING LAYER EVENT";
                    }

                    break;
                case 0x30:
                    switch(ASCQ)
                    {
                        case 0x00: return"INCOMPATIBLE MEDIUM INSTALLED";
                        case 0x01: return"CANNOT READ MEDIUM - UNKNOWN FORMAT";
                        case 0x02: return"CANNOT READ MEDIUM - INCOMPATIBLE FORMAT";
                        case 0x03: return"CLEANING CARTRIDGE INSTALLED";
                        case 0x04: return"CANNOT WRITE MEDIUM - UNKNOWN FORMAT";
                        case 0x05: return"CANNOT WRITE MEDIUM - INCOMPATIBLE FORMAT";
                        case 0x06: return"CANNOT FORMAT MEDIUM - INCOMPATIBLE MEDIUM";
                        case 0x07: return"CLEANING FAILURE";
                        case 0x08: return"CANNOT WRITE - APPLICATION CODE MISMATCH";
                        case 0x09: return"CURRENT SESSION NOT FIXATED FOR APPEND";
                        case 0x0A: return"CLEANING REQUEST REJECTED";
                        case 0x0C: return"WORM MEDIUM - OVERWRITE ATTEMPTED";
                        case 0x0D: return"WORM MEDIUM - INTEGRITY CHECK";
                        case 0x10: return"MEDIUM NOT FORMATTED";
                        case 0x11: return"INCOMPATIBLE VOLUME TYPE";
                        case 0x12: return"INCOMPATIBLE VOLUME QUALIFIER";
                        case 0x13: return"CLEANING VOLUME EXPIRED";
                    }

                    break;
                case 0x31:
                    switch(ASCQ)
                    {
                        case 0x00: return"MEDIUM FORMAT CORRUPTED";
                        case 0x01: return"FORMAT COMMAND FAILED";
                        case 0x02: return"ZONED FORMATTING FAILED DUE TO SPARE LINKING";
                        case 0x03: return"SANITIZE COMMAND FAILED";
                    }

                    break;
                case 0x32:
                    switch(ASCQ)
                    {
                        case 0x00: return"NO DEFECT SPARE LOCATION AVAILABLE";
                        case 0x01: return"DEFECT LIST UPDATE FAILURE";
                    }

                    break;
                case 0x33:
                    switch(ASCQ)
                    {
                        case 0x00: return"TAPE LENGTH ERROR";
                    }

                    break;
                case 0x34:
                    switch(ASCQ)
                    {
                        case 0x00: return"ENCLOSURE FAILURE";
                    }

                    break;
                case 0x35:
                    switch(ASCQ)
                    {
                        case 0x00: return"ENCLOSURE SERVICES FAILURE";
                        case 0x01: return"UNSUPPORTED ENCLOSURE FUNCTION";
                        case 0x02: return"ENCLOSURE SERVICES UNAVAILABLE";
                        case 0x03: return"ENCLOSURE SERVICES TRANSFER FAILURE";
                        case 0x04: return"ENCLOSURE SERVICES TRANSFER REFUSED";
                        case 0x05: return"ENCLOSURE SERVICES CHECKSUM ERROR";
                    }

                    break;
                case 0x36:
                    switch(ASCQ)
                    {
                        case 0x00: return"RIBBON, INK, OR TONER FAILURE";
                    }

                    break;
                case 0x37:
                    switch(ASCQ)
                    {
                        case 0x00: return"ROUNDED PARAMETER";
                    }

                    break;
                case 0x38:
                    switch(ASCQ)
                    {
                        case 0x00: return"EVENT STATUS NOTIFICATION";
                        case 0x02: return"ESN - POWER MANAGEMENT CLASS EVENT";
                        case 0x04: return"ESN - MEDIA CLASS EVENT";
                        case 0x06: return"ESN - DEVICE BUSY CLASS EVENT";
                        case 0x07: return"THIN PROVISIONING SOFT THRESHOLD REACHED";
                    }

                    break;
                case 0x39:
                    switch(ASCQ)
                    {
                        case 0x00: return"SAVING PARAMETERS NOT SUPPORTED";
                    }

                    break;
                case 0x3A:
                    switch(ASCQ)
                    {
                        case 0x00: return"MEDIUM NOT PRESENT";
                        case 0x01: return"MEDIUM NOT PRESENT - TRAY CLOSED";
                        case 0x02: return"MEDIUM NOT PRESENT - TRAY OPEN";
                        case 0x03: return"MEDIUM NOT PRESENT - LOADABLE";
                        case 0x04: return"MEDIUM NOT PRESENT - MEDIUM AUXILIARY MEMORY ACCESSIBLE";
                    }

                    break;
                case 0x3B:
                    switch(ASCQ)
                    {
                        case 0x00: return"SEQUENTIAL POSITIONING ERROR";
                        case 0x01: return"TAPE POSITION ERROR AT BEGINNING-OF-MEDIUM";
                        case 0x02: return"TAPE POSITION ERROR AT END-OF-MEDIUM";
                        case 0x03: return"TAPE OR ELECTRONIC VERTICAL FORMS UNIT NOT READY";
                        case 0x04: return"SLEW FAILURE";
                        case 0x05: return"PAPER JAM";
                        case 0x06: return"FAILED TO SENSE TOP-OF-FORM";
                        case 0x07: return"FAILED TO SENSE BOTTOM-OF-FORM";
                        case 0x08: return"REPOSITION ERROR";
                        case 0x09: return"READ PAST END OF MEDIUM";
                        case 0x0A: return"READ PAST BEGINNING OF MEDIUM";
                        case 0x0B: return"POSITION PAST END OF MEDIUM";
                        case 0x0C: return"POSITION PAST BEGINNING OF MEDIUM";
                        case 0x0D: return"MEDIUM DESTINATION ELEMENT FULL";
                        case 0x0E: return"MEDIUM SOURCE ELEMENT EMPTY";
                        case 0x0F: return"END OF MEDIUM REACHED";
                        case 0x11: return"MEDIUM MAGAZINE NOT ACCESSIBLE";
                        case 0x12: return"MEDIUM MAGAZINE REMOVED";
                        case 0x13: return"MEDIUM MAGAZINE INSERTED";
                        case 0x14: return"MEDIUM MAGAZINE LOCKED";
                        case 0x15: return"MEDIUM MAGAZINE UNLOCKED";
                        case 0x16: return"MECHANICAL POSITIONING OR CHANGER ERROR";
                        case 0x17: return"READ PAST END OF USER OBJECT";
                        case 0x18: return"ELEMENT DISABLED";
                        case 0x19: return"ELEMENT ENABLED";
                        case 0x1A: return"DATA TRANSFER DEVICE REMOVED";
                        case 0x1B: return"DATA TRANSFER DEVICE INSERTED";
                        case 0x1C: return"TOO MANY LOGICAL OBJECTS ON PARTITION TO SUPPORT OPERATION";
                    }

                    break;
                case 0x3D:
                    switch(ASCQ)
                    {
                        case 0x00: return"INVALID BITS IN IDENTIFY MESSAGE";
                    }

                    break;
                case 0x3E:
                    switch(ASCQ)
                    {
                        case 0x00: return"LOGICAL UNIT HAS NOT SELF-CONFIGURED YET";
                        case 0x01: return"LOGICAL UNIT FAILURE";
                        case 0x02: return"TIMEOUT ON LOGICAL UNIT";
                        case 0x03: return"LOGICAL UNIT FAILED SELF-TEST";
                        case 0x04: return"LOGICAL UNIT UNABLE TO UPDATE SELF-TEST LOG";
                    }

                    break;
                case 0x3F:
                    switch(ASCQ)
                    {
                        case 0x00: return"TARGET OPERATING CONDITIONS HAVE CHANGED";
                        case 0x01: return"MICROCODE HAS BEEN CHANGED";
                        case 0x02: return"CHANGED OPERATING DEFINITION";
                        case 0x03: return"INQUIRY DATA HAS CHANGED";
                        case 0x04: return"COMPONENT DEVICE ATTACHED";
                        case 0x05: return"DEVICE IDENTIFIED CHANGED";
                        case 0x06: return"REDUNDANCY GROUP CREATED OR MODIFIED";
                        case 0x07: return"REDUNDANCY GROUP DELETED";
                        case 0x08: return"SPARE CREATED OR MODIFIED";
                        case 0x09: return"SPARE DELETED";
                        case 0x0A: return"VOLUME SET CREATED OR MODIFIED";
                        case 0x0B: return"VOLUME SET DELETED";
                        case 0x0C: return"VOLUME SET DEASSIGNED";
                        case 0x0D: return"VOLUME SET REASSIGNED";
                        case 0x0E: return"REPORTED LUNS DATA HAS CHANGED";
                        case 0x0F: return"ECHO BUFFER OVERWRITTEN";
                        case 0x10: return"MEDIUM LOADABLE";
                        case 0x11: return"MEDIUM AUXILIARY MEMORY ACCESSIBLE";
                        case 0x12: return"iSCSI IP ADDRESS ADDED";
                        case 0x13: return"iSCSI IP ADDRESS REMOVED";
                        case 0x14: return"iSCSI IP ADDRESS CHANGED";
                        case 0x15: return"INSPECT REFERRALS SENSE DESCRIPTORS";
                        case 0x16: return"MICROCODE HAS BEEN CHANGED WITHOUT RESET";
                        case 0x17: return"ZONE TRANSITION TO FULL";
                    }

                    break;
                case 0x40:
                    switch(ASCQ)
                    {
                        case 0x00: return"RAM FAILURE";
                        default:   return$"DIAGNOSTIC FAILURE ON COMPONENT {ASCQ:X2}h";
                    }
                case 0x41:
                    switch(ASCQ)
                    {
                        case 0x00: return"DATA PATH FAILURE";
                    }

                    break;
                case 0x42:
                    switch(ASCQ)
                    {
                        case 0x00: return"POWER-ON OR SELF-TEST FAILURE";
                    }

                    break;
                case 0x43:
                    switch(ASCQ)
                    {
                        case 0x00: return"MESSAGE ERROR";
                    }

                    break;
                case 0x44:
                    switch(ASCQ)
                    {
                        case 0x00: return"INTERNAL TARGET FAILURE";
                        case 0x01: return"PERSISTENT RESERVATION INFORMATION LOST";
                        case 0x71: return"ATA DEVICE FAILED SET FEATURES";
                    }

                    break;
                case 0x45:
                    switch(ASCQ)
                    {
                        case 0x00: return"SELECT OR RESELECT FAILURE";
                    }

                    break;
                case 0x46:
                    switch(ASCQ)
                    {
                        case 0x00: return"UNSUCCESSFUL SOFT RESET";
                    }

                    break;
                case 0x47:
                    switch(ASCQ)
                    {
                        case 0x00: return"SCSI PARITY ERROR";
                        case 0x01: return"DATA PHASE CRC ERROR DETECTED";
                        case 0x02: return"SCSI PARITY ERROR DETECTED DURING ST DATA PHASE";
                        case 0x03: return"INFORMATION UNIT iuCRC ERROR DETECTED";
                        case 0x04: return"ASYNCHRONOUS INFORMATION PROTECTION ERROR DETECTED";
                        case 0x05: return"PROTOCOL SERVICE CRC ERROR";
                        case 0x06: return"PHY TEST FUNCTION IN PROGRESS";
                        case 0x7F: return"SOME COMMANDS CLEARED BY iSCSI PROTOCOL EVENT";
                    }

                    break;
                case 0x48:
                    switch(ASCQ)
                    {
                        case 0x00: return"INITIATOR DETECTED ERROR MESSAGE RECEIVED";
                    }

                    break;
                case 0x49:
                    switch(ASCQ)
                    {
                        case 0x00: return"INVALID MESSAGE ERROR";
                    }

                    break;
                case 0x4A:
                    switch(ASCQ)
                    {
                        case 0x00: return"COMMAND PHASE ERROR";
                    }

                    break;
                case 0x4B:
                    switch(ASCQ)
                    {
                        case 0x00: return"DATA PHASE ERROR";
                        case 0x01: return"INVALID TARGET PORT TRANSFER TAG RECEIVED";
                        case 0x02: return"TOO MUCH WRITE DATA";
                        case 0x03: return"ACK/NAK TIMEOUT";
                        case 0x04: return"NAK RECEIVED";
                        case 0x05: return"DATA OFFSET ERROR";
                        case 0x06: return"INITIATOR RESPONSE TIMEOUT";
                        case 0x07: return"CONNECTION LOST";
                        case 0x08: return"DATA-IN BUFFER OVERFLOW - DATA BUFFER SIZE";
                        case 0x09: return"DATA-IN BUFFER OVERFLOW - DATA BUFFER DESCRIPTOR AREA";
                        case 0x0A: return"DATA-IN BUFFER ERROR";
                        case 0x0B: return"DATA-OUT BUFFER OVERFLOW - DATA BUFFER SIZE";
                        case 0x0C: return"DATA-OUT BUFFER OVERFLOW - DATA BUFFER DESCRIPTOR AREA";
                        case 0x0D: return"DATA-OUT BUFFER ERROR";
                        case 0x0E: return"PCIe FABRIC ERROR";
                        case 0x0F: return"PCIe COMPLETION TIMEOUT";
                        case 0x10: return"PCIe COMPLETION ABORT";
                        case 0x11: return"PCIe POISONED TLP RECEIVED";
                        case 0x12: return"PCIe ECRC CHECK FAILED";
                        case 0x13: return"PCIe UNSUPPORTED REQUEST";
                        case 0x14: return"PCIe ACS VIOLATION";
                        case 0x15: return"PCIe TLP PREFIX BLOCKED";
                    }

                    break;
                case 0x4C:
                    switch(ASCQ)
                    {
                        case 0x00: return"LOGICAL UNIT FAILED SELF-CONFIGURATION";
                    }

                    break;
                case 0x4E: return$"OVERLAPPED COMMANDS ATTEMPTED FOR TASK TAG {ASCQ:X2}h";
                case 0x50:
                    switch(ASCQ)
                    {
                        case 0x00: return"WRITE APPEND ERROR";
                        case 0x01: return"WRITE APPEND POSITION ERROR";
                        case 0x02: return"POSITION ERROR RELATED TO TIMING";
                    }

                    break;
                case 0x51:
                    switch(ASCQ)
                    {
                        case 0x00: return"ERASE FAILURE";
                        case 0x01: return"ERASE FAILURE - INCOMPLETE ERASE OPERATION DETECTED";
                    }

                    break;
                case 0x52:
                    switch(ASCQ)
                    {
                        case 0x00: return"CARTRIDGE FAULT";
                    }

                    break;
                case 0x53:
                    switch(ASCQ)
                    {
                        case 0x00: return"MEDIA LOAD OR EJECT FAILED";
                        case 0x01: return"UNLOAD TAPE FAILURE";
                        case 0x02: return"MEDIUM REMOVAL PREVENTED";
                        case 0x03: return"MEDIUM REMOVAL PREVENTED BY DATA TRANSFER ELEMENT";
                        case 0x04: return"MEDIUM THREAD OR UNTHREAD FAILURE";
                        case 0x05: return"VOLUME IDENTIFIER INVALID";
                        case 0x06: return"VOLUME IDENTIFIED MISSING";
                        case 0x07: return"DUPLICATE VOLUME IDENTIFIER";
                        case 0x08: return"ELEMENT STATUS UNKNOWN";
                        case 0x09: return"DATA TRANSFER DEVICE ERROR - LOAD FAILED";
                        case 0x0A: return"DATA TRANSFER DEVICE ERROR - UNLOAD FAILED";
                        case 0x0B: return"DATA TRANSFER DEVICE ERROR - UNLOAD MISSING";
                        case 0x0C: return"DATA TRANSFER DEVICE ERROR - EJECT FAILED";
                        case 0x0D: return"DATA TRANSFER DEVICE ERROR - LIBRARY COMMUNICATION FAILED";
                    }

                    break;
                case 0x54:
                    switch(ASCQ)
                    {
                        case 0x00: return"SCSI TO HOST SYSTEM INTERFACE FAILURE";
                    }

                    break;
                case 0x55:
                    switch(ASCQ)
                    {
                        case 0x00: return"SYSTEM RESOURCE FAILURE";
                        case 0x01: return"SYSTEM BUFFER FULL";
                        case 0x02: return"INSUFFICIENT RESERVATION RESOURCES";
                        case 0x03: return"INSUFFICIENT RESOURCES";
                        case 0x04: return"INSUFFICIENT REGISTRATION RESOURCES";
                        case 0x05: return"INSUFFICIENT ACCESS CONTROL RESOURCES";
                        case 0x06: return"AUXILIARY MEMORY OUT OF SPACE";
                        case 0x07: return"QUOTA ERROR";
                        case 0x08: return"MAXIMUM NUMBER OF SUPPLEMENTAL DECRYPTION KEYS EXCEEDED";
                        case 0x09: return"MEDIUM AUXILIARY MEMORY NOT ACCESSIBLE";
                        case 0x0A: return"DATA CURRENTLY UNAVAILABLE";
                        case 0x0B: return"INSUFFICIENT POWER FOR OPERATION";
                        case 0x0C: return"INSUFFICIENT RESOURCES TO CREATE ROD";
                        case 0x0D: return"INSUFFICIENT RESOURCES TO CREATE ROD TOKEN";
                        case 0x0E: return"INSUFFICIENT ZONE RESOURCES";
                        case 0x0F: return"INSUFFICIENT ZONE RESOURCES TO COMPLETE WRITE";
                        case 0x10: return"MAXIMUM NUMBER OF STREAMS OPEN";
                    }

                    break;
                case 0x57:
                    switch(ASCQ)
                    {
                        case 0x00: return"UNABLE TO RECOVER TABLE-OF-CONTENTS";
                    }

                    break;
                case 0x58:
                    switch(ASCQ)
                    {
                        case 0x00: return"GENERATION DOES NOT EXIST";
                    }

                    break;
                case 0x59:
                    switch(ASCQ)
                    {
                        case 0x00: return"UPDATED BLOCK READ";
                    }

                    break;
                case 0x5A:
                    switch(ASCQ)
                    {
                        case 0x00: return"OPERATOR REQUEST OR STATE CHANGE INPUT";
                        case 0x01: return"OPERATOR MEDIUM REMOVAL REQUEST";
                        case 0x02: return"OPERATOR SELECTED WRITE PROTECT";
                        case 0x03: return"OPERATOR SELECTED WRITE PERMIT";
                    }

                    break;
                case 0x5B:
                    switch(ASCQ)
                    {
                        case 0x00: return"LOG EXCEPTION";
                        case 0x01: return"THRESHOLD CONDITION MET";
                        case 0x02: return"LOG COUNTER AT MAXIMUM";
                        case 0x03: return"LOG LIST CODES EXHAUSTED";
                    }

                    break;
                case 0x5C:
                    switch(ASCQ)
                    {
                        case 0x00: return"RPL STATUS CHANGE";
                        case 0x01: return"SPINDLES SYNCHRONIZED";
                        case 0x02: return"SPINDLES NOT SYNCHRONIZED";
                        case 0x03: return"SPARE AREA EXHAUSTION PREDICTION THRESHOLD EXCEEDED";
                        case 0x10: return"HARDWARE IMPENDING FAILURE GENERAL HARD DRIVE FAILURE";
                        case 0x11: return"HARDWARE IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH";
                        case 0x12: return"HARDWARE IMPENDING FAILURE DATA ERROR RATE TOO HIGH";
                        case 0x13: return"HARDWARE IMPENDING FAILURE SEEK ERROR RATE TOO HIGH";
                        case 0x14: return"HARDWARE IMPENDING FAILURE TOO MANY BLOCK REASSIGNS";
                        case 0x15: return"HARDWARE IMPENDING FAILURE ACCESS TIME TOO HIGH";
                        case 0x16: return"HARDWARE IMPENDING FAILURE START UNIT TIMES TOO HIGH";
                        case 0x17: return"HARDWARE IMPENDING FAILURE CHANNEL PARAMETRICS";
                        case 0x18: return"HARDWARE IMPENDING FAILURE CONTROLLER DETECTED";
                        case 0x19: return"HARDWARE IMPENDING FAILURE THROUGHPUT PERFORMANCE";
                        case 0x1A: return"HARDWARE IMPENDING FAILURE SEEK TIME PERFORMANCE";
                        case 0x1B: return"HARDWARE IMPENDING FAILURE SPIN-UP RETRY COUNT";
                        case 0x1C: return"HARDWARE IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT";
                        case 0x20: return"CONTROLLER IMPENDING FAILURE GENERAL HARD DRIVE FAILURE";
                        case 0x21: return"CONTROLLER IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH";
                        case 0x22: return"CONTROLLER IMPENDING FAILURE DATA ERROR RATE TOO HIGH";
                        case 0x23: return"CONTROLLER IMPENDING FAILURE SEEK ERROR RATE TOO HIGH";
                        case 0x24: return"CONTROLLER IMPENDING FAILURE TOO MANY BLOCK REASSIGNS";
                        case 0x25: return"CONTROLLER IMPENDING FAILURE ACCESS TIME TOO HIGH";
                        case 0x26: return"CONTROLLER IMPENDING FAILURE START UNIT TIMES TOO HIGH";
                        case 0x27: return"CONTROLLER IMPENDING FAILURE CHANNEL PARAMETRICS";
                        case 0x28: return"CONTROLLER IMPENDING FAILURE CONTROLLER DETECTED";
                        case 0x29: return"CONTROLLER IMPENDING FAILURE THROUGHPUT PERFORMANCE";
                        case 0x2A: return"CONTROLLER IMPENDING FAILURE SEEK TIME PERFORMANCE";
                        case 0x2B: return"CONTROLLER IMPENDING FAILURE SPIN-UP RETRY COUNT";
                        case 0x2C: return"CONTROLLER IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT";
                        case 0x30: return"DATA CHANNEL IMPENDING FAILURE GENERAL HARD DRIVE FAILURE";
                        case 0x31: return"DATA CHANNEL IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH";
                        case 0x32: return"DATA CHANNEL IMPENDING FAILURE DATA ERROR RATE TOO HIGH";
                        case 0x33: return"DATA CHANNEL IMPENDING FAILURE SEEK ERROR RATE TOO HIGH";
                        case 0x34: return"DATA CHANNEL IMPENDING FAILURE TOO MANY BLOCK REASSIGNS";
                        case 0x35: return"DATA CHANNEL IMPENDING FAILURE ACCESS TIME TOO HIGH";
                        case 0x36: return"DATA CHANNEL IMPENDING FAILURE START UNIT TIMES TOO HIGH";
                        case 0x37: return"DATA CHANNEL IMPENDING FAILURE CHANNEL PARAMETRICS";
                        case 0x38: return"DATA CHANNEL IMPENDING FAILURE DATA CHANNEL DETECTED";
                        case 0x39: return"DATA CHANNEL IMPENDING FAILURE THROUGHPUT PERFORMANCE";
                        case 0x3A: return"DATA CHANNEL IMPENDING FAILURE SEEK TIME PERFORMANCE";
                        case 0x3B: return"DATA CHANNEL IMPENDING FAILURE SPIN-UP RETRY COUNT";
                        case 0x3C: return"DATA CHANNEL IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT";
                        case 0x40: return"SERVO IMPENDING FAILURE GENERAL HARD DRIVE FAILURE";
                        case 0x41: return"SERVO IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH";
                        case 0x42: return"SERVO IMPENDING FAILURE DATA ERROR RATE TOO HIGH";
                        case 0x43: return"SERVO IMPENDING FAILURE SEEK ERROR RATE TOO HIGH";
                        case 0x44: return"SERVO IMPENDING FAILURE TOO MANY BLOCK REASSIGNS";
                        case 0x45: return"SERVO IMPENDING FAILURE ACCESS TIME TOO HIGH";
                        case 0x46: return"SERVO IMPENDING FAILURE START UNIT TIMES TOO HIGH";
                        case 0x47: return"SERVO IMPENDING FAILURE CHANNEL PARAMETRICS";
                        case 0x48: return"SERVO IMPENDING FAILURE SERVO DETECTED";
                        case 0x49: return"SERVO IMPENDING FAILURE THROUGHPUT PERFORMANCE";
                        case 0x4A: return"SERVO IMPENDING FAILURE SEEK TIME PERFORMANCE";
                        case 0x4B: return"SERVO IMPENDING FAILURE SPIN-UP RETRY COUNT";
                        case 0x4C: return"SERVO IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT";
                        case 0x50: return"SPINDLE IMPENDING FAILURE GENERAL HARD DRIVE FAILURE";
                        case 0x51: return"SPINDLE IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH";
                        case 0x52: return"SPINDLE IMPENDING FAILURE DATA ERROR RATE TOO HIGH";
                        case 0x53: return"SPINDLE IMPENDING FAILURE SEEK ERROR RATE TOO HIGH";
                        case 0x54: return"SPINDLE IMPENDING FAILURE TOO MANY BLOCK REASSIGNS";
                        case 0x55: return"SPINDLE IMPENDING FAILURE ACCESS TIME TOO HIGH";
                        case 0x56: return"SPINDLE IMPENDING FAILURE START UNIT TIMES TOO HIGH";
                        case 0x57: return"SPINDLE IMPENDING FAILURE CHANNEL PARAMETRICS";
                        case 0x58: return"SPINDLE IMPENDING FAILURE SPINDLE DETECTED";
                        case 0x59: return"SPINDLE IMPENDING FAILURE THROUGHPUT PERFORMANCE";
                        case 0x5A: return"SPINDLE IMPENDING FAILURE SEEK TIME PERFORMANCE";
                        case 0x5B: return"SPINDLE IMPENDING FAILURE SPIN-UP RETRY COUNT";
                        case 0x5C: return"SPINDLE IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT";
                        case 0x60: return"FIRMWARE IMPENDING FAILURE GENERAL HARD DRIVE FAILURE";
                        case 0x61: return"FIRMWARE IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH";
                        case 0x62: return"FIRMWARE IMPENDING FAILURE DATA ERROR RATE TOO HIGH";
                        case 0x63: return"FIRMWARE IMPENDING FAILURE SEEK ERROR RATE TOO HIGH";
                        case 0x64: return"FIRMWARE IMPENDING FAILURE TOO MANY BLOCK REASSIGNS";
                        case 0x65: return"FIRMWARE IMPENDING FAILURE ACCESS TIME TOO HIGH";
                        case 0x66: return"FIRMWARE IMPENDING FAILURE START UNIT TIMES TOO HIGH";
                        case 0x67: return"FIRMWARE IMPENDING FAILURE CHANNEL PARAMETRICS";
                        case 0x68: return"FIRMWARE IMPENDING FAILURE FIRMWARE DETECTED";
                        case 0x69: return"FIRMWARE IMPENDING FAILURE THROUGHPUT PERFORMANCE";
                        case 0x6A: return"FIRMWARE IMPENDING FAILURE SEEK TIME PERFORMANCE";
                        case 0x6B: return"FIRMWARE IMPENDING FAILURE SPIN-UP RETRY COUNT";
                        case 0x6C: return"FIRMWARE IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT";
                        case 0xFF: return"FAILURE PREDICTION THRESHOLD EXCEEDED (FALSE)";
                    }

                    break;
                case 0x5E:
                    switch(ASCQ)
                    {
                        case 0x00: return"LOW POWER CONDITION ON";
                        case 0x01: return"IDLE CONDITION ACTIVATED BY TIMER";
                        case 0x02: return"STANDBY CONDITION ACTIVATED BY TIMER";
                        case 0x03: return"IDLE CONDITION ACTIVATED BY COMMAND";
                        case 0x04: return"STANDBY CONDITION ACTIVATED BY COMMAND";
                        case 0x05: return"IDLE_B CONDITION ACTIVATED BY TIMER";
                        case 0x06: return"IDLE_B CONDITION ACTIVATED BY COMMAND";
                        case 0x07: return"IDLE_C CONDITION ACTIVATED BY TIMER";
                        case 0x08: return"IDLE_C CONDITION ACTIVATED BY COMMAND";
                        case 0x09: return"STANDBY_Y CONDITION ACTIVATED BY TIMER";
                        case 0x0A: return"STANDBY_Y CONDITION ACTIVATED BY COMMAND";
                        case 0x41: return"POWER STATE CHANGED TO ACTIVE";
                        case 0x42: return"POWER STATE CHANGED TO IDLE";
                        case 0x43: return"POWER STATE CHANGED TO STANDBY";
                        case 0x45: return"POWER STATE CHANGED TO SLEEP";
                        case 0x47: return"POWER STATE CHANGED TO DEVICE CONTROL";
                    }

                    break;
                case 0x60:
                    switch(ASCQ)
                    {
                        case 0x00: return"LAMP FAILURE";
                    }

                    break;
                case 0x61:
                    switch(ASCQ)
                    {
                        case 0x00: return"VIDEO ACQUISTION ERROR";
                        case 0x01: return"UNABLE TO ACQUIRE VIDEO";
                        case 0x02: return"OUT OF FOCUS";
                    }

                    break;
                case 0x62:
                    switch(ASCQ)
                    {
                        case 0x00: return"SCAN HEAD POSITIONING ERROR";
                    }

                    break;
                case 0x63:
                    switch(ASCQ)
                    {
                        case 0x00: return"END OF USER AREA ENCOUNTERED ON THIS TRACK";
                        case 0x01: return"PACKET DOES NOT FIT IN AVAILABLE SPACE";
                    }

                    break;
                case 0x64:
                    switch(ASCQ)
                    {
                        case 0x00: return"ILLEGAL MODE FOR THIS TRACK";
                        case 0x01: return"INVALID PACKET SIZE";
                    }

                    break;
                case 0x65:
                    switch(ASCQ)
                    {
                        case 0x00: return"VOLTAGE FAULT";
                    }

                    break;
                case 0x66:
                    switch(ASCQ)
                    {
                        case 0x00: return"AUTOMATIC DOCUMENT FEEDER COVER UP";
                        case 0x01: return"AUTOMATIC DOCUMENT FEEDER LIFT UP";
                        case 0x02: return"DOCUMENT JAM IN AUTOMATIC DOCUMENT FEEDER";
                        case 0x03: return"DOCUMENT MISS FEED AUTOMATIC IN DOCUMENT FEEDER";
                    }

                    break;
                case 0x67:
                    switch(ASCQ)
                    {
                        case 0x00: return"CONFIGURATION FAILURE";
                        case 0x01: return"CONFIGURATION OF INCAPABLE LOGICAL UNITS FAILED";
                        case 0x02: return"ADD LOGICAL UNIT FAILED";
                        case 0x03: return"MODIFICATION OF LOGICAL UNIT FAILED";
                        case 0x04: return"EXCHANGE OF LOGICAL UNIT FAILED";
                        case 0x05: return"REMOVE OF LOGICAL UNIT FAILED";
                        case 0x06: return"ATTACHMENT OF LOGICAL UNIT FAILED";
                        case 0x07: return"CREATION OF LOGICAL UNIT FAILED";
                        case 0x08: return"ASSIGN FAILURE OCCURRED";
                        case 0x09: return"MULTIPLY ASSIGNED LOGICAL UNIT";
                        case 0x0A: return"SET TARGET PORT GROUPS COMMAND FAILED";
                        case 0x0B: return"ATA DEVICE FEATURE NOT ENABLED";
                    }

                    break;
                case 0x68:
                    switch(ASCQ)
                    {
                        case 0x00: return"LOGICAL UNIT NOT CONFIGURED";
                        case 0x01: return"SUBSIDIARY LOGICAL UNIT NOT CONFIGURED";
                    }

                    break;
                case 0x69:
                    switch(ASCQ)
                    {
                        case 0x00: return"DATA LOSS ON LOGICAL UNIT";
                        case 0x01: return"MULTIPLE LOGICAL UNIT FAILURES";
                        case 0x02: return"PARITY/DATA MISMATCH";
                    }

                    break;
                case 0x6A:
                    switch(ASCQ)
                    {
                        case 0x00: return"INFORMATIONAL, REFER TO LOG";
                    }

                    break;
                case 0x6B:
                    switch(ASCQ)
                    {
                        case 0x00: return"STATE CHANGE HAS OCCURRED";
                        case 0x01: return"REDUNDANCY LEVEL GOT BETTER";
                        case 0x02: return"REDUNDANCY LEVEL GOT WORSE";
                    }

                    break;
                case 0x6C:
                    switch(ASCQ)
                    {
                        case 0x00: return"REBUILD FAILURE OCCURRED";
                    }

                    break;
                case 0x6D:
                    switch(ASCQ)
                    {
                        case 0x00: return"RECALCULATE FAILURE OCCURRED";
                    }

                    break;
                case 0x6E:
                    switch(ASCQ)
                    {
                        case 0x00: return"COMMAND TO LOGICAL UNIT FAILED";
                    }

                    break;
                case 0x6F:
                    switch(ASCQ)
                    {
                        case 0x00: return"COPY PROTECTION KEY EXCHANGE FAILURE - AUTHENTICATION FAILURE";
                        case 0x01: return"COPY PROTECTION KEY EXCHANGE FAILURE - KEY NOT PRESENT";
                        case 0x02: return"COPY PROTECTION KEY EXCHANGE FAILURE - KEY NOT ESTABLISHED";
                        case 0x03: return"READ OF SCRAMBLED SECTOR WITHOUT AUTHENTICATION";
                        case 0x04: return"MEDIA REGION CODE IS MISMATCHED TO LOGICAL UNIT REGION";
                        case 0x05: return"DRIVE REGION MUST BE PERMANENT/REGION RESET COUNT ERROR";
                        case 0x06: return"INSUFFICIENT BLOCK COUNT FOR BINDING NONCE RECORDING";
                        case 0x07: return"CONFLICT IN BINDING NONCE RECORDING";
                    }

                    break;
                case 0x70: return$"DECOMPRESSION EXCEPTION SHORT ALGORITHM ID OF {ASCQ:X2}h";
                case 0x71:
                    switch(ASCQ)
                    {
                        case 0x00: return"DECOMPRESSIONG EXCEPTION LONG ALGORITHM ID";
                    }

                    break;
                case 0x72:
                    switch(ASCQ)
                    {
                        case 0x00: return"SESSION FIXATION ERROR";
                        case 0x01: return"SESSION FIXATION ERROR WRITING LEAD-IN";
                        case 0x02: return"SESSION FIXATION ERROR WRITING LEAD-OUT";
                        case 0x03: return"SESSION FIXATION ERROR - INCOMPLETE TRACK IN SESSION";
                        case 0x04: return"EMPTY OR PARTIALLY WRITTEN RESERVED TRACK";
                        case 0x05: return"NO MORE TRACK RESERVATIONS ALLOWED";
                        case 0x06: return"RMZ EXTENSION IS NOT ALLOWED";
                        case 0x07: return"NO MORE TEST ZONE EXTENSIONS ARE ALLOWED";
                    }

                    break;
                case 0x73:
                    switch(ASCQ)
                    {
                        case 0x00: return"CD CONTROL ERROR";
                        case 0x01: return"POWER CALIBRATION AREA ALMOST FULL";
                        case 0x02: return"POWER CALIBRATION AREA IS FULL";
                        case 0x03: return"POWER CALIBRATION AREA ERROR";
                        case 0x04: return"PROGRAM MEMORY AREA UPDATE FAILURE";
                        case 0x05: return"PROGRAM MEMORY AREA IS FULL";
                        case 0x06: return"RMA/PMA IS ALMOST FULL";
                        case 0x10: return"CURRENT POWER CALIBRATION AREA ALMOST FULL";
                        case 0x11: return"CURRENT POWER CALIBRATION AREA IS FULL";
                        case 0x17: return"RDZ IS FULL";
                    }

                    break;
                case 0x74:
                    switch(ASCQ)
                    {
                        case 0x00: return"SECURITY ERROR";
                        case 0x01: return"UNABLE TO DECRYPT DATA";
                        case 0x02: return"UNENCRYPTED DATA ENCOUNTERED WHILE DECRYPTING";
                        case 0x03: return"INCORRECT DATA ENCRYPTION KEY";
                        case 0x04: return"CRYPTOGRAPHIC INTEGRITY VALIDATION FAILED";
                        case 0x05: return"ERROR DECRYPTING DATA";
                        case 0x06: return"UNKNOWN SIGNATURE VERIFICATION KEY";
                        case 0x07: return"ENCRYPTION PARAMETERS NOT USEABLE";
                        case 0x08: return"DIGITAL SIGNATURE VALIDATION FAILURE";
                        case 0x09: return"ENCRYPTION MODE MISMATCH ON READ";
                        case 0x0A: return"ENCRYPTED BLOCK NOT RAW READ ENABLED";
                        case 0x0B: return"INCORRECT ENCRYPTION PARAMETERS";
                        case 0x0C: return"UNABLE TO DECRYPT PARAMETER LIST";
                        case 0x0D: return"ENCRYPTION ALGORITHM DISABLED";
                        case 0x10: return"SA CREATION PARAMETER VALUE INVALID";
                        case 0x11: return"SA CREATION PARAMETER VALUE REJECTED";
                        case 0x12: return"INVALID SA USAGE";
                        case 0x21: return"DATA ENCRYPTION CONFIGURATION PREVENTED";
                        case 0x30: return"SA CREATION PARAMETER NOT SUPPORTED";
                        case 0x40: return"AUTHENTICATION FAILED";
                        case 0x61: return"EXTERNAL DATA ENCRYPTION KEY MANAGER ACCESS ERROR";
                        case 0x62: return"EXTERNAL DATA ENCRYPTION KEY MANAGER ERROR";
                        case 0x63: return"EXTERNAL DATA ENCRYPTION KEY NOT FOUND";
                        case 0x64: return"EXTERNAL DATA ENCRYPTION REQUEST NOT AUTHORIZED";
                        case 0x6E: return"EXTERNAL DATA ENCRYPTION CONTROL TIMEOUT";
                        case 0x6F: return"EXTERNAL DATA ENCRYPTION CONTROL ERROR";
                        case 0x71: return"LOGICAL UNIT ACCESS NOT AUTHORIZED";
                        case 0x79: return"SECURITY CONFLICT IN TRANSLATED DEVICE";
                    }

                    break;
            }

            return ASC >= 0x80
                       ? ASCQ >= 0x80
                             ? $"VENDOR-SPECIFIC ASC {ASC:X2}h WITH VENDOR-SPECIFIC ASCQ {ASCQ:X2}h"
                             : $"VENDOR-SPECIFIC ASC {ASC:X2}h WITH ASCQ {ASCQ:X2}h"
                       : ASCQ >= 0x80
                           ? $"ASC {ASC:X2}h WITH VENDOR-SPECIFIC ASCQ {ASCQ:X2}h"
                           : $"ASC {ASC:X2}h WITH ASCQ {ASCQ:X2}h";
        }
    }
}