///////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  Microsoft Research Singularity
//

//#define DEBUG_AML_PARSER

using System.Collections;
using System.Diagnostics;
using System.Text;

using AccessType = Microsoft.Singularity.Hal.Acpi.AcpiObject.AccessType;
using AccessAttrib = Microsoft.Singularity.Hal.Acpi.AcpiObject.AccessAttrib;
using LockRule = Microsoft.Singularity.Hal.Acpi.AcpiObject.LockRule;
using UpdateRule = Microsoft.Singularity.Hal.Acpi.AcpiObject.UpdateRule;
using SerializeFlag = Microsoft.Singularity.Hal.Acpi.AcpiObject.SerializeFlag;
using AbsoluteNodePath = Microsoft.Singularity.Hal.Acpi.AcpiNamespace.AbsoluteNodePath;

using Microsoft.Singularity.Hal.Acpi.AmlParserUnions;

// TODO list:
// * Better error handling. Currently just returns Failure if it fails to parse.

// This file implements a simple recursive descent parser based
// directly on the ACPI specification, Revision 3.0b, section 18.2, in
// order to ensure maximum compliance. Compile-time inlining and
// tail-recursion elimination should make it relatively efficient
// considering the simplicity of the grammar; for this reason, and
// because of annoying snags like the sub-byte encoding of package
// length, I opted for this implementation instead of using a
// full-blown parser generator like netcc on Toolbox.

// Most rules are taken directly from the spec. I made casing
// consistent and renamed the nonterminals "String" and "Object" to
// avoid keyword conflict, and changed some rules where indicated to
// make the grammar unambiguous and sensible.

// Note that in some cases identifiers are inconsistent with established
// naming conventions like "AMLCode" instead of "AmlCode". This is for
// consistency with the specification.

namespace Microsoft.Singularity.Hal.Acpi
{
    // Terminology used by ACPI spec for basic integer types (from section 18.2.3):
    // 
    // ByteData             := 0x00 - 0xFF
    // WordData             := ByteData[0:7] ByteData[8:15]
    //                         // 0x0000-0xFFFF
    // DWordData            := WordData[0:15] WordData[16:31]
    //                         // 0x00000000-0xFFFFFFFF
    // QWordData            := DWordData[0:31] DWordData[32:63]
    //                         // 0x0000000000000000-0xFFFFFFFFFFFFFFFF

    using ByteData  = System.Byte;
    using WordData  = System.UInt16;
    using DWordData = System.UInt32;
    using QWordData = System.UInt64;

    // This interface defines a basic read-only stream interface for the
    // AML parser input that is sufficient for the purposes of the parser.
    // Any attempt to read past the end of the stream produces the exception
    // EndOfAmlStreamException.
    public interface IAmlStream
    {
        // Read 8-bit byte at the given offset, updating the offset past it
        ByteData ReadByteData(ref int offset);

        // Try to read 8-bit byte at the given offset, updating the offset past it,
        // and returning false and not updating offset if offset is at end of stream.
        bool TryReadByteData(ref int offset, out ByteData result);

        // Read 8-bit byte at the given offset as a character, updating the offset past it
        char ReadChar(ref int offset);

        // Reads "length" 8-bit bytes at the given offset, updating the offset past them
        ByteData[] ReadByteDataArray(ref int offset, int length);

        // Reads "length" 8-bit bytes at the given offset, updating the offset past them,
        // and returning false and not updating offset if offset is at end of stream.
        bool TryReadByteDataArray(ref int offset, int length, out ByteData[] result);

        // Read 16-bit word at the given offset, updating the offset past it
        WordData ReadWordData(ref int offset);

        // Read 32-bit word at the given offset, updating the offset past it
        DWordData ReadDWordData(ref int offset);

        // Read 64-bit word at the given offset, updating the offset past it
        QWordData ReadQWordData(ref int offset);
    }

    public class EndOfAmlStreamException : System.Exception
    {
    }

    public class AmlMalformattedException : System.Exception
    {
        public AmlMalformattedException()
            : base("Malformatted AML") { }

        public AmlMalformattedException(string reason)
          : base("Malformatted AML: " + reason) { }
    }

    // Base parser node class
    public abstract class AmlParserNode
    {
        public abstract void Accept(AmlParserNodeVisitor v);
    }

#if !SINGULARITY_KERNEL
    public class Debug
    {
        public static void Assert(bool b)
        {
            if (!b) {
                throw new System.Exception("Failed assertion");
            }
        }

        public static void Assert(bool b, string s)
        {
            if (!b) {
                throw new System.Exception("Failed assertion");
            }
        }
    }
#endif

    // Main parser class
    public class AmlParser
    {
        private IAmlStream stream;
        private IDictionary methodNumArgsByName = new SortedList();
        private AcpiNamespace acpiNamespace;
        private AcpiNamespace.AbsoluteNodePath currentNodePath;

        public AmlParser(IAmlStream stream, AcpiNamespace acpiNamespace,
                         AcpiNamespace.AbsoluteNodePath initialNodePath)
        {
            this.stream = stream;
            this.acpiNamespace = acpiNamespace;
            this.currentNodePath = initialNodePath;
        }

        public enum ParseSuccess
        {
            Success,
            Failure
        }
        const ParseSuccess Success = ParseSuccess.Success;
        const ParseSuccess Failure = ParseSuccess.Failure;

        private void VerifyFormat(bool condition, string malformattedReason)
        {
            if (!condition) {
                throw new AmlMalformattedException(malformattedReason);
            }
        }

        //
        // Section 18.2: AML Grammar Definition
        //

        // This section defines the byte values that make up an AML byte stream.
        // The AML encoding can be categorized in the following groups:
        //     * Table and Table Header encoding
        //     * Name objects encoding
        //     * Data objects encoding
        //     * Package length encoding
        //     * Term objects encoding
        //     * Miscellaneous objects encoding

        //
        // Section 18.2.1: Table and Table Header Encoding
        //

        // AMLCode              := DefBlockHdr TermList
        //[DefBlockHdr is handled by SystemTableHeader under Kernel\Singulary.Acpi, so
        // we just make this top-level rule contain a TermList.]

        public class AMLCode : AmlParserNode
        {
            public TermObj[] termList;

            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        // Main entry point
        public ParseSuccess ParseAMLCode(out AMLCode result, ref int offset, int endOffset)
        {
            int offset2 = offset;
            result = new AMLCode();
            if (ParseTermList(out result.termList, ref offset2, endOffset) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // DefBlockHdr          := TableSignature TableLength SpecCompliance CheckSum OemID
        //                         OemTableID OemRevision CreatorID CreatorRevision
        //[Handled by SystemTableHeader under Kernel\Singulary.Acpi ]

        // TableSignature       := DWordData // As defined in section 5.2.3.
        // TableLength          := DWordData // Length of the table in bytes including
        //                                   // the block header.
        // SpecCompliance       := ByteData // The revision of the structure.
        // CheckSum             := ByteData // Byte checksum of the entire table.
        // OemID                := ByteData(6) // OEM ID of up to 6 characters. If the OEM
        //                                     // ID is shorter than 6 characters, it
        //                                     // can be terminated with a NULL
        //                                     // character.
        // OemTableID           := ByteData(8) // OEM Table ID of up to 8 characters. If
                                               // the OEM Table ID is shorter than 8
                                               // characters, it can be terminated with
                                               // a NULL character.
        // OemRevision          := DWordData // OEM Table Revision.
        // CreatorID            := DWordData // Vendor ID of the ASL compiler.
        // CreatorRevision      := DWordData // Revision of the ASL compiler.

        //
        // Section 18.2.2: Name Objects Encoding
        //

        // [These rules just constrain the characters in NameSegs,
        //  already described by assertions in AcpiNamespace.AssertIsValidName().
        // LeadNameChar         := 'A'-'Z' | '_'
        // DigitChar            := '0'-'9'
        // NameChar             := DigitChar | LeadNameChar

        // RootChar             := '\'

        private bool IsRootChar(char data)
        {
            return data == (byte)'\\';
        }
        
        private ParseSuccess ParseRootChar(ref int offset)
        {
            int offset2 = offset;
            char c = stream.ReadChar(ref offset2);
            if (!IsRootChar(c)) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // ParentPrefixChar     := '^'

        private bool IsParentPrefixChar(char data)
        {
            return data == (byte)'^';
        }
        
        private ParseSuccess ParseParentPrefixChar(ref int offset)
        {
            int offset2 = offset;
            char c = stream.ReadChar(ref offset2);
            if (!IsParentPrefixChar(c)) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // NameSeg              := <LeadNameChar NameChar NameChar NameChar>
        //                         // Notice that NameSegs shorter than 4 characters
        //                         // are filled with trailing underscores ('_'s).

        public class NameSeg : AmlParserNode
        {
            public string data;

            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private char[] nameCharsTemp = new char[4];

        private ParseSuccess ParseNameSeg(out NameSeg result, ref int offset)
        {
            int offset2 = offset;
            result = null;

            // First check first character to avoid spurious allocations
            char firstChar = stream.ReadChar(ref offset2);
            if (!(System.Char.IsUpper(firstChar) || firstChar == '_')) {
                return Failure;
            }

            offset2 = offset; // Rewind to first character
            byte[] nameBytes;
            if (!stream.TryReadByteDataArray(ref offset2, 4, out nameBytes)) {
                return Failure;
            }

            if (!AcpiNamespace.IsValidName(nameBytes)) {
                return Failure;
            }

            for (int i = 0; i < nameCharsTemp.Length; i++) {
                nameCharsTemp[i] = (char)nameBytes[i];
            }
            string name = new string(nameCharsTemp);

            result = new NameSeg();
            result.data = name;

            offset = offset2;
            return Success;
        }

        // NameString           := <RootChar NamePath> | <PrefixPath NamePath>

        public class NameString : AmlParserNode
        {
            public AcpiNamespace.NodePath nodePath;

            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private string[] NamePathToStringArray(NamePath namePath)
        {
            string[] result = new string[namePath.segments.Length];
            for(int i = 0; i < result.Length; i++) {
                result[i] = namePath.segments[i].data;
            }
            return result;
        }

        private ParseSuccess ParseNameString(out NameString result, ref int offset)
        {
            result = null;
            int offset2 = offset;

            if (ParseRootChar(ref offset2) == Success) {
                NamePath namePath;
                if (ParseNamePath(out namePath, ref offset2) == Failure) {
                    return Failure;
                }
                result = new NameString();
                result.nodePath = new AcpiNamespace.NodePath(true/*isAbsolute*/, 0, NamePathToStringArray(namePath));
            }
            else {
                PrefixPath prefixPath;
                NamePath namePath;
                if (ParsePrefixPath(out prefixPath, ref offset2) == Failure ||
                    ParseNamePath(out namePath, ref offset2) == Failure) {
                    return Failure;
                }
                result = new NameString();
                result.nodePath = new AcpiNamespace.NodePath(false/*isAbsolute*/, prefixPath.length, NamePathToStringArray(namePath));
            }

            offset = offset2;
            return Success;
        }

        // PrefixPath           := Nothing | <'^' PrefixPath>
        // [I use ParentPrefixChar (otherwise unused) for '^']

        public class PrefixPath : AmlParserNode
        {
            public int length;

            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParsePrefixPath(out PrefixPath result, ref int offset)
        {
            int offset2 = offset;
            result = new PrefixPath();
            result.length = 0;
            while (ParseParentPrefixChar(ref offset2) != Failure) {
                result.length++;
            }
            offset = offset2;
            return Success;
        }

        // NamePath             := NameSeg | DualNamePath | MultiNamePath | NullName

        public class NamePath : AmlParserNode
        {
            public NameSeg[] segments;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseNamePath(out NamePath result, ref int offset)
        {
            int offset2 = offset;
            result = new NamePath();

            if (ParseDualNamePath(out result.segments, ref offset2) == Failure &&
                ParseMultiNamePath(out result.segments, ref offset2) == Failure &&
                ParseNullName(out result.segments, ref offset2)      == Failure) {
                result.segments = new NameSeg[1];
                if (ParseNameSeg(out result.segments[0], ref offset2) == Failure) {
                    return Failure;
                }
            }

            offset = offset2;
            return Success;
        }

        // DualNamePath         := DualNamePrefix NameSeg NameSeg

        private ParseSuccess ParseDualNamePath(out NameSeg[] result, ref int offset)
        {
            int offset2 = offset;
            result = null;

            char prefix = stream.ReadChar(ref offset2);
            if (prefix != DualNamePrefix) {
                return Failure;
            }

            result = new NameSeg[2];
            if (ParseNameSeg(out result[0], ref offset2) == Failure ||
                ParseNameSeg(out result[1], ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DualNamePrefix       := 0x2E

        private const char DualNamePrefix = '\x002E';

        // MultiNamePath        := MultiNamePrefix SegCount NameSeg(SegCount)

        private ParseSuccess ParseMultiNamePath(out NameSeg[] result, ref int offset)
        {
            int offset2 = offset;
            result = null;

            char prefix = stream.ReadChar(ref offset2);
            if (prefix != MultiNamePrefix) {
                return Failure;
            }

            SegCount segCount;
            if (ParseSegCount(out segCount, ref offset2) == Failure) {
                return Failure;
            }
            result = new NameSeg[segCount.data];
            for (int segNum = 0; segNum < segCount.data; segNum++) {
                if (ParseNameSeg(out result[segNum], ref offset2) == Failure) {
                    return Failure;
                }
            }

            offset = offset2;
            return Success;
        }

        // MultiNamePrefix      := 0x2F

        private const char MultiNamePrefix = '\x002F';

        // SegCount             := ByteData
        // Note: SegCount can be from 1 to 255. For example:
        // MultiNamePrefix(35) is encoded as 0x2f 0x23 and followed by
        // 35 NameSegs. So, the total encoding length will be 1 + 1 +
        // 35*4 = 142. Notice that: DualNamePrefix NameSeg NameSeg has
        // a smaller encoding than the encoding of: MultiNamePrefix(2)
        // NameSeg NameSeg

        public class SegCount : AmlParserNode
        {
            public ByteData data;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseSegCount(out SegCount result, ref int offset)
        {
            int offset2 = offset;
            result = new SegCount();
            result.data = stream.ReadByteData(ref offset2);
            offset = offset2;
            return Success;
        }

        // SimpleName           := NameString | ArgObj | LocalObj
        // See AmlParser.csunion

        private ParseSuccess ParseSimpleName(out SimpleName result, ref int offset)
        {
            int offset2 = offset;

            NameString nameString;
            ArgObj argObj;
            LocalObj localObj;
            if (ParseArgObj(out argObj, ref offset2) == Success) {
                result = SimpleName.CreateArgObj(argObj);
            }
            else if (ParseLocalObj(out localObj, ref offset2) == Success) {
                result = SimpleName.CreateLocalObj(localObj);
            }
            else if (ParseNameString(out nameString, ref offset2) == Success) {
                result = SimpleName.CreateNameString(nameString);
            } 
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // SuperName            := SimpleName | DebugObj | Type6Opcode
        // See AmlParser.csunion

        private ParseSuccess ParseSuperName(out SuperName result, ref int offset)
        {
            int offset2 = offset;

            // There's an ambiguity here! What to do?
            //    SuperName -> SimpleName -> NameString
            //    SuperName -> Type6Opcode -> UserTermObj
            //              -> NameString TermArgList -> NameString
            // For now just doing whatever the parser chooses first.
            SimpleName simpleName;
            DebugObj debugObj;
            Type6Opcode type6Opcode;
            if (ParseSimpleName(out simpleName, ref offset2) == Success) {
                result = SuperName.CreateSimpleName(simpleName);
            }
            else if (ParseDebugObj(out debugObj, ref offset2) == Success) {
                result = SuperName.CreateDebugObj(debugObj);
            }
            else if (ParseType6Opcode(out type6Opcode, ref offset2) == Success) {
                result = SuperName.CreateType6Opcode(type6Opcode);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // NullName             := 0x00

        private ParseSuccess ParseNullName(out NameSeg[] result, ref int offset)
        {
            int offset2 = offset;
            result = null;

            char prefix = stream.ReadChar(ref offset2);
            if (prefix != '\0') {
                return Failure;
            }

            result = new NameSeg[0];
            offset = offset2;
            return Success;
        }

        // Target               := SuperName | NullName
        // [NOTE: SuperName can reduce to NullName anyway:
        //  SuperName -> SimpleName -> NameString -> PrefixPath NamePath
        //            -> NamePath -> NullName
        //  Therefore Target is the same thing as SuperName. We wrap it
        //  for type safety only.]

        public class Target : AmlParserNode
        {
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseTarget(out Target result, ref int offset)
        {
            int offset2 = offset;
            result = new Target();
            if (ParseSuperName(out result.superName, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        //
        // Section 18.2.3: Data Objects Encoding
        //

        // ComputationalData    := ByteConst | WordConst | DWordConst | QWordConst |
        //                         StringConst | ConstObj | RevisionOp | DefBuffer
        // See AmlParser.csunion

        private ParseSuccess ParseComputationalData(out ComputationalData result, ref int offset)
        {
            int offset2 = offset;

            ByteData byteConst;
            WordData wordConst;
            DWordData dWordConst;
            QWordData qWordConst;
            string stringConst;
            ConstObj constObj;
            DefBuffer defBuffer;
            if (ParseByteConst(out byteConst, ref offset2) == Success) {
                result = ComputationalData.CreateByteConst(byteConst);
            }
            else if (ParseWordConst(out wordConst, ref offset2) == Success) {
                result = ComputationalData.CreateWordConst(wordConst);
            }
            else if (ParseDWordConst(out dWordConst, ref offset2) == Success) {
                result = ComputationalData.CreateDWordConst(dWordConst);
            }
            else if (ParseQWordConst(out qWordConst, ref offset2) == Success) {
                result = ComputationalData.CreateQWordConst(qWordConst);
            }
            else if (ParseStringConst(out stringConst, ref offset2) == Success) {
                result = ComputationalData.CreateStringConst(stringConst);
            }
            else if (ParseConstObj(out constObj, ref offset2) == Success) {
                result = ComputationalData.CreateConstObj(constObj);
            }
            else if (ParseRevisionOp(ref offset2) == Success) {
                result = ComputationalData.CreateRevisionOp();
            }
            else if (ParseDefBuffer(out defBuffer, ref offset2) == Success) {
                result = ComputationalData.CreateDefBuffer(defBuffer);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DataObject           := ComputationalData | DefPackage | DefVarPackage
        // See AmlParser.csunion

        private ParseSuccess ParseDataObject(out DataObject result, ref int offset)
        {
            int offset2 = offset;

            ComputationalData computationalData;
            DefPackage defPackage;
            DefVarPackage defVarPackage;
            if (ParseDefPackage(out defPackage, ref offset2) == Success) {
                result = DataObject.CreateDefPackage(defPackage);
            }
            else if (ParseDefVarPackage(out defVarPackage, ref offset2) == Success) {
                result = DataObject.CreateDefVarPackage(defVarPackage);
            }
            else if (ParseComputationalData(out computationalData, ref offset2) == Success) {
                result = DataObject.CreateComputationalData(computationalData);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DataRefObject        := DataObject | ObjectReference | DDBHandle
        // [Note that here ObjectReference and DDBHandle do not have
        //  rules; the only reasonable interpretation is that they mean
        //  "TermArg => ObjectReference" and "DDBHandleObject".]
        // See AmlParser.csunion

        private ParseSuccess ParseDataRefObject(out DataRefObject result, ref int offset)
        {
            int offset2 = offset;

            DataObject dataObject;
            TermArg objectReference;
            DDBHandleObject ddbHandle;
            if (ParseDataObject(out dataObject, ref offset2) == Success) {
                result = DataRefObject.CreateDataObject(dataObject);
            }
            else if (ParseTermArg(out objectReference, ref offset2) == Success) {
                //if (!TermArgEvaluatesTo(objectReference, TermArgType.ObjectReference) {
                //  return Failure;
                //}   
                result = DataRefObject.CreateObjectReference(objectReference);
            }
            else if (ParseDDBHandleObject(out ddbHandle, ref offset2) == Success) {
                result = DataRefObject.CreateDDBHandle(ddbHandle);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // ByteConst            := BytePrefix ByteData

        private ParseSuccess ParseByteConst(out ByteData result, ref int offset)
        {
            int offset2 = offset;
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != BytePrefix) {
                result = 0;
                return Failure;
            }
            result = stream.ReadByteData(ref offset2);
            offset = offset2;
            return Success;
        }

        // BytePrefix           := 0x0A

        const ByteData BytePrefix = 0x0A;

        // WordConst            := WordPrefix WordData

        private ParseSuccess ParseWordConst(out WordData result, ref int offset)
        {
            int offset2 = offset;
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != WordPrefix) {
                result = 0;
                return Failure;
            }
            result = stream.ReadWordData(ref offset2);
            offset = offset2;
            return Success;
        }

        // WordPrefix           := 0x0B

        const ByteData WordPrefix = 0x0B;

        // DWordConst           := DWordPrefix DWordData

        private ParseSuccess ParseDWordConst(out DWordData result, ref int offset)
        {
            int offset2 = offset;
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != DWordPrefix) {
                result = 0;
                return Failure;
            }
            result = stream.ReadDWordData(ref offset2);
            offset = offset2;
            return Success;
        }

        // DWordPrefix          := 0x0C

        const ByteData DWordPrefix = 0x0C;

        // QWordConst           := QWordPrefix QWordData

        private ParseSuccess ParseQWordConst(out QWordData result, ref int offset)
        {
            int offset2 = offset;
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != QWordPrefix) {
                result = 0;
                return Failure;
            }
            result = stream.ReadQWordData(ref offset2);
            offset = offset2;
            return Success;
        }

        // QWordPrefix          := 0x0E

        const ByteData QWordPrefix = 0x0E;

        // StringConst          := StringPrefix AsciiCharList NullChar
        // AsciiCharList        := Nothing | <AsciiChar AsciiCharList>

        private ParseSuccess ParseStringConst(out string result, ref int offset)
        {
            int offset2 = offset;
            result = null;

            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != StringPrefix) {
                return Failure;
            }

            StringBuilder resultBuilder = new StringBuilder();
            while (true) {
                char c = stream.ReadChar(ref offset2);
                if (c == NullChar) {
                    break;
                }
                if (!IsAsciiChar(c)) {
                    return Failure;
                }
                resultBuilder.Append(c);
            }

            result = resultBuilder.ToString();
            offset = offset2;
            return Success;
        }

        // StringPrefix         := 0x0D

        const ByteData StringPrefix = 0x0D;

        // ConstObj             := ZeroOp | OneOp | OnesOp

        public class ConstObj : AmlParserNode
        {
            public ByteData op;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseConstObj(out ConstObj result, ref int offset)
        {
            int offset2 = offset;
            result = new ConstObj();
            ByteData op = stream.ReadByteData(ref offset2);
            if (op != ZeroOp &&
                op != OneOp  &&
                op != OnesOp) {
                return Failure;
            }
            result.op = op;
            offset = offset2;
            return Success;
        }

        // ByteList             := Nothing | <ByteData ByteList>
        // [To make this rule make sense, it needs a length
        //  limit for termination. The rule using it should know this.]

        private ParseSuccess ParseByteList(out ByteData[] result, ref int offset, int endOffset)
        {
            int offset2 = offset;
            result = stream.ReadByteDataArray(ref offset2, endOffset - offset);
            offset = offset2;
            return Success;
        }

        // AsciiChar            := 0x01 - 0x7F

        private bool IsAsciiChar(char data)
        {
            return (byte)data >= 0x01 && (byte)data <= 0x7F;
        }

        // NullChar             := 0x00

        char NullChar = '\0';

        // ZeroOp               := 0x00

        public const ByteData ZeroOp = 0x00;

        // OneOp                := 0x01

        public const ByteData OneOp = 0x01;

        // OnesOp               := 0xFF

        public const ByteData OnesOp = 0xFF;

        // RevisionOp           := ExtOpPrefix 0x30

        private ParseSuccess ParseRevisionOp(ref int offset)
        {
            int offset2 = offset;
            ByteData b = stream.ReadByteData(ref offset2);
            if (b != ExtOpPrefix) {
                return Failure;
            }
            b = stream.ReadByteData(ref offset2);
            if (b != 0x30) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // ExtOpPrefix          := 0x5B

        const ByteData ExtOpPrefix = 0x5B;

        //
        // Section 18.2.4: Package Length Encoding
        //

        // PkgLength            := PkgLeadByte |
        //                         <PkgLeadByte ByteData> |
        //                         <PkgLeadByte ByteData ByteData> |
        //                         <PkgLeadByte ByteData ByteData ByteData>

        // PkgLeadByte          := <bit 7-6: ByteData count that follows (0-3)>
        //                         <bit 5-4: Only used if PkgLength < 63>
        //                         <bit 3-0: Least significant package length nybble>

        // Note: The high 2 bits of the first byte reveal how many
        // follow bytes are in the PkgLength. If the PkgLength has
        // only one byte, bit 0 through 5 are used to encode the
        // package length (in other words, values 0-63). If the
        // package length value is more than 63, more than one byte
        // must be used for the encoding in which case bit 4 and 5 of
        // the PkgLeadByte are reserved and must be zero. If the
        // multiple bytes encoding is used, bits 0-3 of the
        // PkgLeadByte become the least significant 4 bits of the
        // resulting package length value. The next ByteData will
        // become the next least significant 8 bits of the resulting
        // value and so on, up to 3 ByteData bytes. Thus, the maximum
        // package length is 2**28.

        private ParseSuccess ParsePkgLength(out int result, ref int offset)
        {
            int offset2 = offset;
            int length = 0; // Maximum 2^31 - 1 >= 2^28

            ByteData pkgLeadByte = stream.ReadByteData(ref offset2);
            int followingByteDataCount = pkgLeadByte >> 6;
            if (followingByteDataCount == 0) {
                // Bits 5-0 contain package length
                length = pkgLeadByte & 0x3F;
            }
            else {
                VerifyFormat(((pkgLeadByte >> 4) & 3) == 0,
                             "Expect bits 5-4 zero when bits 7-6 nonzero in PkgLeadByte");
                length = pkgLeadByte & 0xF;
                int shiftAmount = 4;
                for (int i = 0; i < followingByteDataCount; i++) {
                    ByteData b = stream.ReadByteData(ref offset2);
                    length = length | (((int)b) << shiftAmount);
                    shiftAmount += 8;
                }
            }
            result = length;
            offset = offset2;
            return Success;
        }

        // [This wrapper converts a PkgLength result to a more useful
        //  position-independent end offset of the area measured by the
        //  PkgLength. This offset is exclusive (the byte at that offset
        //  is not itself in the area).]
        private ParseSuccess ParsePkgLengthEndOffset(out int endOffset, ref int offset)
        {
            int offset2 = offset;
            int length;
            if (ParsePkgLength(out length, ref offset2) == Failure) {
                endOffset = 0;
                return Failure;
            }
            endOffset = offset + length;
            offset = offset2;
            return Success;
        }
            
        //
        // Section 18.2.5: Term Objects Encoding
        //

        // TermObj              := NameSpaceModifierObj | NamedObj | Type1Opcode | Type2Opcode
        // See AmlParser.csunion

        private ParseSuccess ParseTermObj(out TermObj result, ref int offset, int endOffset)
        {
            int offset2 = offset;

            NameSpaceModifierObj nameSpaceModifierObj;
            NamedObj namedObj;
            Type1Opcode type1Opcode;
            Type2Opcode type2Opcode;
            if (ParseNamedObj(out namedObj, ref offset2) == Success) {
                result = TermObj.CreateNamedObj(namedObj);
            }
            else if (ParseType1Opcode(out type1Opcode, ref offset2, endOffset) == Success) {
                result = TermObj.CreateType1Opcode(type1Opcode);
            }
            else if (ParseType2Opcode(out type2Opcode, ref offset2) == Success) {
                result = TermObj.CreateType2Opcode(type2Opcode);
            }
            else if (ParseNameSpaceModifierObj(out nameSpaceModifierObj, ref offset2) == Success) {
                result = TermObj.CreateNameSpaceModifierObj(nameSpaceModifierObj);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // TermList             := Nothing | <TermObj TermList>
        // [To make this rule make sense, it needs a length
        //  limit for termination. The rule using it should know this.]

        private class TermList
        {
            ArrayList list = new ArrayList();

            public void Add(TermObj termObj)
            {
                list.Add(termObj);
            }

            public TermObj[] ToArray()
            {
                return (TermObj[])list.ToArray(typeof(TermObj));
            }
        }

        public ParseSuccess ParseTermList(out TermObj[] result, ref int offset, int endOffset)
        {
            result = null;
            TermList termObjs = new TermList();
            int offset2 = offset;

            while (offset2 < endOffset) {
#if DEBUG_AML_PARSER
                System.Console.WriteLine(offset2.ToString("x8"));
#endif
                TermObj termObj;
                if (ParseTermObj(out termObj, ref offset2, endOffset) == Failure) {
                    return Failure;
                }
                termObjs.Add(termObj);
            }
            Debug.Assert(offset2 == endOffset);
            
            result = termObjs.ToArray();
            offset = offset2;
            return Success;
        }

        // TermArg              := Type2Opcode | DataObject | ArgObj | LocalObj
        // See AmlParser.csunion

        private ParseSuccess ParseTermArg(out TermArg result, ref int offset)
        {
            int offset2 = offset;

            Type2Opcode type2Opcode;
            DataObject dataObject;
            ArgObj argObj;
            LocalObj localObj;
            // Type2Opcode must be tried after DataObject, because the constant object
            // Zero will otherwise parse as a UserTermObj with NullName for Namestring.
            if (ParseDataObject(out dataObject, ref offset2) == Success) {
                result = TermArg.CreateDataObject(dataObject);
            }
            else if (ParseArgObj(out argObj, ref offset2) == Success) {
                result = TermArg.CreateArgObj(argObj);
            }
            else if (ParseLocalObj(out localObj, ref offset2) == Success) {
                result = TermArg.CreateLocalObj(localObj);
            }
            else if (ParseType2Opcode(out type2Opcode, ref offset2) == Success) {
                result = TermArg.CreateType2Opcode(type2Opcode);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // UserTermObj          := NameString TermArgList
        // [This rule annoyingly uses a variable-length list that, unlike every other
        //  such list, is determined not by an obvious encoded PkgLength. According to the engineer
        //  who worked on the Windows AML parser, it's necessary to look up the method indicated
        //  by the NameString to determine its number of arguments. To accomplish this we delay
        //  parsing of the method body until after all methods have been loaded into the namespace.]

        public class UserTermObj : AmlParserNode
        {
            public NameString nameString;
            public TermArg[] termArgList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseUserTermObj(out UserTermObj result, ref int offset)
        {
            int offset2 = offset;
            result = new UserTermObj();

            if (ParseNameString (out result.nameString, ref offset2) == Failure) {
                return Failure;
            }

            int numTermArgs = 0;
            AcpiNamespace.Node node = null;
            if (acpiNamespace != null) {
                node = acpiNamespace.LookupNode(result.nameString.nodePath, currentNodePath);
            }
            if (node != null && node.Value is AcpiObject.Method) {
                numTermArgs = ((AcpiObject.Method)node.Value).ArgCount;
            }
            else {
                numTermArgs = 0; // If we're still loading, it can't be a method call, must have zero args
            }

            if (ParseTermArgListN(out result.termArgList, ref offset2, numTermArgs) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // TermArgList          := Nothing | <TermArg TermArgList>
        // [To make this rule make sense, it needs a length
        //  limit for termination. The rule using it should know this.]

        private class TermArgList
        {
            ArrayList list = new ArrayList();

            public void Add(TermArg termArg)
            {
                list.Add(termArg);
            }

            public TermArg[] ToArray()
            {
                return (TermArg[])list.ToArray(typeof(TermArg));
            }
        }

        private ParseSuccess ParseTermArgList(out TermArg[] result, ref int offset, int endOffset)
        {
            result = null;
            TermArgList termArgs = new TermArgList();
            int offset2 = offset;

            while (offset2 < endOffset) {
                TermArg termArg;
                if (ParseTermArg(out termArg, ref offset2) == Failure) {
                    return Failure;
                }
                termArgs.Add(termArg);
            }
            Debug.Assert(offset2 == endOffset);
            
            result = termArgs.ToArray();
            offset = offset2;
            return Success;
        }

        // For UserTermObj rule, parses a specified number of TermArgs
        private ParseSuccess ParseTermArgListN(out TermArg[] result, ref int offset, int numTermArgs)
        {
            int offset2 = offset;
            result = new TermArg[numTermArgs];

            for (int i = 0; i < numTermArgs; i++) {
                if (ParseTermArg(out result[i], ref offset2) == Failure) {
                    return Failure;
                }
            }
           
            offset = offset2;
            return Success;
        }

        // AmlObjectList           := Nothing | <AmlObject AmlObjectList>
        // [To make this rule make sense, it needs a length
        //  limit for termination. The rule using it should know this.]

        private class AmlObjectList
        {
            ArrayList list = new ArrayList();

            public void Add(AmlObject amlObject)
            {
                list.Add(amlObject);
            }

            public AmlObject[] ToArray()
            {
                return (AmlObject[])list.ToArray(typeof(AmlObject));
            }
        }

        private ParseSuccess ParseAmlObjectList(out AmlObject[] result, ref int offset, int endOffset)
        {
            result = null;
            AmlObjectList amlObjects = new AmlObjectList();
            int offset2 = offset;

            while (offset2 < endOffset) {
                AmlObject amlObject;
                if (ParseAmlObject(out amlObject, ref offset2) == Failure) {
                    return Failure;
                }
                amlObjects.Add(amlObject);
            }
            Debug.Assert(offset2 == endOffset);
            
            result = amlObjects.ToArray();
            offset = offset2;
            return Success;
        }

        // AmlObject               := NameSpaceModifierObj | NamedObj
        // See AmlParser.csunion

        private ParseSuccess ParseAmlObject(out AmlObject result, ref int offset)
        {
            int offset2 = offset;

            NameSpaceModifierObj nameSpaceModifierObj;
            NamedObj namedObj;
            if (ParseNameSpaceModifierObj(out nameSpaceModifierObj, ref offset2) == Success) {
                result = AmlObject.CreateNameSpaceModifierObj(nameSpaceModifierObj);
            }
            else if (ParseNamedObj(out namedObj, ref offset2) == Success) {
                result = AmlObject.CreateNamedObj(namedObj);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        //
        // Section 18.2.5.1: Namespace Modifier Objects Encoding
        //

        // NameSpaceModifierObj := DefAlias | DefName | DefScope
        // See AmlParser.csunion

        private ParseSuccess ParseNameSpaceModifierObj(out NameSpaceModifierObj result, ref int offset)
        {
            int offset2 = offset;

            DefAlias defAlias;
            DefName defName;
            DefScope defScope;
            if (ParseDefAlias(out defAlias, ref offset2) == Success) {
                result = NameSpaceModifierObj.CreateDefAlias(defAlias);
            }
            else if (ParseDefName(out defName, ref offset2) == Success) {
                result = NameSpaceModifierObj.CreateDefName(defName);
            }
            else if (ParseDefScope(out defScope, ref offset2) == Success) {
                result = NameSpaceModifierObj.CreateDefScope(defScope);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefAlias             := AliasOp NameString NameString

        public class DefAlias : AmlParserNode
        {
            public NameString sourceName;
            public NameString aliasName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefAlias(out DefAlias result, ref int offset)
        {
            int offset2 = offset;
            result = new DefAlias();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != AliasOp) {
                return Failure;
            }
            if (ParseNameString(out result.sourceName, ref offset2) == Failure ||
                ParseNameString(out result.aliasName, ref offset2)  == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // AliasOp              := 0x06

        const ByteData AliasOp = 0x06;
        
        // DefName              := NameOp NameString DataRefObject
        // [There is no DataRefObject rule. I assume they mean TermArg => DataRefObject as
        //  in the ArgObject rule.]

        public class DefName : AmlParserNode
        {
            public NameString nameString;
            public TermArg dataRefObject;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefName(out DefName result, ref int offset)
        {
            int offset2 = offset;
            result = new DefName();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != NameOp) {
                return Failure;
            }
            if (ParseNameString(out result.nameString, ref offset2) == Failure ||
                ParseTermArg(out result.dataRefObject, ref offset2)  == Failure /*||
                !TermArgEvaluatesTo(result.dataRefObject, TermArgType.DataRefObject*/) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // NameOp               := 0x08

        const ByteData NameOp = 0x08;
        
        // DefScope             := ScopeOp PkgLength NameString TermList

        public class DefScope : AmlParserNode
        {
            public NameString nameString;
            public TermObj[] termList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefScope(out DefScope result, ref int offset)
        {
            int offset2 = offset;
            result = new DefScope();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ScopeOp) {
                return Failure;
            }

            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseNameString(out result.nameString, ref offset2) == Failure) {
                return Failure;
            }

            AbsoluteNodePath oldNodePath = currentNodePath;
            if (acpiNamespace != null) {
                currentNodePath = acpiNamespace.LookupNode(result.nameString.nodePath, currentNodePath).Path;
            }
            if (ParseTermList(out result.termList, ref offset2, endOffset)  == Failure) {
                return Failure;
            }
            currentNodePath = oldNodePath;

            offset = offset2;
            return Success;
        }

        // ScopeOp              := 0x10

        const ByteData ScopeOp = 0x10;

        //
        // Section 18.2.5.2: Named Objects Encoding
        //

        // NamedObj             := DefBankField | DefCreateBitField | DefCreateByteField |
        //                         DefCreateDWordField | DefCreateField |
        //                         DefCreateQWordField | DefCreateWordField |
        //                         DefDataRegion | DefDevice | DefEvent | DefField |
        //                         DefIndexField | DefMethod | DefMutex | DefOpRegion |
        //                         DefPowerRes | DefProcessor | DefThermalZone
        // See AmlParser.csunion

        private ParseSuccess ParseNamedObj(out NamedObj result, ref int offset)
        {
            int offset2 = offset;

            DefBankField defBankField;
            DefCreateBitField defCreateBitField;
            DefCreateByteField defCreateByteField;
            DefCreateDWordField defCreateDWordField;
            DefCreateField defCreateField;
            DefCreateQWordField defCreateQWordField;
            DefCreateWordField defCreateWordField;
            DefDataRegion defDataRegion;
            DefDevice defDevice;
            DefEvent defEvent;
            DefField defField;
            DefIndexField defIndexField;
            DefMethod defMethod;
            DefMutex defMutex;
            DefOpRegion defOpRegion;
            DefPowerRes defPowerRes;
            DefProcessor defProcessor;
            DefThermalZone defThermalZone;
            if (ParseDefBankField(out defBankField, ref offset2) == Success ) {
                result = NamedObj.CreateDefBankField(defBankField);
            }
            else if (ParseDefCreateBitField(out defCreateBitField, ref offset2) == Success ) {
                result = NamedObj.CreateDefCreateBitField(defCreateBitField);
            }
            else if (ParseDefCreateByteField(out defCreateByteField, ref offset2) == Success ) {
                result = NamedObj.CreateDefCreateByteField(defCreateByteField);
            }
            else if (ParseDefCreateDWordField(out defCreateDWordField, ref offset2) == Success ) {
                result = NamedObj.CreateDefCreateDWordField(defCreateDWordField);
            }
            else if (ParseDefCreateField(out defCreateField, ref offset2) == Success ) {
                result = NamedObj.CreateDefCreateField(defCreateField);
            }
            else if (ParseDefCreateQWordField(out defCreateQWordField, ref offset2) == Success ) {
                result = NamedObj.CreateDefCreateQWordField(defCreateQWordField);
            }
            else if (ParseDefCreateWordField(out defCreateWordField, ref offset2) == Success ) {
                result = NamedObj.CreateDefCreateWordField(defCreateWordField);
            }
            else if (ParseDefDataRegion(out defDataRegion, ref offset2) == Success ) {
                result = NamedObj.CreateDefDataRegion(defDataRegion);
            }
            else if (ParseDefDevice(out defDevice, ref offset2) == Success ) {
                result = NamedObj.CreateDefDevice(defDevice);
            }
            else if (ParseDefEvent(out defEvent, ref offset2) == Success ) {
                result = NamedObj.CreateDefEvent(defEvent);
            }
            else if (ParseDefField(out defField, ref offset2) == Success ) {
                result = NamedObj.CreateDefField(defField);
            }
            else if (ParseDefIndexField(out defIndexField, ref offset2) == Success ) {
                result = NamedObj.CreateDefIndexField(defIndexField);
            }
            else if (ParseDefMethod(out defMethod, ref offset2) == Success ) {
                result = NamedObj.CreateDefMethod(defMethod);
            }
            else if (ParseDefMutex(out defMutex, ref offset2) == Success ) {
                result = NamedObj.CreateDefMutex(defMutex);
            }
            else if (ParseDefOpRegion(out defOpRegion, ref offset2) == Success ) {
                result = NamedObj.CreateDefOpRegion(defOpRegion);
            }
            else if (ParseDefPowerRes(out defPowerRes, ref offset2) == Success ) {
                result = NamedObj.CreateDefPowerRes(defPowerRes);
            }
            else if (ParseDefProcessor(out defProcessor, ref offset2) == Success ) {
                result = NamedObj.CreateDefProcessor(defProcessor);
            }
            else if (ParseDefThermalZone(out defThermalZone, ref offset2) == Success) {
                result = NamedObj.CreateDefThermalZone(defThermalZone);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefBankField         := BankFieldOp PkgLength NameString NameString BankValue FieldFlags FieldList

        public class DefBankField : AmlParserNode
        {
            public NameString regionName;
            public NameString bankName;
            public BankValue bankValue;
            public FieldFlags fieldFlags;
            public FieldElement[] fieldList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefBankField(out DefBankField result, ref int offset)
        {
            int offset2 = offset;
            result = new DefBankField();
            if (CheckTwoBytePrefix(BankFieldOp1, BankFieldOp2, ref offset2) == Failure) {
                return Failure;
            }

            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseNameString(out result.regionName, ref offset2) == Failure ||
                ParseNameString(out result.bankName, ref offset2)   == Failure ||
                ParseBankValue (out result.bankValue, ref offset2)  == Failure ||
                ParseFieldFlags(out result.fieldFlags, ref offset2) == Failure ||
                ParseFieldList (out result.fieldList, ref offset2, endOffset) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // BankFieldOp          := ExtOpPrefix 0x87

        const ByteData BankFieldOp1 = ExtOpPrefix;
        const ByteData BankFieldOp2 = 0x87;

        // BankValue            := TermArg => Integer

        public class BankValue : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseBankValue(out BankValue result, ref int offset)
        {
            int offset2 = offset;
            result = new BankValue();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // FieldFlags           := ByteData     // bit 0-3: AccessType
        //                                      //          0 AnyAcc
        //                                      //          1 ByteAcc
        //                                      //          2 WordAcc
        //                                      //          3 DWordAcc
        //                                      //          4 QWordAcc
        //                                      //          5 BufferAcc
        //                                      //          6 Reserved
        //                                      //          7-15 Reserved
        //                                      // bit 4: LockRule
        //                                      //          0 NoLock
        //                                      //          1 Lock
        //                                      // bit 5-6: UpdateRule
        //                                      //          0 Preserve
        //                                      //          1 WriteAsOnes
        //                                      //          2 WriteAsZeros
        //                                      // bit 7: Reserved (must be 0)

        public class FieldFlags : AmlParserNode
        {
            public AccessType accessType;
            public LockRule lockRule;
            public UpdateRule updateRule;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseFieldFlags(out FieldFlags result, ref int offset)
        {
            int offset2 = offset;
            result = new FieldFlags();

            ByteData b = stream.ReadByteData(ref offset2);

            result.accessType = (AccessType)(b & 0xF);
            result.lockRule   = (LockRule)((b >> 4) & 1);
            result.updateRule = (UpdateRule)((b >> 5) & 3);
            if (result.updateRule == UpdateRule.Invalid || ((b >> 7) != 0)) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // FieldList            := Nothing | <FieldElement FieldList>
        // [To make this rule make sense, it needs a length
        //  limit for termination. The rule using it should know this.]

        private class FieldList
        {
            ArrayList list = new ArrayList();

            public void Add(FieldElement fieldElement)
            {
                list.Add(fieldElement);
            }

            public FieldElement[] ToArray()
            {
                return (FieldElement[])list.ToArray(typeof(FieldElement));
            }
        }

        private ParseSuccess ParseFieldList(out FieldElement[] result, ref int offset, int endOffset)
        {
            result = null;
            FieldList fields = new FieldList();
            int offset2 = offset;

            while (offset2 < endOffset) {
                FieldElement fieldElement;
                if (ParseFieldElement(out fieldElement, ref offset2) == Failure) {
                    return Failure;
                }
                fields.Add(fieldElement);
            }
            Debug.Assert(offset2 == endOffset);
            
            result = fields.ToArray();
            offset = offset2;
            return Success;
        }

        // FieldElement         := NamedField | ReservedField | AccessField
        // See AmlParser.csunion

        private ParseSuccess ParseFieldElement(out FieldElement result, ref int offset)
        {
            int offset2 = offset;

            NamedField namedField;
            ReservedField reservedField;
            AccessField accessField;
            if (ParseNamedField(out namedField, ref offset2) == Success) {
                result = FieldElement.CreateNamedField(namedField);
            }
            else if (ParseReservedField(out reservedField, ref offset2) == Success) {
                result = FieldElement.CreateReservedField(reservedField);
            }
            else if (ParseAccessField(out accessField, ref offset2) == Success) {
                result = FieldElement.CreateAccessField(accessField);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // NamedField           := NameSeg PkgLength

        public class NamedField : AmlParserNode
        {
            public NameSeg nameSeg;
            public int bitWidth;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseNamedField(out NamedField result, ref int offset)
        {
            int offset2 = offset;
            result = new NamedField();

            if (ParseNameSeg  (out result.nameSeg,  ref offset2) == Failure ||
                ParsePkgLength(out result.bitWidth, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // ReservedField        := 0x00 PkgLength

        public class ReservedField : AmlParserNode
        {
            public int bitWidth;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseReservedField(out ReservedField result, ref int offset)
        {
            int offset2 = offset;
            result = new ReservedField();

            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != 0x00) {
                return Failure;
            }

            if (ParsePkgLength(out result.bitWidth, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // AccessField          := 0x01 AccessType AccessAttrib

        public class AccessField : AmlParserNode
        {
            public AccessType accessType;
            public AccessAttrib accessAttrib;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseAccessField(out AccessField result, ref int offset)
        {
            int offset2 = offset;
            result = new AccessField();

            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != 0x01) {
                return Failure;
            }

            if (ParseAccessType  (out result.accessType,  ref offset2) == Failure ||
                ParseAccessAttrib(out result.accessAttrib, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // AccessType           := ByteData     // Same as AccessType bits of FieldFlags.

        private ParseSuccess ParseAccessType(out AccessType result, ref int offset)
        {
            result = AccessType.AnyAcc;
            int offset2 = offset;

            ByteData b = stream.ReadByteData(ref offset2);
            if (b > 0xF) {
                return Failure;
            }
            result = (AccessType)b;

            offset = offset2;
            return Success;
        }

        // AccessAttrib         := ByteData     // If AccessType is BufferAcc for the SMB
        //                                      // OpRegion, AccessAttrib can be one of
        //                                      // the following values:
        //                                      //      0x02 SMBQuick
        //                                      //      0x04 SMBSendReceive
        //                                      //      0x06 SMBByte
        //                                      //      0x08 SMBWord
        //                                      //      0x0A SMBBlock
        //                                      //      0x0C SMBProcessCall
        //                                      //      0x0D SMBBlockProcessCall

        private ParseSuccess ParseAccessAttrib(out AcpiObject.AccessAttrib result, ref int offset)
        {
            result = AccessAttrib.SMBNone;
            int offset2 = offset;

            ByteData b = stream.ReadByteData(ref offset2);
            AccessAttrib type = (AccessAttrib)b;
            if (type != AccessAttrib.SMBNone &&
                type != AccessAttrib.SMBQuick &&
                type != AccessAttrib.SMBSendReceive &&
                type != AccessAttrib.SMBByte &&
                type != AccessAttrib.SMBWord &&
                type != AccessAttrib.SMBBlock &&
                type != AccessAttrib.SMBProcessCall &&
                type != AccessAttrib.SMBBlockProcessCall) {
                return Failure;
            }

            result = type;
            offset = offset2;
            return Success;
        }

        // DefCreateBitField    := CreateBitFieldOp SourceBuff BitIndex NameString

        public class DefCreateBitField : AmlParserNode
        {
            public SourceBuff sourceBuff;
            public BitIndex bitIndex;
            public NameString nameString;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefCreateBitField(out DefCreateBitField result, ref int offset)
        {
            int offset2 = offset;
            result = new DefCreateBitField();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != CreateBitFieldOp) {
                return Failure;
            }
            if (ParseSourceBuff(out result.sourceBuff, ref offset2) == Failure ||
                ParseBitIndex  (out result.bitIndex,   ref offset2) == Failure ||
                ParseNameString(out result.nameString, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // CreateBitFieldOp     := 0x8D

        const ByteData CreateBitFieldOp = 0x8D;

        // SourceBuff           := TermArg => Buffer

        public class SourceBuff : AmlParserNode
        {
            public TermArg buffer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseSourceBuff(out SourceBuff result, ref int offset)
        {
            int offset2 = offset;
            result = new SourceBuff();

            if (ParseTermArg(out result.buffer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.buffer, TermArgType.Buffer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // BitIndex             := TermArg => Integer

        public class BitIndex : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseBitIndex(out BitIndex result, ref int offset)
        {
            int offset2 = offset;
            result = new BitIndex();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefCreateByteField   := CreateByteFieldOp SourceBuff ByteIndex NameString

        public class DefCreateByteField : AmlParserNode
        {
            public SourceBuff sourceBuff;
            public ByteIndex byteIndex;
            public NameString nameString;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefCreateByteField(out DefCreateByteField result, ref int offset)
        {
            int offset2 = offset;
            result = new DefCreateByteField();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != CreateByteFieldOp) {
                return Failure;
            }
            if (ParseSourceBuff(out result.sourceBuff, ref offset2) == Failure ||
                ParseByteIndex (out result.byteIndex,  ref offset2) == Failure ||
                ParseNameString(out result.nameString, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // CreateByteFieldOp    := 0x8C

        const ByteData CreateByteFieldOp = 0x8C;

        // ByteIndex            := TermArg => Integer

        public class ByteIndex : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseByteIndex(out ByteIndex result, ref int offset)
        {
            int offset2 = offset;
            result = new ByteIndex();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefCreateDWordField  := CreateDWordFieldOp SourceBuff ByteIndex NameString

        public class DefCreateDWordField : AmlParserNode
        {
            public SourceBuff sourceBuff;
            public ByteIndex byteIndex;
            public NameString nameString;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefCreateDWordField(out DefCreateDWordField result, ref int offset)
        {
            int offset2 = offset;
            result = new DefCreateDWordField();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != CreateDWordFieldOp) {
                return Failure;
            }
            if (ParseSourceBuff(out result.sourceBuff, ref offset2) == Failure ||
                ParseByteIndex (out result.byteIndex,  ref offset2) == Failure ||
                ParseNameString(out result.nameString, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // CreateDWordFieldOp   := 0x8A

        const ByteData CreateDWordFieldOp = 0x8A;

        // DefCreateField       := CreateFieldOp SourceBuff BitIndex NumBits NameString

        public class DefCreateField : AmlParserNode
        {
            public SourceBuff sourceBuff;
            public BitIndex bitIndex;
            public NumBits numBits;
            public NameString nameString;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefCreateField(out DefCreateField result, ref int offset)
        {
            int offset2 = offset;
            result = new DefCreateField();

            if (CheckTwoBytePrefix(CreateFieldOp1, CreateFieldOp2, ref offset2) == Failure) {
                return Failure;
            }
            if (ParseSourceBuff(out result.sourceBuff, ref offset2) == Failure ||
                ParseBitIndex  (out result.bitIndex,   ref offset2) == Failure ||
                ParseNumBits   (out result.numBits,    ref offset2) == Failure ||
                ParseNameString(out result.nameString, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // CreateFieldOp        := ExtOpPrefix 0x13

        const ByteData CreateFieldOp1 = ExtOpPrefix;
        const ByteData CreateFieldOp2 = 0x13;

        // NumBits              := TermArg => Integer

        public class NumBits : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseNumBits(out NumBits result, ref int offset)
        {
            int offset2 = offset;
            result = new NumBits();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefCreateQWordField  := CreateQWordFieldOp SourceBuff ByteIndex NameString

        public class DefCreateQWordField : AmlParserNode
        {
            public SourceBuff sourceBuff;
            public ByteIndex byteIndex;
            public NameString nameString;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefCreateQWordField(out DefCreateQWordField result, ref int offset)
        {
            int offset2 = offset;
            result = new DefCreateQWordField();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != CreateQWordFieldOp) {
                return Failure;
            }
            if (ParseSourceBuff(out result.sourceBuff, ref offset2) == Failure ||
                ParseByteIndex (out result.byteIndex,  ref offset2) == Failure ||
                ParseNameString(out result.nameString, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // CreateQWordFieldOp   := 0x8F

        const ByteData CreateQWordFieldOp = 0x8F;

        // DefCreateWordField   := CreateWordFieldOp SourceBuff ByteIndex NameString

        public class DefCreateWordField : AmlParserNode
        {
            public SourceBuff sourceBuff;
            public ByteIndex byteIndex;
            public NameString nameString;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefCreateWordField(out DefCreateWordField result, ref int offset)
        {
            int offset2 = offset;
            result = new DefCreateWordField();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != CreateWordFieldOp) {
                return Failure;
            }
            if (ParseSourceBuff(out result.sourceBuff, ref offset2) == Failure ||
                ParseByteIndex (out result.byteIndex,  ref offset2) == Failure ||
                ParseNameString(out result.nameString, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // CreateWordFieldOp    := 0x8B

        const ByteData CreateWordFieldOp = 0x8B;

        // DefDataRegion        := DataRegionOp NameString TermArg TermArg TermArg

        public class DefDataRegion : AmlParserNode
        {
            public NameString nameString;
            public TermArg signatureString;
            public TermArg oemIDString;
            public TermArg oemTableIDString;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefDataRegion(out DefDataRegion result, ref int offset)
        {
            int offset2 = offset;
            result = new DefDataRegion();
            if (CheckTwoBytePrefix(DataRegionOp1, DataRegionOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseNameString(out result.nameString,      ref offset2) == Failure ||
                ParseTermArg   (out result.signatureString,  ref offset2) == Failure ||
                ParseTermArg   (out result.oemIDString,      ref offset2) == Failure ||
                ParseTermArg   (out result.oemTableIDString, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // DataRegionOp         := ExtOpPrefix 0x88

        const ByteData DataRegionOp1 = ExtOpPrefix;
        const ByteData DataRegionOp2 = 0x88;
        
        // DefDevice            := DeviceOp PkgLength NameString AmlObjectList

        public class DefDevice : AmlParserNode
        {
            public NameString nameString;
            public AmlObject[] amlObjectList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefDevice(out DefDevice result, ref int offset)
        {
            int offset2 = offset;
            result = new DefDevice();
            if (CheckTwoBytePrefix(DeviceOp1, DeviceOp2, ref offset2) == Failure) {
                return Failure;
            }

            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }
           
            if (ParseNameString   (out result.nameString,   ref offset2) == Failure) {
                return Failure;
            }

            AbsoluteNodePath oldNodePath = currentNodePath;
            if (acpiNamespace != null) {
                currentNodePath = acpiNamespace.LookupNode(result.nameString.nodePath, currentNodePath).Path;
            }
            if (ParseAmlObjectList(out result.amlObjectList, ref offset2, endOffset) == Failure) {
                return Failure;
            }
            currentNodePath = oldNodePath;

            offset = offset2;
            return Success;
        }
        
        // DeviceOp             := ExtOpPrefix 0x82

        const ByteData DeviceOp1 = ExtOpPrefix;
        const ByteData DeviceOp2 = 0x82;

        // DefEvent             := EventOp NameString

        public class DefEvent : AmlParserNode
        {
            public NameString nameString;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefEvent(out DefEvent result, ref int offset)
        {
            int offset2 = offset;
            result = new DefEvent();
            if (CheckTwoBytePrefix(EventOp1, EventOp2, ref offset2) == Failure) {
                return Failure;
            }
           
            if (ParseNameString(out result.nameString, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // EventOp              := ExtOpPrefix 0x02

        const ByteData EventOp1 = ExtOpPrefix;
        const ByteData EventOp2 = 0x02;

        // DefField             := FieldOp PkgLength NameString FieldFlags FieldList

        public class DefField : AmlParserNode
        {
            public NameString nameString;
            public FieldFlags fieldFlags;
            public FieldElement[] fieldList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefField(out DefField result, ref int offset)
        {
            int offset2 = offset;
            result = new DefField();
            if (CheckTwoBytePrefix(FieldOp1, FieldOp2, ref offset2) == Failure) {
                return Failure;
            }
           
            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }
           
            if (ParseNameString(out result.nameString, ref offset2) == Failure ||
                ParseFieldFlags(out result.fieldFlags, ref offset2) == Failure ||
                ParseFieldList (out result.fieldList,  ref offset2, endOffset) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // FieldOp              := ExtOpPrefix 0x81

        const ByteData FieldOp1 = ExtOpPrefix;
        const ByteData FieldOp2 = 0x81;

        // DefIndexField        := IndexFieldOp PkgLength NameString NameString FieldFlags FieldList
        
        public class DefIndexField : AmlParserNode
        {
            public NameString indexName;
            public NameString dataName;
            public FieldFlags fieldFlags;
            public FieldElement[] fieldList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefIndexField(out DefIndexField result, ref int offset)
        {
            int offset2 = offset;
            result = new DefIndexField();
            if (CheckTwoBytePrefix(IndexFieldOp1, IndexFieldOp2, ref offset2) == Failure) {
                return Failure;
            }
           
            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }
           
            if (ParseNameString(out result.indexName, ref offset2) == Failure ||
                ParseNameString(out result.dataName,   ref offset2) == Failure ||
                ParseFieldFlags(out result.fieldFlags, ref offset2) == Failure ||
                ParseFieldList (out result.fieldList,  ref offset2, endOffset) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // IndexFieldOp         := ExtOpPrefix 0x86

        const ByteData IndexFieldOp1 = ExtOpPrefix;
        const ByteData IndexFieldOp2 = 0x86;

        // DefMethod            := MethodOp PkgLength NameString MethodFlags TermList
        
        public class DefMethod : AmlParserNode
        {
            public NameString nameString;
            public MethodFlags methodFlags;
            public byte[] unparsedTermList;
            public TermObj[] termList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefMethod(out DefMethod result, ref int offset)
        {
            int offset2 = offset;
            result = null;
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != MethodOp) {
                return Failure;
            }
           
            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }

            NameString nameString;
            MethodFlags methodFlags;

            if (ParseNameString (out nameString, ref offset2) == Failure ||
                ParseMethodFlags(out methodFlags, ref offset2) == Failure) {
                return Failure;
            }

            result = new DefMethod();
            result.nameString = nameString;
            result.methodFlags = methodFlags;

            // We defer processing of the method body until later when all argument info is
            // known about methods that it might invoke.
            result.unparsedTermList = stream.ReadByteDataArray(ref offset2, endOffset - offset2);

            offset = offset2;
            return Success;
        }
        
        // MethodOp             := 0x14

        const ByteData MethodOp = 0x14;

        // MethodFlags          := ByteData       // bit 0-2:    ArgCount (0-7)
        //                                        // bit 3:      SerializeFlag
        //                                        //             0 NotSerialized
        //                                        //             1 Serialized
        //                                        // bit 4-7:    SyncLevel (0x00-0x0f)

        public class MethodFlags : AmlParserNode
        {
            public ByteData argCount;
            public SerializeFlag serializeFlag;
            public ByteData syncLevel;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseMethodFlags(out MethodFlags result, ref int offset)
        {
            int offset2 = offset;
            result = new MethodFlags();
            ByteData b = stream.ReadByteData(ref offset2);

            result.argCount = (byte)(b & 7);
            result.serializeFlag = (SerializeFlag)((b >> 3) & 1);
            result.syncLevel = (byte)(b >> 4);

            offset = offset2;
            return Success;
        }

        // DefMutex             := MutexOp NameString SyncFlags
        
        public class DefMutex : AmlParserNode
        {
            public NameString nameString;
            public SyncFlags syncFlags;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefMutex(out DefMutex result, ref int offset)
        {
            int offset2 = offset;
            result = new DefMutex();
            if (CheckTwoBytePrefix(MutexOp1, MutexOp2, ref offset2) == Failure) {
                return Failure;
            }
           
            if (ParseNameString(out result.nameString, ref offset2) == Failure ||
                ParseSyncFlags (out result.syncFlags,  ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // MutexOp              := ExtOpPrefix 0x01

        const ByteData MutexOp1 = ExtOpPrefix;
        const ByteData MutexOp2 = 0x01;

        // SyncFlags            := ByteData       // bit 0-3: SyncLevel (0x00-0x0f)
        //                                        // bit 4-7: Reserved (must be 0)

        public class SyncFlags : AmlParserNode
        {
            public ByteData syncLevel;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseSyncFlags(out SyncFlags result, ref int offset)
        {
            int offset2 = offset;
            result = new SyncFlags();
            ByteData b = stream.ReadByteData(ref offset2);

            if ((b >> 4) != 0) {
                return Failure;
            }
            result.syncLevel = (byte)(b & 0x0F);

            offset = offset2;
            return Success;
        }

        // DefOpRegion          := OpRegionOp NameString RegionSpace RegionOffset RegionLen
        
        public class DefOpRegion : AmlParserNode
        {
            public NameString   nameString;
            public RegionSpace  regionSpace;
            public RegionOffset regionOffset;
            public RegionLen    regionLen;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefOpRegion(out DefOpRegion result, ref int offset)
        {
            int offset2 = offset;
            result = new DefOpRegion();
            if (CheckTwoBytePrefix(OpRegionOp1, OpRegionOp2, ref offset2) == Failure) {
                return Failure;
            }
           
            if (ParseNameString  (out result.nameString,  ref offset2) == Failure ||
                ParseRegionSpace (out result.regionSpace,  ref offset2) == Failure ||
                ParseRegionOffset(out result.regionOffset, ref offset2) == Failure ||
                ParseRegionLen   (out result.regionLen,    ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // OpRegionOp           := ExtOpPrefix 0x80

        const ByteData OpRegionOp1 = ExtOpPrefix;
        const ByteData OpRegionOp2 = 0x80;

        // RegionSpace          := ByteData       // 0x00 SystemMemory
        //                                        // 0x01 SystemIO
        //                                        // 0x02 PCI_Config
        //                                        // 0x03 EmbeddedControl
        //                                        // 0x04 SMBus
        //                                        // 0x05 CMOS
        //                                        // 0x06 PciBarTarget
        //                                        // 0x80-0xFF: User Defined

        public class RegionSpace : AmlParserNode
        {
            public ByteData byteData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseRegionSpace(out RegionSpace result, ref int offset)
        {
            int offset2 = offset;
            result = new RegionSpace();
            result.byteData = stream.ReadByteData(ref offset2);
            offset = offset2;
            return Success;
        }

        // RegionOffset         := TermArg => Integer

        public class RegionOffset : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseRegionOffset(out RegionOffset result, ref int offset)
        {
            int offset2 = offset;
            result = new RegionOffset();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // RegionLen            := TermArg => Integer

        public class RegionLen : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseRegionLen(out RegionLen result, ref int offset)
        {
            int offset2 = offset;
            result = new RegionLen();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // DefPowerRes          := PowerResOp PkgLength NameString SystemLevel ResourceOrder AmlObjectList
        
        public class DefPowerRes : AmlParserNode
        {
            public NameString    nameString;
            public SystemLevel   systemLevel;
            public ResourceOrder resourceOrder;
            public AmlObject[]   amlObjectList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefPowerRes(out DefPowerRes result, ref int offset)
        {
            int offset2 = offset;
            result = new DefPowerRes();
            if (CheckTwoBytePrefix(PowerResOp1, PowerResOp2, ref offset2) == Failure) {
                return Failure;
            }
          
            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }
            
            if (ParseNameString   (out result.nameString,   ref offset2) == Failure) {
                return Failure;
            }

            AbsoluteNodePath oldNodePath = currentNodePath;
            if (acpiNamespace != null) {
                currentNodePath = acpiNamespace.LookupNode(result.nameString.nodePath, currentNodePath).Path;
            }

            if (ParseSystemLevel  (out result.systemLevel,   ref offset2) == Failure ||
                ParseResourceOrder(out result.resourceOrder, ref offset2) == Failure ||
                ParseAmlObjectList(out result.amlObjectList, ref offset2, endOffset) == Failure) {
                return Failure;
            }

            currentNodePath = oldNodePath;

            offset = offset2;
            return Success;
        }
        
        // PowerResOp           := ExtOpPrefix 0x84

        const ByteData PowerResOp1 = ExtOpPrefix;
        const ByteData PowerResOp2 = 0x84;

        // SystemLevel          := ByteData

        public class SystemLevel : AmlParserNode
        {
            public ByteData byteData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseSystemLevel(out SystemLevel result, ref int offset)
        {
            int offset2 = offset;
            result = new SystemLevel();
            result.byteData = stream.ReadByteData(ref offset2);
            offset = offset2;
            return Success;
        }

        // ResourceOrder        := WordData
 
        public class ResourceOrder : AmlParserNode
        {
            public WordData wordData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseResourceOrder(out ResourceOrder result, ref int offset)
        {
            int offset2 = offset;
            result = new ResourceOrder();
            result.wordData = stream.ReadWordData(ref offset2);
            offset = offset2;
            return Success;
        }

        // DefProcessor         := ProcessorOp PkgLength NameString ProcID PblkAddr PblkLen AmlObjectList
        
        public class DefProcessor : AmlParserNode
        {
            public NameString  nameString;
            public ProcID      procID;
            public PblkAddr    pblkAddr;
            public PblkLen     pblkLen;
            public AmlObject[] amlObjectList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefProcessor(out DefProcessor result, ref int offset)
        {
            int offset2 = offset;
            result = new DefProcessor();
            if (CheckTwoBytePrefix(ProcessorOp1, ProcessorOp2, ref offset2) == Failure) {
                return Failure;
            }
          
            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }
            
            if (ParseNameString   (out result.nameString,   ref offset2) == Failure) {
                return Failure;
            }

            AbsoluteNodePath oldNodePath = currentNodePath;
            if (acpiNamespace != null) {
                currentNodePath = acpiNamespace.LookupNode(result.nameString.nodePath, currentNodePath).Path;
            }

            if (ParseProcID       (out result.procID,        ref offset2) == Failure ||
                ParsePblkAddr     (out result.pblkAddr,      ref offset2) == Failure ||
                ParsePblkLen      (out result.pblkLen,       ref offset2) == Failure ||
                ParseAmlObjectList(out result.amlObjectList, ref offset2, endOffset) == Failure) {
                return Failure;
            }

            currentNodePath = oldNodePath;

            offset = offset2;
            return Success;
        }

        // ProcessorOp          := ExtOpPrefix 0x83

        const ByteData ProcessorOp1 = ExtOpPrefix;
        const ByteData ProcessorOp2 = 0x83;

        // ProcID               := ByteData

        public class ProcID : AmlParserNode
        {
            public ByteData byteData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseProcID(out ProcID result, ref int offset)
        {
            int offset2 = offset;
            result = new ProcID();
            result.byteData = stream.ReadByteData(ref offset2);
            offset = offset2;
            return Success;
        }

        // PblkAddr             := DWordData

        public class PblkAddr : AmlParserNode
        {
            public DWordData dWordData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParsePblkAddr(out PblkAddr result, ref int offset)
        {
            int offset2 = offset;
            result = new PblkAddr();
            result.dWordData = stream.ReadDWordData(ref offset2);
            offset = offset2;
            return Success;
        }

        // PblkLen              := ByteData

        public class PblkLen : AmlParserNode
        {
            public ByteData byteData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParsePblkLen(out PblkLen result, ref int offset)
        {
            int offset2 = offset;
            result = new PblkLen();
            result.byteData = stream.ReadByteData(ref offset2);
            offset = offset2;
            return Success;
        }

        // DefThermalZone       := ThermalZoneOp PkgLength NameString AmlObjectList
        
        public class DefThermalZone : AmlParserNode
        {
            public NameString  nameString;
            public AmlObject[] amlObjectList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefThermalZone(out DefThermalZone result, ref int offset)
        {
            int offset2 = offset;
            result = new DefThermalZone();
            if (CheckTwoBytePrefix(ThermalZoneOp1, ThermalZoneOp2, ref offset2) == Failure) {
                return Failure;
            }
          
            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }
            
            if (ParseNameString   (out result.nameString,   ref offset2) == Failure) {
                return Failure;
            }

            AbsoluteNodePath oldNodePath = currentNodePath;
            if (acpiNamespace != null) {
                currentNodePath = acpiNamespace.LookupNode(result.nameString.nodePath, currentNodePath).Path;
            }

            if (ParseAmlObjectList(out result.amlObjectList, ref offset2, endOffset) == Failure) {
                return Failure;
            }

            currentNodePath = oldNodePath;

            offset = offset2;
            return Success;
        }

        // ThermalZoneOp        := ExtOpPrefix 0x85

        const ByteData ThermalZoneOp1 = ExtOpPrefix;
        const ByteData ThermalZoneOp2 = 0x85;

        // 18.2.5.3 Type 1 Opcodes Encoding

        // [Type 1 opcodes involve mainly control flow and some high-level operations.
        //  They are only found inside methods.]
        // Type1Opcode          := DefBreak | DefBreakPoint | DefContinue | DefFatal |
        //                         DefIfElse | DefLoad | DefNoop | DefNotify | 
        //                         DefRelease | DefReset | DefReturn | DefSignal |
        //                         DefSleep | DefStall | DefUnload | DefWhile
        // See AmlParser.csunion

        private ParseSuccess ParseType1Opcode(out Type1Opcode result, ref int offset, int endOffset)
        {
            int offset2 = offset;

            DefBreak      defBreak;
            DefBreakPoint defBreakPoint;
            DefContinue   defContinue;
            DefFatal      defFatal;
            DefIfElse     defIfElse;
            DefLoad       defLoad;
            DefNoop       defNoop;
            DefNotify     defNotify;
            DefRelease    defRelease;
            DefReset      defReset;
            DefReturn     defReturn;
            DefSignal     defSignal;
            DefSleep      defSleep;
            DefStall      defStall;
            DefUnload     defUnload;
            DefWhile      defWhile;
            if (ParseDefBreak     (out defBreak,     ref offset2) == Success) {
                result = Type1Opcode.CreateDefBreak(defBreak);
            }
            else if (ParseDefBreakPoint(out defBreakPoint, ref offset2) == Success) {
                result = Type1Opcode.CreateDefBreakPoint(defBreakPoint);
            }
            else if (ParseDefContinue  (out defContinue,   ref offset2) == Success) {
                result = Type1Opcode.CreateDefContinue(defContinue);
            }
            else if (ParseDefFatal     (out defFatal,      ref offset2) == Success) {
                result = Type1Opcode.CreateDefFatal(defFatal);
            }
            else if (ParseDefIfElse    (out defIfElse,     ref offset2, endOffset) == Success) {
                result = Type1Opcode.CreateDefIfElse(defIfElse);
            }
            else if (ParseDefLoad      (out defLoad,       ref offset2) == Success) {
                result = Type1Opcode.CreateDefLoad(defLoad);
            }
            else if (ParseDefNoop      (out defNoop,       ref offset2) == Success) {
                result = Type1Opcode.CreateDefNoop(defNoop);
            }
            else if (ParseDefNotify    (out defNotify,     ref offset2) == Success) {
                result = Type1Opcode.CreateDefNotify(defNotify);
            }
            else if (ParseDefRelease   (out defRelease,    ref offset2) == Success) {
                result = Type1Opcode.CreateDefRelease(defRelease);
            }
            else if (ParseDefReset     (out defReset,      ref offset2) == Success) {
                result = Type1Opcode.CreateDefReset(defReset);
            }
            else if (ParseDefReturn    (out defReturn,     ref offset2) == Success) {
                result = Type1Opcode.CreateDefReturn(defReturn);
            }
            else if (ParseDefSignal    (out defSignal,     ref offset2) == Success) {
                result = Type1Opcode.CreateDefSignal(defSignal);
            }
            else if (ParseDefSleep     (out defSleep,      ref offset2) == Success) {
                result = Type1Opcode.CreateDefSleep(defSleep);
            }
            else if (ParseDefStall     (out defStall,      ref offset2) == Success) {
                result = Type1Opcode.CreateDefStall(defStall);
            }
            else if (ParseDefUnload    (out defUnload,     ref offset2) == Success) {
                result = Type1Opcode.CreateDefUnload(defUnload);
            }
            else if (ParseDefWhile     (out defWhile,      ref offset2) == Success) {
                result = Type1Opcode.CreateDefWhile(defWhile);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefBreak             := BreakOp

        public class DefBreak : AmlParserNode
        {
            // No data
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefBreak(out DefBreak result, ref int offset)
        {
            int offset2 = offset;
            result = new DefBreak();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != BreakOp) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // BreakOp              := 0xA5

        const ByteData BreakOp = 0xA5;

        // DefBreakPoint        := BreakPointOp

        public class DefBreakPoint : AmlParserNode
        {
            // No data
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefBreakPoint(out DefBreakPoint result, ref int offset)
        {
            int offset2 = offset;
            result = new DefBreakPoint();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != BreakPointOp) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // BreakPointOp         := 0xCC

        const ByteData BreakPointOp = 0xCC;

        // DefContinue          := ContinueOp

        public class DefContinue : AmlParserNode
        {
            // No data
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefContinue(out DefContinue result, ref int offset)
        {
            int offset2 = offset;
            result = new DefContinue();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ContinueOp) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
 
        // ContinueOp           := 0x9F

        const ByteData ContinueOp = 0x9F;

        // DefElse              := Nothing | <ElseOp PkgLength TermList>

        public class DefElse : AmlParserNode
        {
            public TermObj[] termList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefElse(out DefElse result, ref int offset, int endOffset)
        {
            int offset2 = offset;
            result = new DefElse();
            ByteData prefix;

            if (offset >= endOffset) {
                return Success; // Empty else clause
            }
            if (!stream.TryReadByteData(ref offset2, out prefix)) {
                return Success; // Sometimes an if with no else is at the end of the stream
            }
            if (prefix != ElseOp) {
                result.termList = null;
                return Success;
            }

            int endOffsetBody;
            if (ParsePkgLengthEndOffset(out endOffsetBody, ref offset2) == Failure) {
                return Failure;
            }
            
            if (ParseTermList(out result.termList, ref offset2, endOffsetBody) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
         
        // ElseOp               := 0xA1

        const ByteData ElseOp = 0xA1;

        // DefFatal             := FatalOp FatalType FatalCode FatalArg

        public class DefFatal : AmlParserNode
        {
            public FatalType fatalType;
            public FatalCode fatalCode;
            public FatalArg  fatalArg;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefFatal(out DefFatal result, ref int offset)
        {
            int offset2 = offset;
            result = new DefFatal();
            if (CheckTwoBytePrefix(FatalOp1, FatalOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseFatalType(out result.fatalType, ref offset2) == Failure ||
                ParseFatalCode(out result.fatalCode, ref offset2) == Failure ||
                ParseFatalArg (out result.fatalArg,  ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // FatalOp              := ExtOpPrefix 0x32

        const ByteData FatalOp1 = ExtOpPrefix;
        const ByteData FatalOp2 = 0x32;

        // FatalType            := ByteData

        public class FatalType : AmlParserNode
        {
            public ByteData byteData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseFatalType(out FatalType result, ref int offset)
        {
            int offset2 = offset;
            result = new FatalType();
            result.byteData = stream.ReadByteData(ref offset2);
            offset = offset2;
            return Success;
        }

        // FatalCode            := DWordData

        public class FatalCode : AmlParserNode
        {
            public DWordData dWordData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseFatalCode(out FatalCode result, ref int offset)
        {
            int offset2 = offset;
            result = new FatalCode();
            result.dWordData = stream.ReadDWordData(ref offset2);
            offset = offset2;
            return Success;
        }

        // FatalArg             := TermArg => Integer

        public class FatalArg : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseFatalArg(out FatalArg result, ref int offset)
        {
            int offset2 = offset;
            result = new FatalArg();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // DefIfElse            := IfOp PkgLength Predicate TermList DefElse

        public class DefIfElse : AmlParserNode
        {
            public Predicate predicate;
            public TermObj[] termList;
            public DefElse defElse;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefIfElse(out DefIfElse result, ref int offset, int endOffset)
        {
            int offset2 = offset;
            result = new DefIfElse();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != IfOp) {
                return Failure;
            }

            int endOffsetThen;
            if (ParsePkgLengthEndOffset(out endOffsetThen, ref offset2) == Failure) {
                return Failure;
            }
            
            // Investigation of ASL compiler output reveals that the PkgLength in this
            // rule includes the if body but not the else clause, which is fortunate
            // since otherwise ambiguities would arise.
            if (ParsePredicate(out result.predicate, ref offset2) == Failure ||
                ParseTermList(out result.termList, ref offset2, endOffsetThen) == Failure ||
                ParseDefElse(out result.defElse, ref offset2, endOffset) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // IfOp                 := 0xA0

        const ByteData IfOp = 0xA0;

        // Predicate            := TermArg => Integer

        public class Predicate : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParsePredicate(out Predicate result, ref int offset)
        {
            int offset2 = offset;
            result = new Predicate();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefLoad              := LoadOp NameString DDBHandleObject

        public class DefLoad : AmlParserNode
        {
            public NameString nameString;
            public DDBHandleObject ddbHandleObject;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLoad(out DefLoad result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLoad();
            if (CheckTwoBytePrefix(LoadOp1, LoadOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseNameString     (out result.nameString,     ref offset2) == Failure ||
                ParseDDBHandleObject(out result.ddbHandleObject, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // LoadOp               := ExtOpPrefix 0x20

        const ByteData LoadOp1 = ExtOpPrefix;
        const ByteData LoadOp2 = 0x20;

        // DDBHandleObject      := SuperName

        public class DDBHandleObject : AmlParserNode
        {
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDDBHandleObject(out DDBHandleObject result, ref int offset)
        {
            int offset2 = offset;
            result = new DDBHandleObject();

            if (ParseSuperName(out result.superName, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefNoop              := NoopOp

        public class DefNoop : AmlParserNode
        {
            // No data
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefNoop(out DefNoop result, ref int offset)
        {
            int offset2 = offset;
            result = new DefNoop();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != NoopOp) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // NoopOp               := 0xA3

        const ByteData NoopOp = 0xA3;

        // DefNotify            := NotifyOp NotifyObject NotifyValue

        public class DefNotify : AmlParserNode
        {
            public NotifyObject notifyObject;
            public NotifyValue notifyValue;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefNotify(out DefNotify result, ref int offset)
        {
            int offset2 = offset;
            result = new DefNotify();

            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != NotifyOp) {
                return Failure;
            }

            if (ParseNotifyObject(out result.notifyObject, ref offset2) == Failure ||
                ParseNotifyValue (out result.notifyValue,  ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // NotifyOp             := 0x86

        const ByteData NotifyOp = 0x86;

        // NotifyObject         := SuperName => ThermalZone | Processor | Device

        public class NotifyObject : AmlParserNode
        {
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseNotifyObject(out NotifyObject result, ref int offset)
        {
            int offset2 = offset;
            result = new NotifyObject();

            if (ParseSuperName(out result.superName, ref offset2) == Failure /*||
                (!SuperNameEvaluatesTo(result.superName, SuperNameType.ThermalZone) &&
                 !SuperNameEvaluatesTo(result.superName, SuperNameType.Processor) &&
                 !SuperNameEvaluatesTo(result.superName, SuperNameType.Device)) */) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // NotifyValue          := TermArg => Integer

        public class NotifyValue : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseNotifyValue(out NotifyValue result, ref int offset)
        {
            int offset2 = offset;
            result = new NotifyValue();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // DefRelease           := ReleaseOp MutexObject

        public class DefRelease : AmlParserNode
        {
            public MutexObject mutexObject;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefRelease(out DefRelease result, ref int offset)
        {
            int offset2 = offset;
            result = new DefRelease();

            if (CheckTwoBytePrefix(ReleaseOp1, ReleaseOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseMutexObject(out result.mutexObject, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // ReleaseOp            := ExtOpPrefix 0x27

        const ByteData ReleaseOp1 = ExtOpPrefix;
        const ByteData ReleaseOp2 = 0x27;

        // MutexObject          := SuperName

        public class MutexObject : AmlParserNode
        {
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseMutexObject(out MutexObject result, ref int offset)
        {
            int offset2 = offset;
            result = new MutexObject();

            if (ParseSuperName(out result.superName, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefReset             := ResetOp EventObject

        public class DefReset : AmlParserNode
        {
            public EventObject eventObject;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefReset(out DefReset result, ref int offset)
        {
            int offset2 = offset;
            result = new DefReset();

            if (CheckTwoBytePrefix(ResetOp1, ResetOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseEventObject(out result.eventObject, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // ResetOp              := ExtOpPrefix 0x26

        const ByteData ResetOp1 = ExtOpPrefix;
        const ByteData ResetOp2 = 0x26;

        // EventObject          := SuperName

        public class EventObject : AmlParserNode
        {
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseEventObject(out EventObject result, ref int offset)
        {
            int offset2 = offset;
            result = new EventObject();

            if (ParseSuperName(out result.superName, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // DefReturn            := ReturnOp ArgObject

        public class DefReturn : AmlParserNode
        {
            public ArgObject argObject;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefReturn(out DefReturn result, ref int offset)
        {
            int offset2 = offset;
            result = new DefReturn();

            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ReturnOp) {
                return Failure;
            }

            if (ParseArgObject(out result.argObject, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // ReturnOp             := 0xA4

        const ByteData ReturnOp = 0xA4;

        // ArgObject            := TermArg => DataRefObject

        public class ArgObject : AmlParserNode
        {
            public TermArg dataRefObject;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseArgObject(out ArgObject result, ref int offset)
        {
            int offset2 = offset;
            result = new ArgObject();

            if (ParseTermArg(out result.dataRefObject, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.dataRefObject, TermArgType.DataRefObject)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefSignal            := SignalOp EventObject

        public class DefSignal : AmlParserNode
        {
            public EventObject eventObject;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefSignal(out DefSignal result, ref int offset)
        {
            int offset2 = offset;
            result = new DefSignal();

            if (CheckTwoBytePrefix(SignalOp1, SignalOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseEventObject(out result.eventObject, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // SignalOp             := ExtOpPrefix 0x24

        const ByteData SignalOp1 = ExtOpPrefix;
        const ByteData SignalOp2 = 0x24;

        // DefSleep             := SleepOp MsecTime

        public class DefSleep : AmlParserNode
        {
            public MsecTime msecTime;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefSleep(out DefSleep result, ref int offset)
        {
            int offset2 = offset;
            result = new DefSleep();

            if (CheckTwoBytePrefix(SleepOp1, SleepOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseMsecTime(out result.msecTime, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // SleepOp              := ExtOpPrefix 0x22

        const ByteData SleepOp1 = ExtOpPrefix;
        const ByteData SleepOp2 = 0x22;

        // MsecTime             := TermArg => Integer

        public class MsecTime : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseMsecTime(out MsecTime result, ref int offset)
        {
            int offset2 = offset;
            result = new MsecTime();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefStall             := StallOp UsecTime

        public class DefStall : AmlParserNode
        {
            public UsecTime usecTime;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefStall(out DefStall result, ref int offset)
        {
            int offset2 = offset;
            result = new DefStall();

            if (CheckTwoBytePrefix(StallOp1, StallOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseUsecTime(out result.usecTime, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
        
        // StallOp              := ExtOpPrefix 0x21

        const ByteData StallOp1 = ExtOpPrefix;
        const ByteData StallOp2 = 0x21;

        // UsecTime             := TermArg => ByteData

        public class UsecTime : AmlParserNode
        {
            public TermArg byteData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseUsecTime(out UsecTime result, ref int offset)
        {
            int offset2 = offset;
            result = new UsecTime();

            if (ParseTermArg(out result.byteData, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.byteData, TermArgType.ByteData)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefUnload            := UnloadOp DDBHandleObject

        public class DefUnload : AmlParserNode
        {
            public DDBHandleObject ddbHandleObject;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefUnload(out DefUnload result, ref int offset)
        {
            int offset2 = offset;
            result = new DefUnload();
            if (CheckTwoBytePrefix(UnloadOp1, UnloadOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseDDBHandleObject(out result.ddbHandleObject, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // UnloadOp             := ExtOpPrefix 0x2A

        const ByteData UnloadOp1 = ExtOpPrefix;
        const ByteData UnloadOp2 = 0x2A;

        // DefWhile             := WhileOp PkgLength Predicate TermList

        public class DefWhile : AmlParserNode
        {
            public Predicate predicate;
            public TermObj[] termList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefWhile(out DefWhile result, ref int offset)
        {
            int offset2 = offset;
            result = new DefWhile();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != WhileOp) {
                return Failure;
            }

            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }
            
            if (ParsePredicate(out result.predicate, ref offset2) == Failure ||
                ParseTermList (out result.termList,  ref offset2, endOffset) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // WhileOp              := 0xA2

        const ByteData WhileOp = 0xA2;

        // 18.2.5.4 Type 2 Opcodes Encoding

        // [Type 2 opcodes primarily manipulate primitive values (arithmetic, comparison,
        //  etc.) and can also refer to objects through UserTermObj. They are only found
        //  inside methods.]
        // Type2Opcode          := DefAcquire | DefAdd | DefAnd | DefBuffer |
        //                         DefConcat | DefConcatRes | DefCondRefOf |
        //                         DefCopyObject | DefDecrement | DefDerefOf |
        //                         DefDivide | DefFindSetLeftBit | DefFindSetRightBit |
        //                         DefFromBCD | DefIncrement | DefIndex | DefLAnd |
        //                         DefLEqual | DefLGreater | DefLGreaterEqual |
        //                         DefLLess | DefLLessEqual | DefMid | DefLNot |
        //                         DefLNotEqual | DefLoadTable | DefLOr | DefMatch |
        //                         DefMod | DefMultiply | DefNAnd | DefNOr | DefNot |
        //                         DefObjectType | DefOr | DefPackage | DefVarPackage |
        //                         DefRefOf | DefShiftLeft | DefShiftRight | DefSizeOf |
        //                         DefStore | DefSubtract | DefTimer | DefToBCD |
        //                         DefToBuffer | DefToDecimalString | DefToHexString |
        //                         DefToInteger | DefToString | DefWait | DefXOr |
        //                         UserTermObj
        // See AmlParser.csunion

        private ParseSuccess ParseType2Opcode(out Type2Opcode result, ref int offset)
        {
            int offset2 = offset;

            DefAcquire defAcquire;
            DefAdd defAdd;
            DefAnd defAnd;
            DefBuffer defBuffer;
            DefConcat defConcat;
            DefConcatRes defConcatRes;
            DefCondRefOf defCondRefOf;
            DefCopyObject defCopyObject;
            DefDecrement defDecrement;
            DefDerefOf defDerefOf;
            DefDivide defDivide;
            DefFindSetLeftBit defFindSetLeftBit;
            DefFindSetRightBit defFindSetRightBit;
            DefFromBCD defFromBCD;
            DefIncrement defIncrement;
            DefIndex defIndex;
            DefLAnd defLAnd;
            DefLEqual defLEqual;
            DefLGreater defLGreater;
            DefLGreaterEqual defLGreaterEqual;
            DefLLess defLLess;
            DefLLessEqual defLLessEqual;
            DefMid defMid;
            DefLNot defLNot;
            DefLNotEqual defLNotEqual;
            DefLoadTable defLoadTable;
            DefLOr defLOr;
            DefMatch defMatch;
            DefMod defMod;
            DefMultiply defMultiply;
            DefNAnd defNAnd;
            DefNOr defNOr;
            DefNot defNot;
            DefObjectType defObjectType;
            DefOr defOr;
            DefPackage defPackage;
            DefVarPackage defVarPackage;
            DefRefOf defRefOf;
            DefShiftLeft defShiftLeft;
            DefShiftRight defShiftRight;
            DefSizeOf defSizeOf;
            DefStore defStore;
            DefSubtract defSubtract;
            DefTimer defTimer;
            DefToBCD defToBCD;
            DefToBuffer defToBuffer;
            DefToDecimalString defToDecimalString;
            DefToHexString defToHexString;
            DefToInteger defToInteger;
            DefToString defToString;
            DefWait defWait;
            DefXOr defXOr;
            UserTermObj userTermObj;

            if (ParseDefAcquire             (out defAcquire,         ref offset2) == Success) {
                result = Type2Opcode.CreateDefAcquire(defAcquire);                
            }
            else if (ParseDefAdd            (out defAdd,             ref offset2) == Success) {
                result = Type2Opcode.CreateDefAdd(defAdd);
            }
            else if (ParseDefAnd            (out defAnd,             ref offset2) == Success) {
                result = Type2Opcode.CreateDefAnd(defAnd);
            }
            else if (ParseDefBuffer         (out defBuffer,          ref offset2) == Success) {
                result = Type2Opcode.CreateDefBuffer(defBuffer);
            }
            else if (ParseDefConcat         (out defConcat,          ref offset2) == Success) {
                result = Type2Opcode.CreateDefConcat(defConcat);
            }
            else if (ParseDefConcatRes      (out defConcatRes,       ref offset2) == Success) {
                result = Type2Opcode.CreateDefConcatRes(defConcatRes);
            }
            else if (ParseDefCondRefOf      (out defCondRefOf,       ref offset2) == Success) {
                result = Type2Opcode.CreateDefCondRefOf(defCondRefOf);
            }
            else if (ParseDefCopyObject     (out defCopyObject,      ref offset2) == Success) {
                result = Type2Opcode.CreateDefCopyObject(defCopyObject);
            }
            else if (ParseDefDecrement      (out defDecrement,       ref offset2) == Success) {
                result = Type2Opcode.CreateDefDecrement(defDecrement);
            }
            else if (ParseDefDerefOf        (out defDerefOf,         ref offset2) == Success) {
                result = Type2Opcode.CreateDefDerefOf(defDerefOf);
            }
            else if (ParseDefDivide         (out defDivide,          ref offset2) == Success) {
                result = Type2Opcode.CreateDefDivide(defDivide);
            }
            else if (ParseDefFindSetLeftBit (out defFindSetLeftBit,  ref offset2) == Success) {
                result = Type2Opcode.CreateDefFindSetLeftBit(defFindSetLeftBit);
            }
            else if (ParseDefFindSetRightBit(out defFindSetRightBit, ref offset2) == Success) {
                result = Type2Opcode.CreateDefFindSetRightBit(defFindSetRightBit);
            }
            else if (ParseDefFromBCD        (out defFromBCD,         ref offset2) == Success) {
                result = Type2Opcode.CreateDefFromBCD(defFromBCD);
            }
            else if (ParseDefIncrement      (out defIncrement,       ref offset2) == Success) {
                result = Type2Opcode.CreateDefIncrement(defIncrement);
            }
            else if (ParseDefIndex          (out defIndex,           ref offset2) == Success) {
                result = Type2Opcode.CreateDefIndex(defIndex);
            }
            else if (ParseDefLAnd           (out defLAnd,            ref offset2) == Success) {
                result = Type2Opcode.CreateDefLAnd(defLAnd);
            }
            else if (ParseDefLEqual         (out defLEqual,          ref offset2) == Success) {
                result = Type2Opcode.CreateDefLEqual(defLEqual);
            }
            else if (ParseDefLGreater       (out defLGreater,        ref offset2) == Success) {
                result = Type2Opcode.CreateDefLGreater(defLGreater);
            }
            else if (ParseDefLGreaterEqual  (out defLGreaterEqual,   ref offset2) == Success) {
                result = Type2Opcode.CreateDefLGreaterEqual(defLGreaterEqual);
            }
            else if (ParseDefLLess          (out defLLess,           ref offset2) == Success) {
                result = Type2Opcode.CreateDefLLess(defLLess);
            }
            else if (ParseDefLLessEqual     (out defLLessEqual,      ref offset2) == Success) {
                result = Type2Opcode.CreateDefLLessEqual(defLLessEqual);
            }
            else if (ParseDefMid            (out defMid,             ref offset2) == Success) {
                result = Type2Opcode.CreateDefMid(defMid);
            }
            else if (ParseDefLNot           (out defLNot,            ref offset2) == Success) {
                result = Type2Opcode.CreateDefLNot(defLNot);
            }
            else if (ParseDefLNotEqual      (out defLNotEqual,       ref offset2) == Success) {
                result = Type2Opcode.CreateDefLNotEqual(defLNotEqual);
            }
            else if (ParseDefLoadTable      (out defLoadTable,       ref offset2) == Success) {
                result = Type2Opcode.CreateDefLoadTable(defLoadTable);
            }
            else if (ParseDefLOr            (out defLOr,             ref offset2) == Success) {
                result = Type2Opcode.CreateDefLOr(defLOr);
            }
            else if (ParseDefMatch          (out defMatch,           ref offset2) == Success) {
                result = Type2Opcode.CreateDefMatch(defMatch);
            }
            else if (ParseDefMod            (out defMod,             ref offset2) == Success) {
                result = Type2Opcode.CreateDefMod(defMod);
            }
            else if (ParseDefMultiply       (out defMultiply,        ref offset2) == Success) {
                result = Type2Opcode.CreateDefMultiply(defMultiply);
            }
            else if (ParseDefNAnd           (out defNAnd,            ref offset2) == Success) {
                result = Type2Opcode.CreateDefNAnd(defNAnd);
            }
            else if (ParseDefNOr            (out defNOr,             ref offset2) == Success) {
                result = Type2Opcode.CreateDefNOr(defNOr);
            }
            else if (ParseDefNot            (out defNot,             ref offset2) == Success) {
                result = Type2Opcode.CreateDefNot(defNot);
            }
            else if (ParseDefObjectType     (out defObjectType,      ref offset2) == Success) {
                result = Type2Opcode.CreateDefObjectType(defObjectType);
            }
            else if (ParseDefOr             (out defOr,              ref offset2) == Success) {
                result = Type2Opcode.CreateDefOr(defOr);
            }
            else if (ParseDefPackage        (out defPackage,         ref offset2) == Success) {
                result = Type2Opcode.CreateDefPackage(defPackage);
            }
            else if (ParseDefVarPackage     (out defVarPackage,      ref offset2) == Success) {
                result = Type2Opcode.CreateDefVarPackage(defVarPackage);
            }
            else if (ParseDefRefOf          (out defRefOf,           ref offset2) == Success) {
                result = Type2Opcode.CreateDefRefOf(defRefOf);
            }
            else if (ParseDefShiftLeft      (out defShiftLeft,       ref offset2) == Success) {
                result = Type2Opcode.CreateDefShiftLeft(defShiftLeft);
            }
            else if (ParseDefShiftRight     (out defShiftRight,      ref offset2) == Success) {
                result = Type2Opcode.CreateDefShiftRight(defShiftRight);
            }
            else if (ParseDefSizeOf         (out defSizeOf,          ref offset2) == Success) {
                result = Type2Opcode.CreateDefSizeOf(defSizeOf);
            }
            else if (ParseDefStore          (out defStore,           ref offset2) == Success) {
                result = Type2Opcode.CreateDefStore(defStore);
            }
            else if (ParseDefSubtract       (out defSubtract,        ref offset2) == Success) {
                result = Type2Opcode.CreateDefSubtract(defSubtract);
            }
            else if (ParseDefTimer          (out defTimer,           ref offset2) == Success) {
                result = Type2Opcode.CreateDefTimer(defTimer);
            }
            else if (ParseDefToBCD          (out defToBCD,           ref offset2) == Success) {
                result = Type2Opcode.CreateDefToBCD(defToBCD);
            }
            else if (ParseDefToBuffer       (out defToBuffer,        ref offset2) == Success) {
                result = Type2Opcode.CreateDefToBuffer(defToBuffer);
            }
            else if (ParseDefToDecimalString(out defToDecimalString, ref offset2) == Success) {
                result = Type2Opcode.CreateDefToDecimalString(defToDecimalString);
            }
            else if (ParseDefToHexString    (out defToHexString,     ref offset2) == Success) {
                result = Type2Opcode.CreateDefToHexString(defToHexString);
            }
            else if (ParseDefToInteger      (out defToInteger,       ref offset2) == Success) {
                result = Type2Opcode.CreateDefToInteger(defToInteger);
            }
            else if (ParseDefToString       (out defToString,        ref offset2) == Success) {
                result = Type2Opcode.CreateDefToString(defToString);
            }
            else if (ParseDefWait           (out defWait,            ref offset2) == Success) {
                result = Type2Opcode.CreateDefWait(defWait);
            }
            else if (ParseDefXOr            (out defXOr,             ref offset2) == Success) {
                result = Type2Opcode.CreateDefXOr(defXOr);
            }
            else if (ParseUserTermObj       (out userTermObj,        ref offset2) == Success) {
                result = Type2Opcode.CreateUserTermObj(userTermObj);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // Type6Opcode          := DefRefOf | DefDerefOf | DefIndex | UserTermObj


        private ParseSuccess ParseType6Opcode(out Type6Opcode result, ref int offset)
        {
            int offset2 = offset;

            DefRefOf defRefOf;
            DefDerefOf defDerefOf;
            DefIndex defIndex;
            UserTermObj userTermObj;

            if (ParseDefRefOf   (out defRefOf,    ref offset2) == Success) {
                result = Type6Opcode.CreateDefRefOf(defRefOf);
            }
            else if (ParseDefDerefOf (out defDerefOf,  ref offset2) == Success) {
                result = Type6Opcode.CreateDefDerefOf(defDerefOf);
            }
            else if (ParseDefIndex   (out defIndex,    ref offset2) == Success) {
                result = Type6Opcode.CreateDefIndex(defIndex);
            }
            else if (ParseUserTermObj(out userTermObj, ref offset2) == Success) {
                result = Type6Opcode.CreateUserTermObj(userTermObj);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefAcquire           := AcquireOp MutexObject TimeOut

        public class DefAcquire : AmlParserNode
        {
            public MutexObject mutexObject;
            public TimeOut timeOut;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefAcquire(out DefAcquire result, ref int offset)
        {
            int offset2 = offset;
            result = new DefAcquire();
            if (CheckTwoBytePrefix(AcquireOp1, AcquireOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseMutexObject(out result.mutexObject, ref offset2) == Failure ||
                ParseTimeOut    (out result.timeOut,     ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // AcquireOp            := ExtOpPrefix 0x23

        const ByteData AcquireOp1 = ExtOpPrefix;
        const ByteData AcquireOp2 = 0x23;

        // TimeOut              := WordData

        public class TimeOut : AmlParserNode
        {
            public WordData wordData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseTimeOut(out TimeOut result, ref int offset)
        {
            int offset2 = offset;
            result = new TimeOut();
            result.wordData = stream.ReadWordData(ref offset2);
            offset = offset2;
            return Success;
        }

        // DefAdd               := AddOp Operand Operand Target

        public class DefAdd : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefAdd(out DefAdd result, ref int offset)
        {
            int offset2 = offset;
            result = new DefAdd();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != AddOp) {
                return Failure;
            }
            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure ||
                ParseTarget (out result.target,       ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // AddOp                := 0x72

        const ByteData AddOp = 0x72;

        // Operand              := TermArg => Integer

        public class Operand : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseOperand(out Operand result, ref int offset)
        {
            int offset2 = offset;
            result = new Operand();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefAnd               := AndOp Operand Operand Target

        public class DefAnd : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefAnd(out DefAnd result, ref int offset)
        {
            int offset2 = offset;
            result = new DefAnd();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != AndOp) {
                return Failure;
            }
            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure ||
                ParseTarget (out result.target,       ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // AndOp                := 0x7B

        const ByteData AndOp = 0x7B;

        // DefBuffer            := BufferOp PkgLength BufferSize ByteList

        public class DefBuffer : AmlParserNode
        {
            public BufferSize bufferSize;
            public ByteData[] byteList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefBuffer(out DefBuffer result, ref int offset)
        {
            int offset2 = offset;
            result = new DefBuffer();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != BufferOp) {
                return Failure;
            }

            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }
            
            if (ParseBufferSize(out result.bufferSize, ref offset2) == Failure ||
                ParseByteList  (out result.byteList,   ref offset2, endOffset) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // BufferOp             := 0x11

        const ByteData BufferOp = 0x11;

        // BufferSize           := TermArg => Integer

        public class BufferSize : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseBufferSize(out BufferSize result, ref int offset)
        {
            int offset2 = offset;
            result = new BufferSize();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefConcat            := ConcatOp Data Data Target

        public class DefConcat : AmlParserNode
        {
            public Data leftData;
            public Data rightData;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefConcat(out DefConcat result, ref int offset)
        {
            int offset2 = offset;
            result = new DefConcat();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ConcatOp) {
                return Failure;
            }
            if (ParseData(out result.leftData, ref offset2) == Failure ||
                ParseData(out result.rightData, ref offset2) == Failure ||
                ParseTarget (out result.target, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // ConcatOp             := 0x73

        const ByteData ConcatOp = 0x73;

        // Data                 := TermArg => ComputationalData

        public class Data : AmlParserNode
        {
            public TermArg computationalData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseData(out Data result, ref int offset)
        {
            int offset2 = offset;
            result = new Data();

            if (ParseTermArg(out result.computationalData, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.computationalData, TermArgType.ComputationalData)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefConcatRes         := ConcatResOp BufData BufData Target

        public class DefConcatRes : AmlParserNode
        {
            public BufData leftBufData;
            public BufData rightBufData;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefConcatRes(out DefConcatRes result, ref int offset)
        {
            int offset2 = offset;
            result = new DefConcatRes();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ConcatResOp) {
                return Failure;
            }
            if (ParseBufData(out result.leftBufData, ref offset2) == Failure ||
                ParseBufData(out result.rightBufData, ref offset2) == Failure ||
                ParseTarget (out result.target,       ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // ConcatResOp          := 0x84

        const ByteData ConcatResOp = 0x84;

        // BufData              := TermArg => Buffer

        public class BufData : AmlParserNode
        {
            public TermArg buffer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseBufData(out BufData result, ref int offset)
        {
            int offset2 = offset;
            result = new BufData();

            if (ParseTermArg(out result.buffer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.buffer, TermArgType.Buffer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefCondRefOf         := CondRefOfOp SuperName Target

        public class DefCondRefOf : AmlParserNode
        {
            public SuperName superName;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefCondRefOf(out DefCondRefOf result, ref int offset)
        {
            int offset2 = offset;
            result = new DefCondRefOf();
            if (CheckTwoBytePrefix(CondRefOfOp1, CondRefOfOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseSuperName(out result.superName, ref offset2) == Failure ||
                ParseTarget   (out result.target,     ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // CondRefOfOp          := ExtOpPrefix 0x12

        const ByteData CondRefOfOp1 = ExtOpPrefix;
        const ByteData CondRefOfOp2 = 0x12;

        // DefCopyObject        := CopyObjectOp TermArg SimpleName

        public class DefCopyObject : AmlParserNode
        {
            public TermArg termArg;
            public SimpleName simpleName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefCopyObject(out DefCopyObject result, ref int offset)
        {
            int offset2 = offset;
            result = new DefCopyObject();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != CopyObjectOp) {
                return Failure;
            }
            if (ParseTermArg   (out result.termArg,   ref offset2) == Failure ||
                ParseSimpleName(out result.simpleName, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // CopyObjectOp         := 0x9D

        const ByteData CopyObjectOp = 0x9D;

        // DefDecrement         := DecrementOp SuperName

        public class DefDecrement : AmlParserNode
        {
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefDecrement(out DefDecrement result, ref int offset)
        {
            int offset2 = offset;
            result = new DefDecrement();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != DecrementOp) {
                return Failure;
            }
            if (ParseSuperName(out result.superName, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // DecrementOp          := 0x76

        const ByteData DecrementOp = 0x76;

        // DefDerefOf           := DerefOfOp ObjReference

        public class DefDerefOf : AmlParserNode
        {
            public ObjReference objReference;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefDerefOf(out DefDerefOf result, ref int offset)
        {
            int offset2 = offset;
            result = new DefDerefOf();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != DerefOfOp) {
                return Failure;
            }
            if (ParseObjReference(out result.objReference, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // DerefOfOp            := 0x83

        const ByteData DerefOfOp = 0x83;

        // ObjReference         := TermArg => ObjectReference | StringConst

        public class ObjReference : AmlParserNode
        {
            public TermArg termArg;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseObjReference(out ObjReference result, ref int offset)
        {
            int offset2 = offset;
            result = new ObjReference();

            if (ParseTermArg(out result.termArg, ref offset2) == Failure /*||
                (!TermArgEvaluatesTo(result.termArg, TermArgType.ObjectReference) &&
                 !TermArgEvaluatesTo(result.termArg, TermArgType.StringConst))*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefDivide            := DivideOp Dividend Divisor Remainder Quotient

        public class DefDivide : AmlParserNode
        {
            public Dividend dividend;
            public Divisor divisor;
            public Remainder remainder;
            public Quotient quotient;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefDivide(out DefDivide result, ref int offset)
        {
            int offset2 = offset;
            result = new DefDivide();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != DivideOp) {
                return Failure;
            }
            if (ParseDividend (out result.dividend, ref offset2) == Failure ||
                ParseDivisor  (out result.divisor,   ref offset2) == Failure ||
                ParseRemainder(out result.remainder, ref offset2) == Failure ||
                ParseQuotient (out result.quotient,  ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // DivideOp             := 0x78

        const ByteData DivideOp = 0x78;

        // Dividend             := TermArg => Integer

        public class Dividend : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDividend(out Dividend result, ref int offset)
        {
            int offset2 = offset;
            result = new Dividend();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // Divisor              := TermArg => Integer

        public class Divisor : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDivisor(out Divisor result, ref int offset)
        {
            int offset2 = offset;
            result = new Divisor();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // Remainder            := Target

        public class Remainder : AmlParserNode
        {
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseRemainder(out Remainder result, ref int offset)
        {
            int offset2 = offset;
            result = new Remainder();

            if (ParseTarget(out result.target, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // Quotient             := Target

        public class Quotient : AmlParserNode
        {
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseQuotient(out Quotient result, ref int offset)
        {
            int offset2 = offset;
            result = new Quotient();

            if (ParseTarget(out result.target, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefFindSetLeftBit    := FindSetLeftBitOp Operand Target

        public class DefFindSetLeftBit : AmlParserNode
        {
            public Operand operand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefFindSetLeftBit(out DefFindSetLeftBit result, ref int offset)
        {
            int offset2 = offset;
            result = new DefFindSetLeftBit();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != FindSetLeftBitOp) {
                return Failure;
            }
            if (ParseOperand(out result.operand, ref offset2) == Failure ||
                ParseTarget (out result.target,   ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // FindSetLeftBitOp     := 0x81

        const ByteData FindSetLeftBitOp = 0x81;

        // DefFindSetRightBit   := FindSetRightBitOp Operand Target

        public class DefFindSetRightBit : AmlParserNode
        {
            public Operand operand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefFindSetRightBit(out DefFindSetRightBit result, ref int offset)
        {
            int offset2 = offset;
            result = new DefFindSetRightBit();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != FindSetRightBitOp) {
                return Failure;
            }
            if (ParseOperand(out result.operand, ref offset2) == Failure ||
                ParseTarget (out result.target,   ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // FindSetRightBitOp    := 0x82

        const ByteData FindSetRightBitOp = 0x82;

        // DefFromBCD           := FromBCDOp BCDValue Target

        public class DefFromBCD : AmlParserNode
        {
            public BCDValue bcdValue;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefFromBCD(out DefFromBCD result, ref int offset)
        {
            int offset2 = offset;
            result = new DefFromBCD();
            if (CheckTwoBytePrefix(FromBCDOp1, FromBCDOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseBCDValue(out result.bcdValue, ref offset2) == Failure ||
                ParseTarget  (out result.target,    ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // FromBCDOp            := ExtOpPrefix 0x28

        const ByteData FromBCDOp1 = ExtOpPrefix;
        const ByteData FromBCDOp2 = 0x28;

        // BCDValue             := TermArg => Integer

        public class BCDValue : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseBCDValue(out BCDValue result, ref int offset)
        {
            int offset2 = offset;
            result = new BCDValue();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefIncrement         := IncrementOp SuperName

        public class DefIncrement : AmlParserNode
        {
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefIncrement(out DefIncrement result, ref int offset)
        {
            int offset2 = offset;
            result = new DefIncrement();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != IncrementOp) {
                return Failure;
            }
            if (ParseSuperName(out result.superName, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // IncrementOp          := 0x75

        const ByteData IncrementOp = 0x75;

        // DefIndex             := IndexOp BuffPkgStrObj IndexValue Target

        public class DefIndex : AmlParserNode
        {
            public BuffPkgStrObj buffPkgStrObj;
            public IndexValue indexValue;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefIndex(out DefIndex result, ref int offset)
        {
            int offset2 = offset;
            result = new DefIndex();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != IndexOp) {
                return Failure;
            }
            if (ParseBuffPkgStrObj(out result.buffPkgStrObj, ref offset2) == Failure ||
                ParseIndexValue   (out result.indexValue,    ref offset2) == Failure ||
                ParseTarget       (out result.target,        ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // IndexOp              := 0x88

        const ByteData IndexOp = 0x88;

        // BuffPkgStrObj        := TermArg => Buffer | Package | StringConst

        public class BuffPkgStrObj : AmlParserNode
        {
            public TermArg termArg;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseBuffPkgStrObj(out BuffPkgStrObj result, ref int offset)
        {
            int offset2 = offset;
            result = new BuffPkgStrObj();

            if (ParseTermArg(out result.termArg, ref offset2) == Failure /* ||
                (!TermArgEvaluatesTo(result.termArg, TermArgType.Buffer) &&
                 !TermArgEvaluatesTo(result.termArg, TermArgType.Package) &&
                 !TermArgEvaluatesTo(result.termArg, TermArgType.StringConst)) */) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // IndexValue           := TermArg => Integer

        public class IndexValue : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseIndexValue(out IndexValue result, ref int offset)
        {
            int offset2 = offset;
            result = new IndexValue();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefLAnd              := LandOp Operand Operand

        public class DefLAnd : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLAnd(out DefLAnd result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLAnd();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != LandOp) {
                return Failure;
            }
            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // LandOp               := 0x90

        const ByteData LandOp = 0x90;

        // DefLEqual            := LequalOp Operand Operand

        public class DefLEqual : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLEqual(out DefLEqual result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLEqual();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != LequalOp) {
                return Failure;
            }
            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // LequalOp             := 0x93

        const ByteData LequalOp = 0x93;

        // DefLGreater          := LgreaterOp Operand Operand

        public class DefLGreater : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLGreater(out DefLGreater result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLGreater();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != LgreaterOp) {
                return Failure;
            }
            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // LgreaterOp           := 0x94

        const ByteData LgreaterOp = 0x94;

        // DefLGreaterEqual     := LgreaterEqualOp Operand Operand

        public class DefLGreaterEqual : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLGreaterEqual(out DefLGreaterEqual result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLGreaterEqual();
            if (CheckTwoBytePrefix(LgreaterEqualOp1, LgreaterEqualOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // LgreaterEqualOp      := LnotOp LlessOp

        const ByteData LgreaterEqualOp1 = LnotOp;
        const ByteData LgreaterEqualOp2 = LlessOp;

        // DefLLess             := LlessOp Operand Operand

        public class DefLLess : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLLess(out DefLLess result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLLess();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != LlessOp) {
                return Failure;
            }
            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // LlessOp              := 0x95

        const ByteData LlessOp = 0x95;

        // DefLLessEqual        := LlessEqualOp Operand Operand

        public class DefLLessEqual : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLLessEqual(out DefLLessEqual result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLLessEqual();
            if (CheckTwoBytePrefix(LlessEqualOp1, LlessEqualOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // LlessEqualOp         := LnotOp LgreaterOp

        const ByteData LlessEqualOp1 = LnotOp;
        const ByteData LlessEqualOp2 = LgreaterOp;

        // DefLNot              := LnotOp Operand

        public class DefLNot : AmlParserNode
        {
            public Operand operand;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLNot(out DefLNot result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLNot();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != LnotOp) {
                return Failure;
            }
            if (ParseOperand(out result.operand, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // LnotOp               := 0x92

        const ByteData LnotOp = 0x92;

        // DefLNotEqual         := LnotEqualOp Operand Operand

        public class DefLNotEqual : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLNotEqual(out DefLNotEqual result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLNotEqual();
            if (CheckTwoBytePrefix(LnotEqualOp1, LnotEqualOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // LnotEqualOp          := LnotOp LequalOp

        const ByteData LnotEqualOp1 = LnotOp;
        const ByteData LnotEqualOp2 = LequalOp;

        // DefLoadTable         := LoadTableOp TermArg TermArg TermArg TermArg TermArg TermArg

        public class DefLoadTable : AmlParserNode
        {
            public TermArg signatureString;
            public TermArg oemIDString;
            public TermArg oemTableIDString;
            public TermArg rootPathString;
            public TermArg parameterPathString;
            public TermArg parameterData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLoadTable(out DefLoadTable result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLoadTable();
            if (CheckTwoBytePrefix(LoadTableOp1, LoadTableOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseTermArg(out result.signatureString,    ref offset2) == Failure ||
                ParseTermArg(out result.oemIDString,         ref offset2) == Failure ||
                ParseTermArg(out result.oemTableIDString,    ref offset2) == Failure ||
                ParseTermArg(out result.rootPathString,      ref offset2) == Failure ||
                ParseTermArg(out result.parameterPathString, ref offset2) == Failure ||
                ParseTermArg(out result.parameterData,       ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // LoadTableOp          := ExtOpPrefix 0x1F

        const ByteData LoadTableOp1 = ExtOpPrefix;
        const ByteData LoadTableOp2 = 0x1F;

        // DefLOr               := LorOp Operand Operand

        public class DefLOr : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefLOr(out DefLOr result, ref int offset)
        {
            int offset2 = offset;
            result = new DefLOr();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != LorOp) {
                return Failure;
            }
            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // LorOp                := 0x91

        const ByteData LorOp = 0x91;

        // DefMatch             := MatchOp SearchPkg MatchOpcode Operand MatchOpcode Operand StartIndex

        public class DefMatch : AmlParserNode
        {
            public SearchPkg searchPkg;
            public MatchOpcode matchOpcode1;
            public Operand operand1;
            public MatchOpcode matchOpcode2;
            public Operand operand2;
            public StartIndex startIndex;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefMatch(out DefMatch result, ref int offset)
        {
            int offset2 = offset;
            result = new DefMatch();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != MatchOp) {
                return Failure;
            }
            if (ParseSearchPkg  (out result.searchPkg,   ref offset2) == Failure ||
                ParseMatchOpcode(out result.matchOpcode1, ref offset2) == Failure ||
                ParseOperand    (out result.operand1,     ref offset2) == Failure ||
                ParseMatchOpcode(out result.matchOpcode2, ref offset2) == Failure ||
                ParseOperand    (out result.operand2,     ref offset2) == Failure ||
                ParseStartIndex (out result.startIndex,   ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // MatchOp              := 0x89

        const ByteData MatchOp = 0x89;

        // SearchPkg            := TermArg => Package

        public class SearchPkg : AmlParserNode
        {
            public TermArg package;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseSearchPkg(out SearchPkg result, ref int offset)
        {
            int offset2 = offset;
            result = new SearchPkg();

            if (ParseTermArg(out result.package, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.package, TermArgType.Package)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // MatchOpcode          := ByteData             // 0 MTR
        //                                              // 1 MEQ
        //                                              // 2 MLE
        //                                              // 3 MLT
        //                                              // 4 MGE
        //                                              // 5 MGT

        public enum MatchOpcode
        {
            MTR = 0,
            MEQ = 1,
            MLE = 2,
            MLT = 3,
            MGE = 4,
            MGT = 5,
            NumMatchOpcodes = 6
        }

        private ParseSuccess ParseMatchOpcode(out MatchOpcode result, ref int offset)
        {
            int offset2 = offset;
            result = new MatchOpcode();

            ByteData b = stream.ReadByteData(ref offset2);
            if (b >= (byte)MatchOpcode.NumMatchOpcodes) {
                return Failure;
            }
            result = (MatchOpcode)b;

            offset = offset2;
            return Success;
        }
        
        // StartIndex           := TermArg => Integer

        public class StartIndex : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseStartIndex(out StartIndex result, ref int offset)
        {
            int offset2 = offset;
            result = new StartIndex();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefMid               := MidOp MidObj TermArg TermArg Target

        public class DefMid : AmlParserNode
        {
            public MidObj midObj;
            public TermArg index;
            public TermArg length;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefMid(out DefMid result, ref int offset)
        {
            int offset2 = offset;
            result = new DefMid();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != MidOp) {
                return Failure;
            }
            if (ParseMidObj (out result.midObj, ref offset2) == Failure ||
                ParseTermArg(out result.index,   ref offset2) == Failure ||
                ParseTermArg(out result.length,  ref offset2) == Failure ||
                ParseTarget (out result.target,  ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // MidOp                := 0x9E

        const ByteData MidOp = 0x9E;

        // MidObj               := TermArg => Buffer | StringConst

        public class MidObj : AmlParserNode
        {
            public TermArg termArg;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseMidObj(out MidObj result, ref int offset)
        {
            int offset2 = offset;
            result = new MidObj();

            if (ParseTermArg(out result.termArg, ref offset2) == Failure /*||
                (!TermArgEvaluatesTo(result.termArg, TermArgType.Buffer) &&
                 !TermArgEvaluatesTo(result.termArg, TermArgType.StringConst))*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefMod               := ModOp Dividend Divisor Target

        public class DefMod : AmlParserNode
        {
            public Dividend dividend;
            public Divisor divisor;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefMod(out DefMod result, ref int offset)
        {
            int offset2 = offset;
            result = new DefMod();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ModOp) {
                return Failure;
            }
            if (ParseDividend (out result.dividend, ref offset2) == Failure ||
                ParseDivisor  (out result.divisor,   ref offset2) == Failure ||
                ParseTarget   (out result.target,    ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // ModOp                := 0x85

        const ByteData ModOp = 0x85;

        // DefMultiply          := MultiplyOp Operand Operand Target

        public class DefMultiply : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefMultiply(out DefMultiply result, ref int offset)
        {
            int offset2 = offset;
            result = new DefMultiply();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != MultiplyOp) {
                return Failure;
            }
            if (ParseOperand (out result.leftOperand, ref offset2) == Failure ||
                ParseOperand (out result.rightOperand, ref offset2) == Failure ||
                ParseTarget  (out result.target,       ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // MultiplyOp           := 0x77

        const ByteData MultiplyOp = 0x77;

        // DefNAnd              := NandOp Operand Operand Target

        public class DefNAnd : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefNAnd(out DefNAnd result, ref int offset)
        {
            int offset2 = offset;
            result = new DefNAnd();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != NandOp) {
                return Failure;
            }
            if (ParseOperand (out result.leftOperand, ref offset2) == Failure ||
                ParseOperand (out result.rightOperand, ref offset2) == Failure ||
                ParseTarget  (out result.target,       ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // NandOp               := 0x7C

        const ByteData NandOp = 0x7C;

        // DefNOr               := NorOp Operand Operand Target

        public class DefNOr : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefNOr(out DefNOr result, ref int offset)
        {
            int offset2 = offset;
            result = new DefNOr();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != NorOp) {
                return Failure;
            }
            if (ParseOperand (out result.leftOperand, ref offset2) == Failure ||
                ParseOperand (out result.rightOperand, ref offset2) == Failure ||
                ParseTarget  (out result.target,       ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
 
        // NorOp                := 0x7E

        const ByteData NorOp = 0x7E;

        // DefNot               := NotOp Operand Target

        public class DefNot : AmlParserNode
        {
            public Operand operand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefNot(out DefNot result, ref int offset)
        {
            int offset2 = offset;
            result = new DefNot();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != NotOp) {
                return Failure;
            }
            if (ParseOperand (out result.operand, ref offset2) == Failure ||
                ParseTarget  (out result.target,   ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // NotOp                := 0x80

        const ByteData NotOp = 0x80;

        // DefObjectType        := ObjectTypeOp SuperName

        public class DefObjectType : AmlParserNode
        {
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefObjectType(out DefObjectType result, ref int offset)
        {
            int offset2 = offset;
            result = new DefObjectType();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ObjectTypeOp) {
                return Failure;
            }
            if (ParseSuperName(out result.superName, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // ObjectTypeOp         := 0x8E

        const ByteData ObjectTypeOp = 0x8E;

        // DefOr                := OrOp Operand Operand Target

        public class DefOr : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefOr(out DefOr result, ref int offset)
        {
            int offset2 = offset;
            result = new DefOr();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != OrOp) {
                return Failure;
            }
            if (ParseOperand (out result.leftOperand, ref offset2) == Failure ||
                ParseOperand (out result.rightOperand, ref offset2) == Failure ||
                ParseTarget  (out result.target,       ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // OrOp                 := 0x7D

        const ByteData OrOp = 0x7D;

        // DefPackage           := PackageOp PkgLength NumElements PackageElementList

        public class DefPackage : AmlParserNode
        {
            public NumElements numElements;
            public PackageElement[] packageElementList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefPackage(out DefPackage result, ref int offset)
        {
            int offset2 = offset;
            result = new DefPackage();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != PackageOp) {
                return Failure;
            }

            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseNumElements       (out result.numElements,       ref offset2) == Failure ||
                ParsePackageElementList(out result.packageElementList, ref offset2, endOffset) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // PackageOp            := 0x12

        const ByteData PackageOp = 0x12;

        // DefVarPackage        := VarPackageOp PkgLength VarNumElements PackageElementList

        public class DefVarPackage : AmlParserNode
        {
            public VarNumElements varNumElements;
            public PackageElement[] packageElementList;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefVarPackage(out DefVarPackage result, ref int offset)
        {
            int offset2 = offset;
            result = new DefVarPackage();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != VarPackageOp) {
                return Failure;
            }

            int endOffset;
            if (ParsePkgLengthEndOffset(out endOffset, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseVarNumElements    (out result.varNumElements,    ref offset2) == Failure ||
                ParsePackageElementList(out result.packageElementList, ref offset2, endOffset) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // VarPackageOp         := 0x13

        const ByteData VarPackageOp = 0x13;

        // NumElements          := ByteData

        public class NumElements : AmlParserNode
        {
            public ByteData byteData;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseNumElements(out NumElements result, ref int offset)
        {
            int offset2 = offset;
            result = new NumElements();
            result.byteData = stream.ReadByteData(ref offset2);
            offset = offset2;
            return Success;
        }

        // VarNumElements       := TermArg => Integer

        public class VarNumElements : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseVarNumElements(out VarNumElements result, ref int offset)
        {
            int offset2 = offset;
            result = new VarNumElements();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // PackageElementList   := Nothing | <PackageElement PackageElementList>
        // [To make this rule make sense, it needs a length
        //  limit for termination. The rule using it should know this.]

        private class PackageElementList
        {
            ArrayList list = new ArrayList();

            public void Add(PackageElement packageElement)
            {
                list.Add(packageElement);
            }

            public PackageElement[] ToArray()
            {
                return (PackageElement[])list.ToArray(typeof(PackageElement));
            }
        }
        
        private ParseSuccess ParsePackageElementList(out PackageElement[] result, ref int offset, int endOffset)
        {
            result = null;
            PackageElementList packageElements = new PackageElementList();
            int offset2 = offset;

            while (offset2 < endOffset) {
                PackageElement packageElement;
                if (ParsePackageElement(out packageElement, ref offset2) == Failure) {
                    return Failure;
                }
                packageElements.Add(packageElement);
            }
            Debug.Assert(offset2 == endOffset);
            
            result = packageElements.ToArray();
            offset = offset2;
            return Success;
        }

        // PackageElement       := DataRefObject | NameString
        // See AmlParser.csunion

        private ParseSuccess ParsePackageElement(out PackageElement result, ref int offset)
        {
            int offset2 = offset;

            DataRefObject dataRefObject;
            NameString nameString;

            if (ParseDataRefObject(out dataRefObject, ref offset2) == Success) {
                result = PackageElement.CreateDataRefObject(dataRefObject);
            }
            else if (ParseNameString(out nameString, ref offset2) == Success) {
                result = PackageElement.CreateNameString(nameString);
            }
            else {
                result = null;
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefRefOf             := RefOfOp SuperName

        public class DefRefOf : AmlParserNode
        {
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefRefOf(out DefRefOf result, ref int offset)
        {
            int offset2 = offset;
            result = new DefRefOf();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != RefOfOp) {
                return Failure;
            }
            if (ParseSuperName(out result.superName, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // RefOfOp              := 0x71

        const ByteData RefOfOp = 0x71;

        // DefShiftLeft         := ShiftLeftOp Operand ShiftCount Target

        public class DefShiftLeft : AmlParserNode
        {
            public Operand operand;
            public ShiftCount shiftCount;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefShiftLeft(out DefShiftLeft result, ref int offset)
        {
            int offset2 = offset;
            result = new DefShiftLeft();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ShiftLeftOp) {
                return Failure;
            }
            if (ParseOperand   (out result.operand,   ref offset2) == Failure ||
                ParseShiftCount(out result.shiftCount, ref offset2) == Failure ||
                ParseTarget    (out result.target,     ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // ShiftLeftOp          := 0x79

        const ByteData ShiftLeftOp = 0x79;

        // ShiftCount           := TermArg => Integer

        public class ShiftCount : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseShiftCount(out ShiftCount result, ref int offset)
        {
            int offset2 = offset;
            result = new ShiftCount();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DefShiftRight        := ShiftRightOp Operand ShiftCount Target

        public class DefShiftRight : AmlParserNode
        {
            public Operand operand;
            public ShiftCount shiftCount;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefShiftRight(out DefShiftRight result, ref int offset)
        {
            int offset2 = offset;
            result = new DefShiftRight();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ShiftRightOp) {
                return Failure;
            }
            if (ParseOperand   (out result.operand,   ref offset2) == Failure ||
                ParseShiftCount(out result.shiftCount, ref offset2) == Failure ||
                ParseTarget    (out result.target,     ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // ShiftRightOp         := 0x7A

        const ByteData ShiftRightOp = 0x7A;

        // DefSizeOf            := SizeOfOp SuperName

        public class DefSizeOf : AmlParserNode
        {
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefSizeOf(out DefSizeOf result, ref int offset)
        {
            int offset2 = offset;
            result = new DefSizeOf();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != SizeOfOp) {
                return Failure;
            }
            if (ParseSuperName(out result.superName, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // SizeOfOp             := 0x87

        const ByteData SizeOfOp = 0x87;

        // DefStore             := StoreOp TermArg SuperName

        public class DefStore : AmlParserNode
        {
            public TermArg termArg;
            public SuperName superName;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefStore(out DefStore result, ref int offset)
        {
            int offset2 = offset;
            result = new DefStore();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != StoreOp) {
                return Failure;
            }
            if (ParseTermArg  (out result.termArg,  ref offset2) == Failure ||
                ParseSuperName(out result.superName, ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
 
        // StoreOp              := 0x70

        const ByteData StoreOp = 0x70;

        // DefSubtract          := SubtractOp Operand Operand Target

        public class DefSubtract : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefSubtract(out DefSubtract result, ref int offset)
        {
            int offset2 = offset;
            result = new DefSubtract();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != SubtractOp) {
                return Failure;
            }
            if (ParseOperand (out result.leftOperand, ref offset2) == Failure ||
                ParseOperand (out result.rightOperand, ref offset2) == Failure ||
                ParseTarget  (out result.target,       ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // SubtractOp           := 0x74

        const ByteData SubtractOp = 0x74;

        // DefTimer             := TimerOp

        public class DefTimer : AmlParserNode
        {
            // No data
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefTimer(out DefTimer result, ref int offset)
        {
            int offset2 = offset;
            result = new DefTimer();
            if (CheckTwoBytePrefix(TimerOp1, TimerOp2, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // TimerOp              := 0x5B 0x33

        const ByteData TimerOp1 = 0x5B;
        const ByteData TimerOp2 = 0x33;

        // DefToBCD             := ToBCDOp Operand Target

        public class DefToBCD : AmlParserNode
        {
            public Operand operand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefToBCD(out DefToBCD result, ref int offset)
        {
            int offset2 = offset;
            result = new DefToBCD();
            if (CheckTwoBytePrefix(ToBCDOp1, ToBCDOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseOperand (out result.operand, ref offset2) == Failure ||
                ParseTarget   (out result.target,  ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // ToBCDOp              := ExtOpPrefix 0x29

        const ByteData ToBCDOp1 = ExtOpPrefix;
        const ByteData ToBCDOp2 = 0x29;

        // DefToBuffer          := ToBufferOp Operand Target

        public class DefToBuffer : AmlParserNode
        {
            public Operand operand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefToBuffer(out DefToBuffer result, ref int offset)
        {
            int offset2 = offset;
            result = new DefToBuffer();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ToBufferOp) {
                return Failure;
            }
            if (ParseOperand (out result.operand, ref offset2) == Failure ||
                ParseTarget   (out result.target,  ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // ToBufferOp           := 0x96

        const ByteData ToBufferOp = 0x96;

        // DefToDecimalString   := ToDecimalStringOp Operand Target

        public class DefToDecimalString : AmlParserNode
        {
            public Operand operand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefToDecimalString(out DefToDecimalString result, ref int offset)
        {
            int offset2 = offset;
            result = new DefToDecimalString();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ToDecimalStringOp) {
                return Failure;
            }
            if (ParseOperand (out result.operand, ref offset2) == Failure ||
                ParseTarget   (out result.target,  ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }
        
        // ToDecimalStringOp    := 0x97

        const ByteData ToDecimalStringOp = 0x97;

        // DefToHexString       := ToHexStringOp Operand Target

        public class DefToHexString : AmlParserNode
        {
            public Operand operand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefToHexString(out DefToHexString result, ref int offset)
        {
            int offset2 = offset;
            result = new DefToHexString();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ToHexStringOp) {
                return Failure;
            }
            if (ParseOperand (out result.operand, ref offset2) == Failure ||
                ParseTarget   (out result.target,  ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // ToHexStringOp        := 0x98

        const ByteData ToHexStringOp = 0x98;

        // DefToInteger         := ToIntegerOp Operand Target

        public class DefToInteger : AmlParserNode
        {
            public Operand operand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefToInteger(out DefToInteger result, ref int offset)
        {
            int offset2 = offset;
            result = new DefToInteger();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ToIntegerOp) {
                return Failure;
            }
            if (ParseOperand (out result.operand, ref offset2) == Failure ||
                ParseTarget   (out result.target,  ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // ToIntegerOp          := 0x99

        const ByteData ToIntegerOp = 0x99;

        // DefToString          := ToStringOp TermArg LengthArg Target

        public class DefToString : AmlParserNode
        {
            public TermArg termArg;
            public LengthArg lengthArg;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefToString(out DefToString result, ref int offset)
        {
            int offset2 = offset;
            result = new DefToString();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != ToStringOp) {
                return Failure;
            }
            if (ParseTermArg  (out result.termArg,  ref offset2) == Failure ||
                ParseLengthArg(out result.lengthArg, ref offset2) == Failure ||
                ParseTarget   (out result.target,    ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // LengthArg            := TermArg => Integer

        public class LengthArg : AmlParserNode
        {
            public TermArg integer;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseLengthArg(out LengthArg result, ref int offset)
        {
            int offset2 = offset;
            result = new LengthArg();

            if (ParseTermArg(out result.integer, ref offset2) == Failure /*||
                !TermArgEvaluatesTo(result.integer, TermArgType.Integer)*/) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // ToStringOp           := 0x9C

        const ByteData ToStringOp = 0x9C;

        // DefWait              := WaitOp EventObject Operand

        public class DefWait : AmlParserNode
        {
            public EventObject eventObject;
            public Operand operand;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefWait(out DefWait result, ref int offset)
        {
            int offset2 = offset;
            result = new DefWait();
            if (CheckTwoBytePrefix(WaitOp1, WaitOp2, ref offset2) == Failure) {
                return Failure;
            }

            if (ParseEventObject(out result.eventObject, ref offset2) == Failure ||
                ParseOperand    (out result.operand,     ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // WaitOp               := ExtOpPrefix 0x25

        const ByteData WaitOp1 = ExtOpPrefix;
        const ByteData WaitOp2 = 0x25;

        // DefXOr               := XorOp Operand Operand Target

        public class DefXOr : AmlParserNode
        {
            public Operand leftOperand;
            public Operand rightOperand;
            public Target target;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDefXOr(out DefXOr result, ref int offset)
        {
            int offset2 = offset;
            result = new DefXOr();
            ByteData prefix = stream.ReadByteData(ref offset2);
            if (prefix != XorOp) {
                return Failure;
            }
            if (ParseOperand(out result.leftOperand, ref offset2) == Failure ||
                ParseOperand(out result.rightOperand, ref offset2) == Failure ||
                ParseTarget (out result.target,       ref offset2) == Failure) {
                return Failure;
            }
            offset = offset2;
            return Success;
        }

        // XorOp                := 0x7F

        const ByteData XorOp = 0x7F;


        //
        // Section 18.2.6: Miscellaneous Objects Encoding
        //

        //
        // Section 18.2.6.1: Arg Objects Encoding
        //

        // ArgObj               := Arg0Op | Arg1Op | Arg2Op | Arg3Op | Arg4Op |
        //                         Arg5Op | Arg6Op

        public class ArgObj : AmlParserNode
        {
            public ByteData op;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseArgObj(out ArgObj result, ref int offset)
        {
            int offset2 = offset;
            result = new ArgObj();
            ByteData op = stream.ReadByteData(ref offset2);
            if (op != Arg0Op &&
                op != Arg1Op &&
                op != Arg2Op &&
                op != Arg3Op &&
                op != Arg4Op &&
                op != Arg5Op &&
                op != Arg6Op) {
                return Failure;
            }
            result.op = (ByteData)(op - Arg0Op);
            offset = offset2;
            return Success;
        }

        // Arg0Op               := 0x68

        const ByteData Arg0Op = 0x68;

        // Arg1Op               := 0x69

        const ByteData Arg1Op = 0x69;

        // Arg2Op               := 0x6A

        const ByteData Arg2Op = 0x6A;

        // Arg3Op               := 0x6B

        const ByteData Arg3Op = 0x6B;

        // Arg4Op               := 0x6C

        const ByteData Arg4Op = 0x6C;

        // Arg5Op               := 0x6D

        const ByteData Arg5Op = 0x6D;

        // Arg6Op               := 0x6E


        const ByteData Arg6Op = 0x6E;

        //
        // Section 18.2.6.2: Local Objects Encoding
        //

        // LocalObj             := Local0Op | Local1Op | Local2Op | Local3Op | Local4Op |
        //                         Local5Op | Local6Op | Local7Op

        public class LocalObj : AmlParserNode
        {
            public ByteData op;
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseLocalObj(out LocalObj result, ref int offset)
        {
            int offset2 = offset;
            result = new LocalObj();
            ByteData op = stream.ReadByteData(ref offset2);
            if (op != Local0Op &&
                op != Local1Op &&
                op != Local2Op &&
                op != Local3Op &&
                op != Local4Op &&
                op != Local5Op &&
                op != Local6Op &&
                op != Local7Op) {
                return Failure;
            }
            result.op = (ByteData)(op - Local0Op);
            offset = offset2;
            return Success;
        }

        // Local0Op             := 0x60

        const ByteData Local0Op = 0x60;

        // Local1Op             := 0x61

        const ByteData Local1Op = 0x61;

        // Local2Op             := 0x62

        const ByteData Local2Op = 0x62;

        // Local3Op             := 0x63

        const ByteData Local3Op = 0x63;

        // Local4Op             := 0x64

        const ByteData Local4Op = 0x64;

        // Local5Op             := 0x65

        const ByteData Local5Op = 0x65;

        // Local6Op             := 0x66

        const ByteData Local6Op = 0x66;

        // Local7Op             := 0x67

        const ByteData Local7Op = 0x67;

        //
        // Section 18.2.6.3: Debug Objects Encoding
        //

        // DebugObj             := DebugOp

        public class DebugObj : AmlParserNode
        {
            // No data
            
            public override void Accept(AmlParserNodeVisitor v)
            {
                v.Visit(this);
            }
        }

        private ParseSuccess ParseDebugObj(out DebugObj result, ref int offset)
        {
            int offset2 = offset;
            result = new DebugObj();
            if (CheckTwoBytePrefix(DebugOp1, DebugOp2, ref offset2) == Failure) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }

        // DebugOp              := ExtOpPrefix 0x31

        const ByteData DebugOp1 = ExtOpPrefix;
        const ByteData DebugOp2 = 0x31;

        // Helpers

        private ParseSuccess CheckTwoBytePrefix(byte op1, byte op2, ref int offset) {
            int offset2 = offset;
            ByteData prefix1, prefix2;

            prefix1 = stream.ReadByteData(ref offset2);
            if (prefix1 != op1) {
                return Failure;
            }

            prefix2 = stream.ReadByteData(ref offset2);

            if (prefix2 != op2) {
                return Failure;
            }

            offset = offset2;
            return Success;
        }
    }
}