diff --git a/Makefile b/Makefile index c133d2a..fa49a19 100644 --- a/Makefile +++ b/Makefile @@ -11,13 +11,18 @@ iso_target := $(BUILD_DIR)/kernel-$(ARCH).iso # this: make run GO=go1.8 GO ?= go -# Prepend build path to GOPATH so the compiled packages and linter dependencies +# Prepend build path to GOPATH so the compiled packages and linter dependencies # end up inside the build folder GOPATH := $(BUILD_ABS_DIR):$(shell pwd):$(GOPATH) +FUZZ_PKG_LIST := src/gopheros/device/acpi/aml +# To append more entries to the above list use the following syntax +# FUZZ_PKG_LIST += path-to-pkg + ifeq ($(OS), Linux) export SHELL := /bin/bash -o pipefail + LD := ld AS := nasm @@ -143,7 +148,7 @@ run-vbox: iso VBoxManage storageattach $(VBOX_VM_NAME) --storagectl "IDE Controller" --port 0 --device 0 --type dvddrive \ --medium $(iso_target) || true VBoxManage startvm $(VBOX_VM_NAME) - + # When building gdb target disable optimizations (-N) and inlining (l) of Go code gdb: GC_FLAGS += -N -l gdb: iso @@ -185,12 +190,28 @@ lint: lint-check-deps src/... lint-check-deps: + @echo [go get] installing linter dependencies @GOPATH=$(GOPATH) $(GO) get -u -t gopkg.in/alecthomas/gometalinter.v1 @GOPATH=$(GOPATH) PATH=$(BUILD_ABS_DIR)/bin:$(PATH) gometalinter.v1 --install >/dev/null test: GOPATH=$(GOPATH) $(GO) test -cover gopheros/... +fuzz-deps: + @mkdir -p $(BUILD_DIR)/fuzz + @echo [go get] installing go-fuzz dependencies + @GOPATH=$(GOPATH) $(GO) get -u github.com/dvyukov/go-fuzz/... + +%.fuzzpkg: % + @echo [go-fuzz] fuzzing: $< + @GOPATH=$(GOPATH) PATH=$(BUILD_ABS_DIR)/bin:$(PATH) go-fuzz-build -o $(BUILD_ABS_DIR)/fuzz/$(subst /,_,$<).zip $(subst src/,,$<) + @mkdir -p $(BUILD_ABS_DIR)/fuzz/corpus/$(subst /,_,$<)/corpus + @echo [go-fuzz] + grepping for corpus file hints in $< + @grep "go-fuzz-corpus+=" $&1 | sed -e "s/^/ | /g" + +test-fuzz: fuzz-deps $(addsuffix .fuzzpkg,$(FUZZ_PKG_LIST)) + collect-coverage: GOPATH=$(GOPATH) sh coverage.sh diff --git a/src/gopheros/device/acpi/aml/obj_tree.go b/src/gopheros/device/acpi/aml/obj_tree.go new file mode 100644 index 0000000..12e79fd --- /dev/null +++ b/src/gopheros/device/acpi/aml/obj_tree.go @@ -0,0 +1,599 @@ +package aml + +import ( + "bytes" + "gopheros/kernel/kfmt" + "io" +) + +const ( + // InvalidIndex is a sentinel value used by ObjectTree to indicate that + // a returned object index is not valid. + InvalidIndex uint32 = (1 << 32) - 1 + + // The size of AML name identifiers in bytes. + amlNameLen = 4 +) + +// fieldElement groups together information about a field element. This +// information can also be obtained by scanning a field element's siblings but +// it is summarized in this structure for convenience. +type fieldElement struct { + // The offset in the address space defined by parent field. + offset uint32 + + // The width of this field element in bits. + width uint32 + + accessLength uint8 + _pad [3]uint8 + + accessType uint8 + accessAttrib uint8 + lockType uint8 + updateType uint8 + + // The index of an Object to use as a connection target. Used only for + // GenericSerialBus and GeneralPurposeIO operation regions. + connectionIndex uint32 + + // The index of the Field (pOpField, pOpIndexField or pOpBankField) that this + // field element belongs to. According to the spec, named fields appear + // at the same scope as their parent. + fieldIndex uint32 +} + +// Object describes an entity encoded in the AML bytestream. +type Object struct { + // The AML ocode that describes this oBject. + opcode uint16 + + // The Index in the opcodeTable for this opcode + infoIndex uint8 + + // The table handle which contains this entity. + tableHandle uint8 + + // Named AML entities provide a fixed-width name which is padded by '_' chars. + name [amlNameLen]byte + + // The following indices refer to other Objects in the ObjectTree + // that allocated this Object instance. Uninitialized indices are + // represented via a math.MaxUint32 value. + index uint32 + parentIndex uint32 + prevSiblingIndex uint32 + nextSiblingIndex uint32 + firstArgIndex uint32 + lastArgIndex uint32 + + // The byte offset in the AML stream where this opcode is defined. + amlOffset uint32 + + // A non-zero value for pkgEnd indicates that this opcode requires deferred + // parsing due to its potentially ambiguous contents. + pkgEnd uint32 + + // A value placeholder for entites that contain values (e.g. int + // or string constants byte slices e.t.c) + value interface{} +} + +// ObjectTree is a structure that contains a tree of AML entities where each +// entity is allocated from a contiguous Object pool. Index #0 of the pool +// contains the root scope ('\') of the AML tree. +type ObjectTree struct { + objPool []*Object + freeListHeadIndex uint32 +} + +// NewObjectTree returns a new ObjectTree instance. +func NewObjectTree() *ObjectTree { + return &ObjectTree{ + freeListHeadIndex: InvalidIndex, + } +} + +// CreateDefaultScopes populates the Object pool with the default scopes +// specified by the ACPI standard: +// +// +-[\] (Root scope) +// +- [_GPE] (General events in GPE register block) +// +- [_PR_] (ACPI 1.0 processor namespace) +// +- [_SB_] (System bus with all device objects) +// +- [_SI_] (System indicators) +// +- [_TZ_] (ACPI 1.0 thermal zone namespace) +func (tree *ObjectTree) CreateDefaultScopes(tableHandle uint8) { + root := tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'\\'}) + tree.append(root, tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'_', 'G', 'P', 'E'})) // General events in GPE register block + tree.append(root, tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'_', 'P', 'R', '_'})) // ACPI 1.0 processor namespace + tree.append(root, tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'_', 'S', 'B', '_'})) // System bus with all device objects + tree.append(root, tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'_', 'S', 'I', '_'})) // System indicators + tree.append(root, tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'_', 'T', 'Z', '_'})) // ACPI 1.0 thermal zone namespace +} + +// newObject allocates a new Object from the Object pool, populates its +// contents and returns back a pointer to it. +func (tree *ObjectTree) newObject(opcode uint16, tableHandle uint8) *Object { + var obj *Object + + // Check the free list first + if tree.freeListHeadIndex != InvalidIndex { + obj = tree.objPool[tree.freeListHeadIndex] + tree.freeListHeadIndex = obj.nextSiblingIndex + } else { + // Allocate new object and attach it to the pool + obj = new(Object) + obj.index = uint32(len(tree.objPool)) + tree.objPool = append(tree.objPool, obj) + } + + obj.opcode = opcode + obj.infoIndex = pOpcodeTableIndex(opcode, true) + obj.tableHandle = tableHandle + obj.parentIndex = InvalidIndex + obj.prevSiblingIndex = InvalidIndex + obj.nextSiblingIndex = InvalidIndex + obj.firstArgIndex = InvalidIndex + obj.lastArgIndex = InvalidIndex + obj.value = nil + + return obj +} + +// newNamedObject allocates a new Object from the Object pool, populates its +// name and returns back a pointer to it. +func (tree *ObjectTree) newNamedObject(opcode uint16, tableHandle uint8, name [amlNameLen]byte) *Object { + obj := tree.newObject(opcode, tableHandle) + obj.name = name + return obj +} + +// append appends arg to obj's argument list. +func (tree *ObjectTree) append(obj, arg *Object) { + arg.parentIndex = obj.index + + if obj.lastArgIndex == InvalidIndex { + obj.firstArgIndex = arg.index + obj.lastArgIndex = arg.index + return + } + + LastArg := tree.ObjectAt(obj.lastArgIndex) + LastArg.nextSiblingIndex = arg.index + arg.prevSiblingIndex = LastArg.index + arg.nextSiblingIndex = InvalidIndex + obj.lastArgIndex = arg.index +} + +// appendAfter appends arg to obj's argument list after nextTo. +func (tree *ObjectTree) appendAfter(obj, arg, nextTo *Object) { + // nextTo is the last arg of obj; this is equivalent to a regular append + if nextTo.nextSiblingIndex == InvalidIndex { + tree.append(obj, arg) + return + } + + arg.parentIndex = obj.index + arg.prevSiblingIndex = nextTo.index + arg.nextSiblingIndex = nextTo.nextSiblingIndex + + tree.ObjectAt(arg.nextSiblingIndex).prevSiblingIndex = arg.index + nextTo.nextSiblingIndex = arg.index +} + +// free appends obj to the tree's free object list allowing it to be re-used by +// future calls to NewObject and NewNamedObject. Callers must ensure that any +// held pointers to the object are not used after calling free. +func (tree *ObjectTree) free(obj *Object) { + if obj.parentIndex != InvalidIndex { + tree.detach(tree.ObjectAt(obj.parentIndex), obj) + } + + if obj.firstArgIndex != InvalidIndex || obj.lastArgIndex != InvalidIndex { + panic("aml.ObjectTree: attempted to free object that still contains argument references") + } + + // Push the object to the top of the free list and change its opcode to + // indicate this is a freed node + obj.opcode = pOpIntFreedObject + obj.nextSiblingIndex = tree.freeListHeadIndex + tree.freeListHeadIndex = obj.index +} + +// detach detaches arg from obj's argument list. +func (tree *ObjectTree) detach(obj, arg *Object) { + if obj.firstArgIndex == arg.index { + obj.firstArgIndex = arg.nextSiblingIndex + } + + if obj.lastArgIndex == arg.index { + obj.lastArgIndex = arg.prevSiblingIndex + } + + if arg.nextSiblingIndex != InvalidIndex { + tree.ObjectAt(arg.nextSiblingIndex).prevSiblingIndex = arg.prevSiblingIndex + } + + if arg.prevSiblingIndex != InvalidIndex { + tree.ObjectAt(arg.prevSiblingIndex).nextSiblingIndex = arg.nextSiblingIndex + } + + arg.prevSiblingIndex = InvalidIndex + arg.nextSiblingIndex = InvalidIndex + arg.parentIndex = InvalidIndex +} + +// ObjectAt returns a pointer to the Object at the specified index or nil if +// no object with this index exists inside the object tree. +func (tree *ObjectTree) ObjectAt(index uint32) *Object { + if index >= uint32(len(tree.objPool)) { + return nil + } + obj := tree.objPool[index] + if obj.opcode == pOpIntFreedObject { + return nil + } + + return obj +} + +// Find attempts to resolve the given expression into an Object using the rules +// specified in page 252 of the ACPI 6.2 spec: +// +// There are two types of namespace paths: an absolute namespace path (that is, +// one that starts with a ‘\’ prefix), and a relative namespace path (that is, +// one that is relative to the current namespace). The namespace search rules +// discussed above, only apply to single NameSeg paths, which is a relative +// namespace path. For those relative name paths that contain multiple NameSegs +// or Parent Prefixes, ‘^’, the search rules do not apply. If the search rules +// do not apply to a relative namespace path, the namespace object is looked up +// relative to the current namespace +func (tree *ObjectTree) Find(scopeIndex uint32, expr []byte) uint32 { + exprLen := len(expr) + if exprLen == 0 || scopeIndex == InvalidIndex { + return InvalidIndex + } + + switch { + case expr[0] == '\\': // relative to the root scope + // Name was just `\`; this matches the root namespace + if exprLen == 1 { + return 0 + } + + return tree.findRelative(0, expr[1:]) + case expr[0] == '^': // relative to the parent scope(s) + for startIndex := 0; startIndex < exprLen; startIndex++ { + switch expr[startIndex] { + case '^': + // Mpve up one parent. If we were at the root scope + // then the lookup failed. + if scopeIndex = tree.ObjectAt(scopeIndex).parentIndex; scopeIndex == InvalidIndex { + return InvalidIndex + } + default: + // Found the start of the name. Look it up relative to current scope + return tree.findRelative(scopeIndex, expr[startIndex:]) + } + } + + // Name was just a sequence of '^'; this matches the last scopeIndex value + return scopeIndex + case exprLen > amlNameLen: + // The expression consists of multiple name segments joined together (e.g. FOOFBAR0) + // In this case we need to apply relative lookup rules for FOOF.BAR0 + return tree.findRelative(scopeIndex, expr) + case exprLen == amlNameLen: + // expr is a simple name. According to the spec, we need to + // search for it in this scope and all its parent scopes till + // we reach the root. + for nextScopeIndex := scopeIndex; nextScopeIndex != InvalidIndex; nextScopeIndex = tree.ObjectAt(nextScopeIndex).parentIndex { + scopeObj := tree.ObjectAt(nextScopeIndex) + checkNextSibling: + for nextIndex := scopeObj.firstArgIndex; nextIndex != InvalidIndex; nextIndex = tree.ObjectAt(nextIndex).nextSiblingIndex { + obj := tree.ObjectAt(nextIndex) + for byteIndex := 0; byteIndex < amlNameLen; byteIndex++ { + if expr[byteIndex] != obj.name[byteIndex] { + continue checkNextSibling + } + } + + // Found match + return obj.index + } + } + } + + // Not found + return InvalidIndex +} + +// findRelative attempts to resolve an object using relative scope lookup rules. +func (tree *ObjectTree) findRelative(scopeIndex uint32, expr []byte) uint32 { + exprLen := len(expr) + +nextSegment: + for segIndex := 0; segIndex < exprLen; segIndex += amlNameLen { + // If expr contains a dual or multinamed path then we may encounter special + // prefix chars in the stream (the parser extracts the raw data). In this + // case skip over them. + for ; segIndex < exprLen && expr[segIndex] != '_' && (expr[segIndex] < 'A' || expr[segIndex] > 'Z'); segIndex++ { + } + + if exprLen-segIndex < amlNameLen { + return InvalidIndex + } + + // Search current scope for an entity matching the next name segment + scopeObj := tree.ObjectAt(scopeIndex) + + checkNextSibling: + for nextIndex := scopeObj.firstArgIndex; nextIndex != InvalidIndex; nextIndex = tree.ObjectAt(nextIndex).nextSiblingIndex { + obj := tree.ObjectAt(nextIndex) + for byteIndex := 0; byteIndex < amlNameLen; byteIndex++ { + if expr[segIndex+byteIndex] != obj.name[byteIndex] { + continue checkNextSibling + } + } + + // Found match; set match as the next scope index and + // try to match the next segment + scopeIndex = nextIndex + continue nextSegment + } + + // Failed to match next segment. Lookup failed + return InvalidIndex + } + + // scopeIndex contains the index of the last matched name in the expression + // which is the target we were looking for. + return scopeIndex +} + +// ClosestNamedAncestor returns the index of the first named object that is an +// ancestor of obj. If any of obj's parents are unresolved scope directives +// then the call will return InvalidIndex. +func (tree *ObjectTree) ClosestNamedAncestor(obj *Object) uint32 { + if obj == nil { + return InvalidIndex + } + + for ancestorIndex := obj.parentIndex; ancestorIndex != InvalidIndex; { + ancestor := tree.ObjectAt(ancestorIndex) + if ancestor.opcode == pOpScope { + break + } + + if pOpcodeTable[ancestor.infoIndex].flags&pOpFlagNamed != 0 { + return ancestorIndex + } + + ancestorIndex = ancestor.parentIndex + } + + return InvalidIndex +} + +// NumArgs returns the number of arguments contained in obj. +func (tree *ObjectTree) NumArgs(obj *Object) uint32 { + if obj == nil { + return 0 + } + + var argCount uint32 + for siblingIndex := obj.firstArgIndex; siblingIndex != InvalidIndex; siblingIndex = tree.ObjectAt(siblingIndex).nextSiblingIndex { + argCount++ + } + + return argCount +} + +// ArgAt returns a pointer to obj's arg located at index. +func (tree *ObjectTree) ArgAt(obj *Object, index uint32) *Object { + if obj == nil { + return nil + } + for argIndex, siblingIndex := uint32(0), obj.firstArgIndex; siblingIndex != InvalidIndex; argIndex, siblingIndex = argIndex+1, tree.ObjectAt(siblingIndex).nextSiblingIndex { + if argIndex == index { + return tree.ObjectAt(siblingIndex) + } + } + + return nil +} + +// PrettyPrint outputs a pretty-printed version of the AML tree to w. +func (tree *ObjectTree) PrettyPrint(w io.Writer) { + if len(tree.objPool) != 0 { + var padBuf bytes.Buffer + padBuf.WriteByte(' ') + tree.toString(w, &padBuf, 0) + } +} + +func (tree *ObjectTree) toString(w io.Writer, padBuf *bytes.Buffer, index uint32) { + curObj := tree.ObjectAt(index) + + _, _ = w.Write(padBuf.Bytes()) + kfmt.Fprintf(w, "+- [%s", pOpcodeName(curObj.opcode)) + + if name := nameOf(curObj); len(name) != 0 { + kfmt.Fprintf(w, ", name: \"%s\"", name) + } + + if curObj.opcode == pOpMethod { + kfmt.Fprintf(w, ", argCount: %d", uint8(tree.ArgAt(curObj, 1).value.(uint64)&0x7)) + } + + kfmt.Fprintf(w, ", table: %d, index: %d, offset: 0x%x", curObj.tableHandle, curObj.index, curObj.amlOffset) + kfmt.Fprintf(w, "]") + + if curObj.opcode == pOpIntMethodCall { + methodObj := tree.ObjectAt(curObj.value.(uint32)) + argCount := uint8(tree.ArgAt(methodObj, 1).value.(uint64) & 0x7) + kfmt.Fprintf(w, " -> [call to \"%s\", argCount: %d, table: %d, index: %d, offset: 0x%x]", methodObj.name[:], argCount, methodObj.tableHandle, methodObj.index, methodObj.amlOffset) + } else if curObj.opcode == pOpIntResolvedNamePath { + resolvedObj := tree.ObjectAt(curObj.value.(uint32)) + kfmt.Fprintf(w, " -> [resolved to \"%s\", table: %d, index: %d, offset: 0x%x]", nameOf(resolvedObj), resolvedObj.tableHandle, resolvedObj.index, resolvedObj.amlOffset) + } else if curObj.opcode == pOpIntNamedField { + field := curObj.value.(*fieldElement) + kfmt.Fprintf(w, " -> [field index: %d, offset(bytes): 0x%x, width(bits): 0x%x, accType: ", field.fieldIndex, field.offset, field.width) + switch field.accessType { + case 0x00: + kfmt.Fprintf(w, "Any") + case 0x01: + kfmt.Fprintf(w, "Byte") + case 0x02: + kfmt.Fprintf(w, "Word") + case 0x03: + kfmt.Fprintf(w, "Dword") + case 0x04: + kfmt.Fprintf(w, "Qword") + case 0x05: + kfmt.Fprintf(w, "Buffer, accAttr: ") + switch field.accessAttrib { + case 0x02: + kfmt.Fprintf(w, "Quick") + case 0x04: + kfmt.Fprintf(w, "SendReceive") + case 0x06: + kfmt.Fprintf(w, "Byte") + case 0x08: + kfmt.Fprintf(w, "Word") + case 0x0a: + kfmt.Fprintf(w, "Block") + case 0x0b: + kfmt.Fprintf(w, "Bytes(0x%x)", field.accessLength) + case 0x0c: + kfmt.Fprintf(w, "ProcessCall") + case 0x0d: + kfmt.Fprintf(w, "BlockProcessCall") + case 0x0e: + kfmt.Fprintf(w, "RawBytes(0x%x)", field.accessLength) + case 0x0f: + kfmt.Fprintf(w, "RawProcessBytes(0x%x)", field.accessLength) + } + /* + case 0x40: + kfmt.Fprintf(w, "Bytes(0x%x)", field.AccessAttrib) + case 0x80: + kfmt.Fprintf(w, "RawBytes(0x%x)", field.AccessAttrib) + case 0xc0: + kfmt.Fprintf(w, "RawProcessBytes(0x%x)", field.AccessAttrib) + */ + } + + kfmt.Fprintf(w, ", lockType: ") + switch field.lockType { + case 0x00: + kfmt.Fprintf(w, "NoLock") + case 0x01: + kfmt.Fprintf(w, "Lock") + } + + kfmt.Fprintf(w, ", updateType: ") + switch field.updateType { + case 0x00: + kfmt.Fprintf(w, "Preserve") + case 0x01: + kfmt.Fprintf(w, "WriteAsOnes") + case 0x02: + kfmt.Fprintf(w, "WriteAsZeroes") + } + + switch field.connectionIndex { + case InvalidIndex: + kfmt.Fprintf(w, ", connection: -]") + default: + kfmt.Fprintf(w, ", connection: index %d]", field.connectionIndex) + } + } else if curObj.opcode == pOpStringPrefix { + kfmt.Fprintf(w, " -> [string value: \"%s\"]", curObj.value.([]byte)) + } else if curObj.opcode == pOpIntNamePath { + kfmt.Fprintf(w, " -> [namepath: \"%s\"]", curObj.value.([]byte)) + } else if curObj.value != nil { + switch v := curObj.value.(type) { + case uint64: + kfmt.Fprintf(w, " -> [num value; dec: %d, hex: 0x%x]", v, v) + + // If this is an encoded EISA id convert it back to a string + if curObj.opcode == pOpDwordPrefix && tree.ObjectAt(curObj.parentIndex).name == [amlNameLen]byte{'_', 'H', 'I', 'D'} { + // Poor-man's ntohl + id := uint32((v>>24)&0xff) | + uint32((v>>16)&0xff)<<8 | + uint32((v>>8)&0xff)<<16 | + uint32(v&0xff)<<24 + + var eisaID = [7]byte{ + '@' + (byte)((id>>26)&0x1f), + '@' + (byte)((id>>21)&0x1f), + '@' + (byte)((id>>16)&0x1f), + hexToASCII(id >> 12), + hexToASCII(id >> 8), + hexToASCII(id >> 4), + hexToASCII(id), + } + + kfmt.Fprintf(w, " [EISA: \"%s\"]", eisaID[:]) + } + case []byte: + + kfmt.Fprintf(w, " -> [bytelist value; len: %d; data: [", len(v)) + for i, b := range v { + if i != 0 { + kfmt.Fprintf(w, ", ") + } + kfmt.Fprintf(w, "0x%x", uint8(b)) + } + kfmt.Fprintf(w, "]]") + } + } + + kfmt.Fprintf(w, "\n") + + padLen := padBuf.Len() + if curObj.nextSiblingIndex == InvalidIndex { + padBuf.WriteByte(' ') + } else { + padBuf.WriteByte('|') + } + padBuf.WriteByte(' ') + padBuf.WriteByte(' ') + + for argIndex := curObj.firstArgIndex; argIndex != InvalidIndex; argIndex = tree.ObjectAt(argIndex).nextSiblingIndex { + tree.toString(w, padBuf, argIndex) + } + + padBuf.Truncate(padLen) +} + +func hexToASCII(val uint32) byte { + v := byte(val & 0xf) + if v <= 9 { + return '0' + v + } + + return 'A' + (v - 0xa) +} + +func nameOf(obj *Object) []byte { + var nameStartIndex, nameEndIndex int + for ; nameStartIndex < amlNameLen; nameStartIndex++ { + if ch := obj.name[nameStartIndex]; (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_' || ch == '\\' { + break + } + } + for nameEndIndex = nameStartIndex; nameEndIndex < amlNameLen; nameEndIndex++ { + if ch := obj.name[nameEndIndex]; !((ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_' || ch == '\\') { + break + } + } + + if nameStartIndex != amlNameLen { + return obj.name[nameStartIndex:nameEndIndex] + } + + return nil +} diff --git a/src/gopheros/device/acpi/aml/obj_tree_test.go b/src/gopheros/device/acpi/aml/obj_tree_test.go new file mode 100644 index 0000000..fb488a0 --- /dev/null +++ b/src/gopheros/device/acpi/aml/obj_tree_test.go @@ -0,0 +1,434 @@ +package aml + +import ( + "fmt" + "testing" +) + +func TestTreeObjectAt(t *testing.T) { + tree := NewObjectTree() + + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpIntScopeBlock, 1) + + tree.append(root, obj1) + + if got := tree.ObjectAt(obj1.index); got != obj1 { + t.Fatalf("expected to get back obj1; got %#+v", got) + } + + if got := tree.ObjectAt(obj1.index + 1); got != nil { + t.Fatalf("expected to get nil; got %#+v", got) + } + + tree.free(obj1) + if got := tree.ObjectAt(obj1.index); got != nil { + t.Fatalf("expected to get back nil after freeing obj1; got %#+v", got) + } +} + +func TestTreeFreelist(t *testing.T) { + tree := NewObjectTree() + + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpIntScopeBlock, 1) + obj2 := tree.newObject(pOpIntScopeBlock, 2) + obj3 := tree.newObject(pOpIntScopeBlock, 3) + + tree.append(root, obj1) + tree.append(root, obj2) + tree.append(root, obj3) + + // By freeing these objects they will be re-used by the following NewObject + // calls in LIFO order. + obj2Index := obj2.index + obj3Index := obj3.index + tree.free(obj3) + tree.free(obj2) + + newObj := tree.newObject(pOpIntScopeBlock, 4) + if newObj.index != obj2Index { + t.Errorf("expected object index to be %d; got %d", obj2Index, newObj.index) + } + + newObj = tree.newObject(pOpIntScopeBlock, 4) + if newObj.index != obj3Index { + t.Errorf("expected object index to be %d; got %d", obj3Index, newObj.index) + } + + if tree.freeListHeadIndex != InvalidIndex { + t.Errorf("expected free list head index to be InvalidIndex; got %d", tree.freeListHeadIndex) + } +} + +func TestTreeFreelistPanic(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(42) + + defer func() { + expErr := "aml.ObjectTree: attempted to free object that still contains argument references" + if err := recover(); err != expErr { + t.Fatalf("expected call to Free to panic with: %s; got: %v", expErr, err) + } + }() + + // Call should panic as root contains argument references + tree.free(tree.ObjectAt(0)) +} + +func TestTreeAppend(t *testing.T) { + tree := NewObjectTree() + + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpIntScopeBlock, 1) + obj2 := tree.newObject(pOpIntScopeBlock, 2) + obj3 := tree.newObject(pOpIntScopeBlock, 3) + + if root.firstArgIndex != InvalidIndex || root.lastArgIndex != InvalidIndex { + t.Fatal("expected root First/Last arg indices to be InvalidIndex") + } + + tree.append(root, obj1) + if root.firstArgIndex != obj1.index || root.lastArgIndex != obj1.index { + t.Fatal("expected root First/Last arg indices to point to obj1") + } + + if obj1.parentIndex != root.index { + t.Fatal("expected obj1 parent index to point to root") + } + + if obj1.firstArgIndex != InvalidIndex || obj1.lastArgIndex != InvalidIndex { + t.Fatal("expected obj1 First/Last arg indices to be InvalidIndex") + } + + // Attach the remaining pointers and follow the links both ways + tree.append(root, obj2) + tree.append(root, obj3) + + visitedObjects := 0 + for i := root.firstArgIndex; i != InvalidIndex; i = tree.ObjectAt(i).nextSiblingIndex { + visitedObjects++ + } + + if want := 3; visitedObjects != want { + t.Fatalf("expected to visit %d objects in left -> right traversal; visited %d", want, visitedObjects) + } + + visitedObjects = 0 + for i := root.lastArgIndex; i != InvalidIndex; i = tree.ObjectAt(i).prevSiblingIndex { + visitedObjects++ + } + + if want := 3; visitedObjects != want { + t.Fatalf("expected to visit %d objects in right -> left traversal; visited %d", want, visitedObjects) + } +} + +func TestTreeAppendAfter(t *testing.T) { + tree := NewObjectTree() + + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpIntScopeBlock, 1) + obj2 := tree.newObject(pOpIntScopeBlock, 2) + obj3 := tree.newObject(pOpIntScopeBlock, 3) + + if root.firstArgIndex != InvalidIndex || root.lastArgIndex != InvalidIndex { + t.Fatal("expected root First/Last arg indices to be InvalidIndex") + } + + tree.append(root, obj1) + + tree.appendAfter(root, obj2, obj1) + tree.appendAfter(root, obj3, obj1) + + expIndexList := []uint32{obj1.index, obj3.index, obj2.index} + + visitedObjects := 0 + for i := root.firstArgIndex; i != InvalidIndex; i = tree.ObjectAt(i).nextSiblingIndex { + if i != expIndexList[visitedObjects] { + t.Fatalf("expected arg %d to have index %d; got %d", visitedObjects, expIndexList[visitedObjects], i) + } + visitedObjects++ + } + + if want := 3; visitedObjects != want { + t.Fatalf("expected to visit %d objects in left -> right traversal; visited %d", want, visitedObjects) + } +} + +func TestTreeDetach(t *testing.T) { + tree := NewObjectTree() + + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpIntScopeBlock, 1) + obj2 := tree.newObject(pOpIntScopeBlock, 2) + obj3 := tree.newObject(pOpIntScopeBlock, 3) + + t.Run("detach in reverse order", func(t *testing.T) { + tree.append(root, obj1) + tree.append(root, obj2) + tree.append(root, obj3) + + tree.detach(root, obj3) + if root.firstArgIndex != obj1.index || root.lastArgIndex != obj2.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj1.index, obj2.index, root.firstArgIndex, root.lastArgIndex) + } + + tree.detach(root, obj2) + if root.firstArgIndex != obj1.index || root.lastArgIndex != obj1.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj1.index, obj1.index, root.firstArgIndex, root.lastArgIndex) + } + + tree.detach(root, obj1) + if root.firstArgIndex != InvalidIndex || root.lastArgIndex != InvalidIndex { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", InvalidIndex, InvalidIndex, root.firstArgIndex, root.lastArgIndex) + } + }) + + t.Run("detach in insertion order", func(t *testing.T) { + tree.append(root, obj1) + tree.append(root, obj2) + tree.append(root, obj3) + + tree.detach(root, obj1) + if root.firstArgIndex != obj2.index || root.lastArgIndex != obj3.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj2.index, obj3.index, root.firstArgIndex, root.lastArgIndex) + } + + tree.detach(root, obj2) + if root.firstArgIndex != obj3.index || root.lastArgIndex != obj3.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj3.index, obj3.index, root.firstArgIndex, root.lastArgIndex) + } + + tree.detach(root, obj3) + if root.firstArgIndex != InvalidIndex || root.lastArgIndex != InvalidIndex { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", InvalidIndex, InvalidIndex, root.firstArgIndex, root.lastArgIndex) + } + }) + + t.Run("detach middle node and then edges", func(t *testing.T) { + tree.append(root, obj1) + tree.append(root, obj2) + tree.append(root, obj3) + + tree.detach(root, obj2) + if root.firstArgIndex != obj1.index || root.lastArgIndex != obj3.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj1.index, obj3.index, root.firstArgIndex, root.lastArgIndex) + } + + if obj1.nextSiblingIndex != obj3.index { + t.Fatalf("expected obj1 NextSiblingIndex to be %d; got %d", obj3.index, obj1.nextSiblingIndex) + } + + if obj3.prevSiblingIndex != obj1.index { + t.Fatalf("expected obj3 PrevSiblingIndex to be %d; got %d", obj1.index, obj3.prevSiblingIndex) + } + + tree.detach(root, obj1) + if root.firstArgIndex != obj3.index || root.lastArgIndex != obj3.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj3.index, obj3.index, root.firstArgIndex, root.lastArgIndex) + } + + tree.detach(root, obj3) + if root.firstArgIndex != InvalidIndex || root.lastArgIndex != InvalidIndex { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", InvalidIndex, InvalidIndex, root.firstArgIndex, root.lastArgIndex) + } + }) +} + +func TestFind(t *testing.T) { + tree, scopeMap := genTestScopes() + + specs := []struct { + curScope uint32 + expr string + want uint32 + }{ + // Search rules do not apply for these cases + { + scopeMap["PCI0"], + `\`, + scopeMap[`\`], + }, + { + scopeMap["PCI0"], + "IDE0_ADR", + scopeMap["_ADR"], + }, + { + scopeMap["IDE0"], + "^^PCI0IDE0_ADR", + scopeMap["_ADR"], + }, + { + scopeMap["IDE0"], + `\_SB_PCI0IDE0_ADR`, + scopeMap["_ADR"], + }, + // Raw multi-segment path (prefix 0x2f, segCount: 3) + { + scopeMap["_ADR"], + fmt.Sprintf("\\%c%c_SB_PCI0IDE0", 0x2f, 0x03), + scopeMap["IDE0"], + }, + { + scopeMap["IDE0"], + `\_SB_PCI0`, + scopeMap["PCI0"], + }, + { + scopeMap["IDE0"], + `^`, + scopeMap["PCI0"], + }, + // Bad queries + { + scopeMap["_SB_"], + "PCI0USB0_CRS", + InvalidIndex, + }, + { + scopeMap["IDE0"], + "^^^^^^^^^^^^^^^^^^^", + InvalidIndex, + }, + { + scopeMap["IDE0"], + `^^^^^^^^^^^FOO`, + InvalidIndex, + }, + { + scopeMap["IDE0"], + "FOO", + InvalidIndex, + }, + { + scopeMap["IDE0"], + "", + InvalidIndex, + }, + // Incomplete multi-segment path (prefix 0x2f, segCount: 3) + { + scopeMap["_ADR"], + fmt.Sprintf("\\%c%c?", 0x2f, 0x03), + InvalidIndex, + }, + // Search rules apply for these cases + { + scopeMap["IDE0"], + "_CRS", + scopeMap["_CRS"], + }, + } + + for specIndex, spec := range specs { + if got := tree.Find(spec.curScope, []byte(spec.expr)); got != spec.want { + t.Errorf("[spec %d] expected lookup to return index %d; got %d", specIndex, spec.want, got) + } + } +} + +func TestNumArgs(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(42) + + if exp, got := uint32(5), tree.NumArgs(tree.ObjectAt(0)); got != exp { + t.Fatalf("expected NumArgs(root) to return %d; got %d", exp, got) + } + + if got := tree.NumArgs(nil); got != 0 { + t.Fatalf("expected NumArgs(nil) to return 0; got %d", got) + } +} + +func TestArgAt(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(42) + + root := tree.ObjectAt(0) + arg0 := tree.ArgAt(root, 0) + expName := [amlNameLen]byte{'_', 'G', 'P', 'E'} + if arg0.name != expName { + t.Errorf("expected ArgAt(root, 0) to return object with name: %s; got: %s", string(expName[:]), string(arg0.name[:])) + } + + if got := tree.ArgAt(root, InvalidIndex); got != nil { + t.Errorf("expected ArgAt(root, InvalidIndex) to return nil; got: %v", got) + } + + if got := tree.ArgAt(nil, 1); got != nil { + t.Fatalf("expected ArgAt(nil, x) to return nil; got %#+v", got) + } +} + +func TestClosestNamedAncestor(t *testing.T) { + tree := NewObjectTree() + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpMethod, 1) + obj2 := tree.newObject(pOpIf, 2) + scope := tree.newObject(pOpScope, 3) + obj3 := tree.newObject(pOpIf, 4) + + tree.append(root, obj1) + tree.append(obj1, obj2) + tree.append(obj2, scope) + tree.append(scope, obj3) + + if got := tree.ClosestNamedAncestor(obj3); got != InvalidIndex { + t.Errorf("expected ClosestNamedAncestor to return InvalidIndex; got %d", got) + } + + // No parent exists + if got := tree.ClosestNamedAncestor(root); got != InvalidIndex { + t.Errorf("expected ClosestNamedAncestor to return InvalidIndex; got %d", got) + } + + // Make the root a non-named object and call ClosestNamedAncestor on its child + root.opcode = pOpAdd + root.infoIndex = pOpcodeTableIndex(root.opcode, false) + if got := tree.ClosestNamedAncestor(obj1); got != InvalidIndex { + t.Errorf("expected ClosestNamedAncestor to return InvalidIndex; got %d", got) + } + + if got := tree.ClosestNamedAncestor(nil); got != InvalidIndex { + t.Fatalf("expected ClosestNamedAncestor(nil) to return InvalidIndex; got %d", got) + } +} + +func genTestScopes() (*ObjectTree, map[string]uint32) { + // Setup the example tree from page 252 of the acpi 6.2 spec + // \ + // SB + // \ + // PCI0 + // | _CRS + // \ + // IDE0 + // | _ADR + + tree := NewObjectTree() + + root := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'\\'}) + pci := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'P', 'C', 'I', '0'}) + ide := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'I', 'D', 'E', '0'}) + sb := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'_', 'S', 'B', '_'}) + + crs := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'_', 'C', 'R', 'S'}) + adr := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'_', 'A', 'D', 'R'}) + + // Setup tree + tree.append(root, sb) + tree.append(sb, pci) + tree.append(pci, crs) + tree.append(pci, ide) + tree.append(ide, adr) + + return tree, map[string]uint32{ + "IDE0": ide.index, + "PCI0": pci.index, + "_SB_": sb.index, + "\\": root.index, + "_ADR": adr.index, + "_CRS": crs.index, + } +} diff --git a/src/gopheros/device/acpi/aml/parser.go b/src/gopheros/device/acpi/aml/parser.go new file mode 100644 index 0000000..9051cd1 --- /dev/null +++ b/src/gopheros/device/acpi/aml/parser.go @@ -0,0 +1,1449 @@ +package aml + +import ( + "gopheros/device/acpi/table" + "gopheros/kernel" + "gopheros/kernel/kfmt" + "io" + "reflect" + "unsafe" +) + +var ( + errParsingAML = &kernel.Error{Module: "acpi_aml_parser", Message: "could not parse AML bytecode"} +) + +type parseResult uint8 +type parseMode uint8 + +const ( + parseResultFailed parseResult = iota + parseResultOk + parseResultShortCircuit + parseResultRequireExtraPass + + parseModeSkipAmbiguousBlocks parseMode = iota + parseModeAllBlocks + + // The maximum number of mergeScopeDirectives - relocateNamedObjects passes + // attempted by the parser to fully resolve static objects. + maxResolvePasses = 5 +) + +// Parser implements a parser for ACPI Machine Language (AML) bytecode. +type Parser struct { + r amlStreamReader + errWriter io.Writer + + tableName string + tableHandle uint8 + + objTree *ObjectTree + scopeStack []uint32 + pkgEndStack []uint32 + streamEnd uint32 + + resolvePasses uint32 + mergedScopes uint32 + relocatedObjects uint32 + + mode parseMode +} + +// NewParser creates a new AML parser instance that attaches parsed AML entities to +// the provided objTree and emits parse errors to errWriter. +func NewParser(errWriter io.Writer, objTree *ObjectTree) *Parser { + return &Parser{ + errWriter: errWriter, + objTree: objTree, + } +} + +// ParseAML attempts to parse the AML byte-code contained in the supplied ACPI +// table tagging each scoped entity with the supplied table handle. +func (p *Parser) ParseAML(tableHandle uint8, tableName string, header *table.SDTHeader) *kernel.Error { + p.init(tableHandle, tableName, header) + + // Parse raw object list starting at the root scope + p.scopeEnter(0) + if p.parseObjectList() == parseResultFailed { + return errParsingAML + } + + // Connect missing args to named objects + if p.connectNamedObjArgs(0) != parseResultOk { + return errParsingAML + } + + // Resolve scope directives for non-executable blocks and relocate named + // objects. These two tasks run in lockstep until both steps report success + // or either reports an error. Running multiple passes is required to deal + // with edge cases like this one: + // Scope (_SB) + // { + // Device(SBRG) + // { + // Name(_HID, 0xf00) + // } + // } + // Scope (_SB ) + // { + // Scope(SBRG) + // { + // Device(^PCIE) + // { + // Name(_HID, 0xba1) + // } + // } + // } + // Scope (_SB) + // { + // Scope(PCIE) + // { + // Name(CRS, Zero) + // } + // } + // + // In this example, calling mergeScopeDirectives will place the PCIE device + // into the SBRG scope. However, the PCIE device must actually be placed in + // the _SB scope due to the ^ prefix in its name. The 3rd block expects to + // find PCIE in the _SB scope and will fail with parseResultRequireExtraPass. + // + // Running relocateNamedObjects immediately after will place the PCIE device + // at the correct location allowing us to run an extra mergeScopeDirectives + // pass to fully resolve the scope directive. + p.resolvePasses = 1 + for ; ; p.resolvePasses++ { + mergeRes := p.mergeScopeDirectives(0) + if mergeRes == parseResultFailed { + return errParsingAML + } + + relocateRes := p.relocateNamedObjects(0) + if relocateRes == parseResultFailed { + return errParsingAML + } + + // Stop if both calls returned OK + if mergeRes == parseResultOk && relocateRes == parseResultOk { + break + } + } + + // Parse deferred blocks + if p.parseDeferredBlocks(0) != parseResultOk { + return errParsingAML + } + + // Resolve method calls + if p.resolveMethodCalls(0) != parseResultOk { + return errParsingAML + } + + // Connect missing args that include method invocations to remaining + // non-named objects + if p.connectNonNamedObjArgs(0) != parseResultOk { + return errParsingAML + } + + return nil +} + +func (p *Parser) init(tableHandle uint8, tableName string, header *table.SDTHeader) { + p.resetState(tableHandle, tableName) + + p.r.Init( + uintptr(unsafe.Pointer(header)), + header.Length, + uint32(unsafe.Sizeof(table.SDTHeader{})), + ) + + // Keep track of the stream end for parsing deferred objects + p.streamEnd = header.Length + _ = p.pushPkgEnd(header.Length) +} + +func (p *Parser) resetState(tableHandle uint8, tableName string) { + p.tableHandle = tableHandle + p.tableName = tableName + p.resolvePasses = 0 + p.mergedScopes = 0 + p.relocatedObjects = 0 + p.mode = parseModeSkipAmbiguousBlocks + + p.scopeStack = nil + p.pkgEndStack = nil + +} + +// parseObjectList tries to parse an AML object list. Object lists are usually +// specified together with a pkgLen block which is used to calculate the max +// read offset that the parser may reach. +func (p *Parser) parseObjectList() parseResult { + for len(p.scopeStack) != 0 { + // Consume up to the current package end + for !p.r.EOF() { + if p.parseNextObject() != parseResultOk { + return parseResultFailed + } + } + + // If the pkgEnd stack matches the scope stack this means the parser + // completed a scoped block and we need to pop it from the stack + if len(p.pkgEndStack) == len(p.scopeStack) { + p.scopeExit() + } + p.popPkgEnd() + } + + return parseResultOk +} + +// parseNextObject tries to parse a single object from the AML stream and +// attach it to the currently active scope. +func (p *Parser) parseNextObject() parseResult { + curOffset := p.r.Offset() + nextOp, res := p.nextOpcode() + if nextOp == pOpNoop { + return parseResultOk + } + + if res == parseResultFailed { + return p.parseNamePathOrMethodCall() + } + + curObj := p.objTree.newObject(nextOp, p.tableHandle) + curObj.amlOffset = curOffset + p.objTree.append(p.scopeCurrent(), curObj) + return p.parseObjectArgs(curObj) +} + +func (p *Parser) parseObjectArgs(curObj *Object) parseResult { + var res parseResult + + // Special case for constants that are used as TermArgs; just read the + // value directly into the supplied curObject + switch curObj.opcode { + case pOpBytePrefix: + curObj.value, res = p.parseNumConstant(1) + case pOpWordPrefix: + curObj.value, res = p.parseNumConstant(2) + case pOpDwordPrefix: + curObj.value, res = p.parseNumConstant(4) + case pOpQwordPrefix: + curObj.value, res = p.parseNumConstant(8) + case pOpStringPrefix: + curObj.value, res = p.parseString() + default: + res = p.parseArgs(&pOpcodeTable[curObj.infoIndex], curObj, 0) + } + + if res == parseResultShortCircuit { + res = parseResultOk + } + + return res +} + +func (p *Parser) parseArgs(info *pOpcodeInfo, curObj *Object, argOffset uint8) parseResult { + var ( + argCount = info.argFlags.argCount() + argObj *Object + res = parseResultOk + ) + + if argCount == 0 { + return parseResultOk + } + + for argIndex := argOffset; argIndex < argCount && res == parseResultOk; argIndex++ { + argObj, res = p.parseArg(info, curObj, info.argFlags.arg(argIndex)) + + // Ignore nil args (e.g. result of parsing a pkgLen) + if argObj != nil { + p.objTree.append(curObj, argObj) + } + } + + return res +} + +func (p *Parser) parseArg(info *pOpcodeInfo, curObj *Object, argType pArgType) (*Object, parseResult) { + switch argType { + case pArgTypeByteData, pArgTypeWordData, pArgTypeDwordData, pArgTypeQwordData, pArgTypeString, pArgTypeNameString: + return p.parseSimpleArg(argType) + case pArgTypeByteList: + argObj := p.objTree.newObject(pOpIntByteList, p.tableHandle) + p.parseByteList(argObj, p.r.pkgEnd-p.r.Offset()) + return argObj, parseResultOk + case pArgTypePkgLen: + origOffset := p.r.Offset() + pkgLen, res := p.parsePkgLength() + if res != parseResultOk { + return nil, res + } + + // If this opcode requires deferred parsing just keep track of + // the package end and skip over it. + if p.mode == parseModeSkipAmbiguousBlocks && (info.flags&pOpFlagDeferParsing != 0) { + curObj.pkgEnd = origOffset + pkgLen + p.r.SetOffset(curObj.pkgEnd) + return nil, parseResultShortCircuit + } + + if err := p.pushPkgEnd(origOffset + pkgLen); err != nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] %s\n", p.tableName, p.r.Offset(), err.Error()) + return nil, parseResultFailed + } + + return nil, parseResultOk + case pArgTypeFieldList: + return nil, p.parseFieldElements(curObj) + case pArgTypeTermArg, pArgTypeDataRefObj: + // A TermObj may contain a method call to a not-yet defined + // method. Since the AML stream does not contain info about + // the number of arguments in method calls the parser cannot + // distinguish where the TermObj actually ends. To work around + // this limitation, the parser will process any object up to + // the current package end and append them as *siblings* to + // curObj. We will then need to perform a second pass to + // properly populate the arguments. + if p.mode == parseModeAllBlocks { + return p.parseStrictTermArg(curObj) + } + + return nil, parseResultShortCircuit + case pArgTypeTermList: + // Create a new scope and shortcircuit the arg parser + scope := p.objTree.newObject(pOpIntScopeBlock, p.tableHandle) + scope.amlOffset = p.r.Offset() + p.scopeEnter(scope.index) + + if p.mode == parseModeSkipAmbiguousBlocks { + return scope, parseResultShortCircuit + } + + // Attach scope to curObj so lookups work and consume all objects till the package end + p.objTree.append(curObj, scope) + for !p.r.EOF() { + if p.parseNextObject() != parseResultOk { + return nil, parseResultFailed + } + } + p.scopeExit() + p.objTree.detach(curObj, scope) + return scope, parseResultOk + default: // pArgTypeTarget, pArgTypeSimpleName, pArgTypeSuperName: + return p.parseTarget() + } +} + +// parseNamePathOrMethodCall is invoked by the parser when it cannot parse an +// opcode from the AML stream. This indicates that the stream may contain +// either a method call or a named path reference. If the current parse mode is +// parseModeAllBlocks the method will return an error if the next term in the +// stream does not match an existing namepath or method name. +func (p *Parser) parseNamePathOrMethodCall() parseResult { + curOffset := p.r.Offset() + + pathExpr, res := p.parseNameString() + if res != parseResultOk { + return parseResultFailed + } + + // During the initial pass we cannot be sure about whether this is actually + // a method name or a named path reference as AML allows for forward decls. + if p.mode == parseModeSkipAmbiguousBlocks { + curObj := p.objTree.newObject(pOpIntNamePathOrMethodCall, p.tableHandle) + curObj.amlOffset = curOffset + curObj.value = pathExpr + p.objTree.append(p.scopeCurrent(), curObj) + return parseResultOk + } + + // Lookup the object pointed to by the path expression + targetIndex := p.objTree.Find( + p.objTree.ClosestNamedAncestor(p.scopeCurrent()), + pathExpr, + ) + + if targetIndex == InvalidIndex { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] unable to resolve path expression %s\n", p.tableName, p.r.Offset(), pathExpr) + return parseResultFailed + } + + target := p.objTree.ObjectAt(targetIndex) + curObj := p.objTree.newObject(pOpIntResolvedNamePath, p.tableHandle) + curObj.amlOffset = curOffset + curObj.value = targetIndex + p.objTree.append(p.scopeCurrent(), curObj) + if target.opcode != pOpMethod { + return parseResultOk + } + + // If target is a method definition we need to make curObj the active scope + // and parse the number of args specified by the definition. + curObj.opcode = pOpIntMethodCall + curObj.infoIndex = pOpcodeTableIndex(curObj.opcode, true) + p.scopeEnter(curObj.index) + + argCount := uint8(p.objTree.ArgAt(target, 1).value.(uint64) & 0x7) + for argIndex := uint8(0); argIndex < argCount; argIndex++ { + if p.parseNextObject() != parseResultOk { + p.scopeExit() + return parseResultFailed + } + } + p.scopeExit() + return parseResultOk +} + +// parseStrictTermObj attempts to parse a TermArg from the stream using the +// strict grammar definitions from p. 1022 of the spec. As TermArgs may also +// contain method invocations, parseStrictTermArg must only be called after +// all static scope directives have been fully evaluated. +// +// Grammar: +// TermArg := Type2Opcode | DataObject | ArgObj | LocalObj +func (p *Parser) parseStrictTermArg(curObj *Object) (*Object, parseResult) { + var ( + termObj *Object + curOffset = p.r.Offset() + ) + + nextOp, res := p.peekNextOpcode() + if res != parseResultOk { + // make curObj the active scope so that lookups can work and parse a + // method call. + p.scopeEnter(curObj.index) + res = p.parseNamePathOrMethodCall() + p.scopeExit() + + // parseNamePathOrMethodCall will append the parsed object to the scope + // so we need to detach it. + if res == parseResultOk { + termObj = p.objTree.ObjectAt(curObj.lastArgIndex) + p.objTree.detach(curObj, termObj) + } + + if p.r.EOF() { + p.popPkgEnd() + } + return termObj, res + } + + if !pOpIsType2(nextOp) && !pOpIsDataObject(nextOp) && !pOpIsArg(nextOp) { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] encountered unexpected opcode %s while parsing termArg\n", p.tableName, p.r.Offset(), pOpcodeName(nextOp)) + return nil, parseResultFailed + } + + _, _ = p.nextOpcode() + termObj = p.objTree.newObject(nextOp, p.tableHandle) + termObj.amlOffset = curOffset + res = p.parseObjectArgs(termObj) + if p.r.EOF() { + p.popPkgEnd() + } + + return termObj, res +} + +func (p *Parser) parseSimpleArg(argType pArgType) (*Object, parseResult) { + var ( + obj = p.objTree.newObject(0, p.tableHandle) + res parseResult + ) + + obj.amlOffset = p.r.Offset() + + switch argType { + case pArgTypeByteData: + obj.opcode = pOpBytePrefix + obj.value, res = p.parseNumConstant(1) + case pArgTypeWordData: + obj.opcode = pOpWordPrefix + obj.value, res = p.parseNumConstant(2) + case pArgTypeDwordData: + obj.opcode = pOpDwordPrefix + obj.value, res = p.parseNumConstant(4) + case pArgTypeQwordData: + obj.opcode = pOpQwordPrefix + obj.value, res = p.parseNumConstant(8) + case pArgTypeString: + obj.opcode = pOpStringPrefix + obj.value, res = p.parseString() + case pArgTypeNameString: + obj.opcode = pOpIntNamePath + obj.value, res = p.parseNameString() + default: + return nil, parseResultFailed + } + + obj.infoIndex = pOpcodeTableIndex(obj.opcode, true) + return obj, res +} + +// parseTarget attempts to pass a Target from the AML bytestream. +// +// Grammar: +// Target := SuperName | NullName +// NullName := 0x00 +// SuperName := SimpleName | DebugObj | Type6Opcode +// Type6Opcode := DefRefOf | DefDerefOf | DefIndex | UserTermObj +// SimpleName := NameString | ArgObj | LocalObj +// +// UserTermObj is a control method invocation. +func (p *Parser) parseTarget() (*Object, parseResult) { + // Peek next opcode + origOffset := p.r.Offset() + nextOp, res := p.nextOpcode() + + if res == parseResultOk { + switch { + case nextOp == pOpZero: // NullName == no target + return nil, parseResultOk + case pOpIsArg(nextOp) || + nextOp == pOpRefOf || nextOp == pOpDerefOf || + nextOp == pOpIndex || nextOp == pOpDebug: + // This is a SuperName or a Type6Opcode + obj := p.objTree.newObject(nextOp, p.tableHandle) + obj.amlOffset = origOffset + return obj, p.parseObjectArgs(obj) + default: + // Unexpected opcode + return nil, parseResultFailed + } + } + + // In this case, this is either a method call or a named reference. Just + // like in parseObjectList we assume it's a named reference. + p.r.SetOffset(origOffset) + curObj := p.objTree.newObject(pOpIntNamePath, p.tableHandle) + curObj.amlOffset = origOffset + curObj.value, res = p.parseNameString() + return curObj, res +} + +// parseFieldElements parses a list of named field elements from the AML stream. +// +// FieldList := | FieldElement FieldList +// FieldElement := NamedField | ReservedField | AccessField | ExtendedAccessField | ConnectField +// NamedField := NameSeg PkgLength +// ReservedField := 0x00 PkgLength +// AccessField := 0x1 AccessType AccessAttrib +// ConnectField := 0x02 NameString | 0x02 BufferData +// ExtendedAccessField := 0x3 AccessType ExtendedAccessAttrib AccessLength +func (p *Parser) parseFieldElements(curObj *Object) parseResult { + var ( + nextFieldOffset uint32 + accessLength uint8 + accessType uint8 + accessAttrib uint8 + lockType uint8 + updateType uint8 + + field *Object + connection, connArg *Object + appendAfter = curObj + connectionIndex = InvalidIndex + + next uint8 + nextOp uint16 + err error + value uint64 + pkgLen uint32 + parseRes parseResult + ) + + // Initialize default flags based on the default flags of curObj + initialFlags := uint8(p.objTree.ObjectAt(curObj.lastArgIndex).value.(uint64)) + accessType = initialFlags & 0xf // bits [0:3] + lockType = (initialFlags >> 4) & 0x1 // bits [4:4] + updateType = (initialFlags >> 5) & 0x3 // bits [5:6] + + for !p.r.EOF() { + next, _ = p.r.ReadByte() + + switch next { + case 0x00: // ReservedField + if pkgLen, parseRes = p.parsePkgLength(); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse pkgLen for ReservedField element\n", p.tableName, p.r.Offset()) + return parseResultFailed + } + + nextFieldOffset += pkgLen + case 0x01: // AccessField: change default access type for fields that follow + if value, parseRes = p.parseNumConstant(1); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse AccessType for AccessField element\n", p.tableName, p.r.Offset()) + return parseRes + } + + accessType = uint8(value & 0xff) // bits [0:7] + + if value, parseRes = p.parseNumConstant(1); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse AccessAttrib for AccessField element\n", p.tableName, p.r.Offset()) + return parseRes + } + + accessAttrib = uint8(value & 0xff) // bits [0:7] + case 0x03: // ExtAccessField + if value, parseRes = p.parseNumConstant(1); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse AccessType for ExtAccessField element\n", p.tableName, p.r.Offset()) + return parseRes + } + + accessType = uint8(value & 0xff) // bits [0:7] + + if value, parseRes = p.parseNumConstant(1); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse AccessAttrib for ExtAccessField element\n", p.tableName, p.r.Offset()) + return parseRes + } + + accessAttrib = uint8(value & 0xff) // bits [0:7] + + if value, parseRes = p.parseNumConstant(1); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse AccessLength for ExtAccessField element\n", p.tableName, p.r.Offset()) + return parseRes + } + + accessLength = uint8(value & 0xff) // bits [0:7] + case 0x02: // Connection + // Connection can be either a namestring or a buffer + next, err = p.r.ReadByte() + if err != nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] unexpected end of stream while parsing Connection\n", p.tableName, p.r.Offset()) + return parseResultFailed + } + + connection = p.objTree.newObject(pOpIntConnection, p.tableHandle) + connectionIndex = connection.index + p.objTree.append(curObj, connection) + + switch next { + case uint8(pOpBuffer): + origPkgEnd := p.r.pkgEnd + origOffset := p.r.Offset() + if pkgLen, parseRes = p.parsePkgLength(); parseRes != parseResultOk { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse pkgLen for Connection\n", p.tableName, p.r.Offset()) + return parseRes + } + + dataLen := uint64(0) + if pkgLen > 0 { + if err = p.r.SetPkgEnd(origOffset + pkgLen); err != nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] failed to set pkgEnd for Buffer\n", p.tableName, p.r.Offset()) + return parseResultFailed + } + + if nextOp, parseRes = p.nextOpcode(); parseRes != parseResultOk { + return parseRes + } + + // Read data length + parseRes = parseResultOk + + switch nextOp { + case pOpBytePrefix: + dataLen, parseRes = p.parseNumConstant(1) + case pOpWordPrefix: + dataLen, parseRes = p.parseNumConstant(2) + case pOpDwordPrefix: + dataLen, parseRes = p.parseNumConstant(4) + } + + if parseRes == parseResultFailed { + return parseRes + } + } + + connArg = p.objTree.newObject(pOpIntByteList, p.tableHandle) + connArg.amlOffset = origOffset + p.parseByteList(connArg, uint32(dataLen)) + + // Restore previous pkg end and jump to end of buffer package + _ = p.r.SetPkgEnd(origPkgEnd) + p.r.SetOffset(origOffset + pkgLen) + default: + // unread first byte of namepath + _ = p.r.UnreadByte() + connArg = p.objTree.newObject(pOpIntNamePath, p.tableHandle) + connArg.amlOffset = p.r.Offset() + if connArg.value, parseRes = p.parseNameString(); parseRes != parseResultOk { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse namestring for Connection\n", p.tableName, p.r.Offset()) + return parseRes + } + } + + p.objTree.append(connection, connArg) + default: + // This is a named field and next is the first part of its name. We need + // to rewind the stream + _ = p.r.UnreadByte() + + field = p.objTree.newObject(pOpIntNamedField, p.tableHandle) + field.amlOffset = p.r.Offset() + for i := 0; i < amlNameLen; i++ { + if field.name[i], err = p.r.ReadByte(); err != nil { + return parseResultFailed + } + } + + if pkgLen, parseRes = p.parsePkgLength(); parseRes != parseResultOk { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse pkgLen for NamedField\n", p.tableName, p.r.Offset()) + return parseRes + } + + // Populate field element and attach field object + field.value = &fieldElement{ + offset: nextFieldOffset, + width: pkgLen, + accessLength: accessLength, + accessType: accessType, + accessAttrib: accessAttrib, + lockType: lockType, + updateType: updateType, + connectionIndex: connectionIndex, + fieldIndex: curObj.index, + } + + // According to the spec, field elements appear at the same scope as + // their Field/IndexField/BankField container + p.objTree.appendAfter(p.objTree.ObjectAt(curObj.parentIndex), field, appendAfter) + appendAfter = field + + // Calculate offset for next field + nextFieldOffset += pkgLen + } + } + + // Skip to the end of the arg list for the current field object + return parseResultShortCircuit +} + +func (p *Parser) parseByteList(obj *Object, dataLen uint32) { + obj.opcode = pOpIntByteList + obj.infoIndex = pOpcodeTableIndex(obj.opcode, true) + obj.value = *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{ + Len: int(dataLen), + Cap: int(dataLen), + Data: p.r.DataPtr(), + })) + + p.r.SetOffset(p.r.Offset() + dataLen) +} + +// parsePkgLength parses a PkgLength value from the AML bytestream. +func (p *Parser) parsePkgLength() (uint32, parseResult) { + origOffset := p.r.Offset() + lead, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + // The high 2 bits of the lead byte indicate how many bytes follow. + var pkgLen uint32 + switch lead >> 6 { + case 0: + pkgLen = uint32(lead) + case 1: + b1, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + // lead bits 0-3 are the lsb of the length nybble + pkgLen = uint32(b1)<<4 | uint32(lead&0xf) + case 2: + b1, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + b2, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + // lead bits 0-3 are the lsb of the length nybble + pkgLen = uint32(b2)<<12 | uint32(b1)<<4 | uint32(lead&0xf) + case 3: + b1, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + b2, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + b3, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + // lead bits 0-3 are the lsb of the length nybble + pkgLen = uint32(b3)<<20 | uint32(b2)<<12 | uint32(b1)<<4 | uint32(lead&0xf) + } + + return pkgLen, parseResultOk +} + +// parseNumConstant parses a byte/word/dword or qword value from the AML bytestream. +func (p *Parser) parseNumConstant(numBytes uint8) (uint64, parseResult) { + var ( + next byte + err error + res uint64 + ) + + for c := uint8(0); c < numBytes; c++ { + if next, err = p.r.ReadByte(); err != nil { + return 0, parseResultFailed + } + + res = res | (uint64(next) << (8 * c)) + } + + return res, parseResultOk +} + +// parseString parses a string from the AML bytestream and returns back a +// []byte pointing at its contents. +func (p *Parser) parseString() ([]byte, parseResult) { + // Read ASCII chars till we reach a null byte + var ( + next byte + err error + res = parseResultOk + str = reflect.SliceHeader{Data: p.r.DataPtr()} + ) + + for { + next, err = p.r.ReadByte() + if err != nil { + res = parseResultFailed + break + } + + if next == 0x00 { + break + } else if next >= 0x01 && next <= 0x7f { // AsciiChar + str.Len++ + } else { + res = parseResultFailed + break + } + } + + str.Cap = str.Len + return *(*[]byte)(unsafe.Pointer(&str)), res +} + +// parseNameString parses a NameString from the AML bytestream and returns back +// a []byte pointing at its contents. +// +// Grammar: +// NameString := RootChar NamePath | PrefixPath NamePath +// PrefixPath := Nothing | '^' PrefixPath +// NamePath := NameSeg | DualNamePath | MultiNamePath | NullName +func (p *Parser) parseNameString() ([]byte, parseResult) { + var ( + res = parseResultOk + str = reflect.SliceHeader{Data: p.r.DataPtr()} + next byte + err error + startOffset = p.r.Offset() + endOffset uint32 + ) + + // Skip over RootChar ('\') and Caret ('^') prefixes + for { + if next, err = p.r.PeekByte(); err != nil { + return nil, parseResultFailed + } + + if next != '\\' && next != '^' { + break + } + + _, _ = p.r.ReadByte() + } + + // Decode NamePath; note: the for loop above has already checked whether the + // next byte is readable via the call to PeekByte. This call to read will + // never error. + next, _ = p.r.ReadByte() + + switch next { + case 0x00: // NullName (null string or a name terminator) + startOffset = p.r.Offset() + // return empty string + case 0x2e: // DualNamePath := DualNamePrefix NameSeg NameSeg + endOffset = p.r.Offset() + uint32(amlNameLen*2) + if endOffset > p.r.pkgEnd { + return nil, parseResultFailed + } + p.r.SetOffset(endOffset) + case 0x2f: // MultiNamePath := MultiNamePrefix SegCount NameSeg(SegCount) + segCount, err := p.r.ReadByte() + if segCount == 0 || err != nil { + return nil, parseResultFailed + } + + endOffset = p.r.Offset() + uint32(amlNameLen*segCount) + if endOffset > p.r.pkgEnd { + return nil, parseResultFailed + } + + p.r.SetOffset(endOffset) + default: // NameSeg := LeadNameChar NameChar NameChar NameChar + // LeadNameChar := 'A' - 'Z' | '_' + if (next < 'A' || next > 'Z') && next != '_' { + return nil, parseResultFailed + } + + endOffset = p.r.Offset() + uint32(amlNameLen-1) + if endOffset > p.r.pkgEnd { + return nil, parseResultFailed + } + + // Skip past the remaning amlNameLen-1 chars + p.r.SetOffset(endOffset) + } + + str.Len = int(p.r.Offset() - startOffset) + str.Cap = str.Len + return *(*[]byte)(unsafe.Pointer(&str)), res +} + +// peekNextOpcode returns the next opcode in the stream without advancing the +// stream pointer. +func (p *Parser) peekNextOpcode() (uint16, parseResult) { + curOffset := p.r.Offset() + op, res := p.nextOpcode() + p.r.SetOffset(curOffset) + + return op, res +} + +// nextOpcode decodes an AML opcode from the stream. +func (p *Parser) nextOpcode() (uint16, parseResult) { + var ( + opLen uint32 = 1 + op uint16 + ) + + next, err := p.r.ReadByte() + if err != nil { + return 0xffff, parseResultFailed + } + + op = uint16(next) + + if next == extOpPrefix { + op = 0xff + if next, err = p.r.ReadByte(); err != nil { + _ = p.r.UnreadByte() + return 0xffff, parseResultFailed + } + + opLen++ + op += uint16(next) + } + + // If this is not a valid opcode, rewind the stream. + if pOpcodeTableIndex(op, false) == badOpcode { + p.r.SetOffset(p.r.Offset() - opLen) + return 0xffff, parseResultFailed + } + + return op, parseResultOk +} + +// scopeCurrent returns the currently active scope. +func (p *Parser) scopeCurrent() *Object { + return p.objTree.ObjectAt(p.scopeStack[len(p.scopeStack)-1]) +} + +// scopeEnter enters the given scope. +func (p *Parser) scopeEnter(index uint32) { + p.scopeStack = append(p.scopeStack, index) +} + +// scopeExit exits the current scope. +func (p *Parser) scopeExit() { + p.scopeStack = p.scopeStack[:len(p.scopeStack)-1] +} + +func (p *Parser) pushPkgEnd(pkgEnd uint32) error { + p.pkgEndStack = append(p.pkgEndStack, pkgEnd) + return p.r.SetPkgEnd(pkgEnd) +} + +func (p *Parser) popPkgEnd() { + // Pop pkg end if one exists + if len(p.pkgEndStack) != 0 { + p.pkgEndStack = p.pkgEndStack[:len(p.pkgEndStack)-1] + } + + // If the stack is not empty restore the last pushed pkgEnd + if len(p.pkgEndStack) != 0 && len(p.pkgEndStack) != 0 { + _ = p.r.SetPkgEnd(p.pkgEndStack[len(p.pkgEndStack)-1]) + } +} + +// connectNamedObjArgs visits each named object in the AML tree and populates +// any missing args by consuming the object's siblings. +func (p *Parser) connectNamedObjArgs(objIndex uint32) parseResult { + var ( + obj = p.objTree.ObjectAt(objIndex) + argObj *Object + argFlags pOpArgTypeList + argCount uint8 + termArgIndex uint8 + namepath []byte + nameIndex int + ok bool + ) + + // The arg list must be visited in reverse order to handle nesting + for argIndex := obj.lastArgIndex; argIndex != InvalidIndex; argIndex = argObj.prevSiblingIndex { + // Recursively process children first + argObj = p.objTree.ObjectAt(argIndex) + if p.connectNamedObjArgs(argObj.index) != parseResultOk { + return parseResultFailed + } + + // Ignore non-named objects and objects not defined by the table currently parsed + if pOpcodeTable[argObj.infoIndex].flags&pOpFlagNamed == 0 || argObj.tableHandle != p.tableHandle || argObj.firstArgIndex == InvalidIndex || argObj.opcode == pOpIntScopeBlock { + continue + } + + // Named opcodes contain a namepath as the first arg + if namepath, ok = p.objTree.ObjectAt(argObj.firstArgIndex).value.([]byte); !ok { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] named object of type %s without a valid name\n", p.tableName, argObj.amlOffset, pOpcodeName(argObj.opcode)) + return parseResultFailed + } + + // The last amlNameLen part of the namepath contains the name for this object + if nameIndex = len(namepath) - amlNameLen; nameIndex < 0 { + return parseResultFailed + } + for i := 0; i < amlNameLen; i++ { + argObj.name[i] = namepath[nameIndex+i] + } + + // Check if this object's args specify a TermObj/DataRefObj which + // would cause the parser to consume any object found till the + // enclosing package end. + argFlags = pOpcodeTable[argObj.infoIndex].argFlags + argCount = argFlags.argCount() + for termArgIndex = 0; termArgIndex < argCount; termArgIndex++ { + if argType := argFlags.arg(termArgIndex); argType == pArgTypeTermArg || argType == pArgTypeDataRefObj { + break + } + } + + // All args connected OR no term args; assume object has been completely parsed + if p.objTree.NumArgs(argObj) == uint32(argCount) || termArgIndex >= argCount { + continue + } + + // The parser has already attached args [0, termArgIndex) to + // the object and has parsed the remaining args as siblings to + // the object. Detach the missing args from the sibling list and + // attach them to object. + if p.attachSiblingsAsArgs(obj, argObj, argCount-termArgIndex, false) != parseResultOk { + return parseResultFailed + } + } + + return parseResultOk +} + +// mergeScopeDirectives visits pOpScope objects inside non-executable blocks +// and attempts to merge their contents to the scope referenced by the Scope +// directive. +func (p *Parser) mergeScopeDirectives(objIndex uint32) parseResult { + var ( + res = parseResultOk + obj = p.objTree.ObjectAt(objIndex) + firstArgIndex = obj.firstArgIndex + ) + + if objIndex == 0 { + p.mergedScopes = 0 + } + + // Ignore executable section contents + if pOpcodeTable[obj.infoIndex].flags&pOpFlagExecutable != 0 { + return res + } + + if obj.opcode == pOpScope && obj.tableHandle == p.tableHandle { + if obj.firstArgIndex == InvalidIndex { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] malformed scope object\n", p.tableName, obj.amlOffset) + return parseResultFailed + } + + // Lookup target and make sure it resolves to a scoped object + nameObj := p.objTree.ObjectAt(obj.firstArgIndex) + targetName := nameObj.value.([]byte) + targetIndex := p.objTree.Find(obj.parentIndex, targetName) + + // If the lookup failed we may need to run a couple more mergeScopeDirectives / + // relocateNamedObjects passes to resolve things. If however no objects got + // relocated in the previous pass then report this as an error. + if targetIndex == InvalidIndex { + if p.resolvePasses > 1 && p.relocatedObjects == 0 { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] unable to resolve reference to scope \"%s\"\n", p.tableName, obj.amlOffset, targetName) + return parseResultFailed + } + return parseResultRequireExtraPass + } + + // Unless the new parent is an pOpIntScopeBlock it will contain a nested + // pOpIntScopeBlock which is where we should actually attach obj + targetObj := p.objTree.ObjectAt(targetIndex) + if targetObj.opcode != pOpIntScopeBlock { + for targetIndex, targetObj = targetObj.firstArgIndex, nil; targetIndex != InvalidIndex; targetIndex = p.objTree.ObjectAt(targetIndex).nextSiblingIndex { + if nextObj := p.objTree.ObjectAt(targetIndex); nextObj.opcode == pOpIntScopeBlock { + targetObj = nextObj + break + } + } + + if targetObj == nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] reference to scope \"%s\" resolved to non-scope object\n", p.tableName, obj.amlOffset, targetName) + return parseResultFailed + } + } + + // Relocate contents to the new scope + contentsObj := p.objTree.ObjectAt(obj.lastArgIndex) + firstArgIndex = contentsObj.firstArgIndex + for siblingIndex := firstArgIndex; siblingIndex != InvalidIndex; { + argObj := p.objTree.ObjectAt(siblingIndex) + siblingIndex = argObj.nextSiblingIndex + + p.objTree.detach(contentsObj, argObj) + p.objTree.append(targetObj, argObj) + } + + // The scope object and its children can now be freed + p.objTree.free(nameObj) + p.objTree.free(contentsObj) + p.objTree.free(obj) + p.mergedScopes++ + } + + // Recursively process nested objects + for siblingIndex := firstArgIndex; siblingIndex != InvalidIndex; { + argObj := p.objTree.ObjectAt(siblingIndex) + siblingIndex = argObj.nextSiblingIndex + + switch p.mergeScopeDirectives(argObj.index) { + case parseResultFailed: + return parseResultFailed + case parseResultRequireExtraPass: + res = parseResultRequireExtraPass + } + } + + return res +} + +// relocateNamedObjects processes named objects whose name contains a relative +// or absolute path prefix and moves the objects to the appropriate parent. +func (p *Parser) relocateNamedObjects(objIndex uint32) parseResult { + var ( + obj = p.objTree.ObjectAt(objIndex) + flags = pOpcodeTable[obj.infoIndex].flags + argObj, targetObj *Object + targetIndex uint32 + nameIndex int + namepath []byte + ok bool + res = parseResultOk + ) + + if objIndex == 0 { + p.relocatedObjects = 0 + } + + // Ignore executable section contents + if flags&pOpFlagExecutable != 0 { + return res + } + + if flags&pOpFlagNamed != 0 && obj.firstArgIndex != InvalidIndex && obj.tableHandle == p.tableHandle && obj.opcode != pOpIntScopeBlock { + // This is a named object. Check if its namepath requires relocation + if namepath, ok = p.objTree.ObjectAt(obj.firstArgIndex).value.([]byte); !ok { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] named object of type %s without a valid name\n", p.tableName, obj.amlOffset, pOpcodeName(obj.opcode)) + return parseResultFailed + } + + // If the namepath is longer than amlNameLen then it's a scoped path + // expression that needs to be resolved using the closest named ancestor as + // the scope. If the resolve succeeds, the object will be attached to the + // resolved parent and the namepath will be cleaned up. + if nameIndex = len(namepath) - amlNameLen; nameIndex > 0 { + targetIndex = p.objTree.Find(p.objTree.ClosestNamedAncestor(obj), namepath[:nameIndex]) + if targetIndex == InvalidIndex { + if p.resolvePasses > maxResolvePasses { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] unable to resolve relocation path %s for object of type %s after %d passes; aborting\n", p.tableName, obj.amlOffset, namepath[:], pOpcodeName(obj.opcode), p.resolvePasses) + return parseResultFailed + } + return parseResultRequireExtraPass + } + + targetObj = p.objTree.ObjectAt(targetIndex) + if targetObj.opcode != pOpIntScopeBlock { + for targetIndex, targetObj = targetObj.firstArgIndex, nil; targetIndex != InvalidIndex; targetIndex = p.objTree.ObjectAt(targetIndex).nextSiblingIndex { + if nextObj := p.objTree.ObjectAt(targetIndex); nextObj.opcode == pOpIntScopeBlock { + targetObj = nextObj + break + } + } + + if targetObj == nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] relocation path \"%s\" resolved to non-scope object\n", p.tableName, obj.amlOffset, namepath[:]) + return parseResultFailed + } + } + p.objTree.detach(p.objTree.ObjectAt(obj.parentIndex), obj) + p.objTree.append(targetObj, obj) + p.objTree.ObjectAt(obj.firstArgIndex).value = namepath[nameIndex:] + p.relocatedObjects++ + } + } + + // Recursively process nested objects + for siblingIndex := obj.firstArgIndex; siblingIndex != InvalidIndex; { + argObj = p.objTree.ObjectAt(siblingIndex) + siblingIndex = argObj.nextSiblingIndex + + switch p.relocateNamedObjects(argObj.index) { + case parseResultFailed: + return parseResultFailed + case parseResultRequireExtraPass: + res = parseResultRequireExtraPass + } + } + + return res +} + +// parseDeferredBlocks attempts to parse any objects that contain objects that +// are flagged as deferred (e.g. Buffers and BankFields). +func (p *Parser) parseDeferredBlocks(objIndex uint32) parseResult { + obj := p.objTree.ObjectAt(objIndex) + if pOpcodeTable[obj.infoIndex].flags&pOpFlagDeferParsing != 0 && obj.tableHandle == p.tableHandle { + p.mode = parseModeAllBlocks + + // Set stream offset to the first arg + p.r.SetPkgEnd(p.streamEnd) + p.r.SetOffset(obj.amlOffset + 1) + if obj.opcode > 0xff { // opcode length = 2 + _, _ = p.r.ReadByte() + } + + if p.parseObjectArgs(obj) != parseResultOk { + return parseResultFailed + } + + // As we are using a different parse flow than the one used for + // non-deferred we need to manually clean up the pkgEndStack after the + // object has been parsed. + for len(p.pkgEndStack) != 0 { + p.popPkgEnd() + } + + // The parseObjectArgs() call has parsed all children of the deferred node. + // At this point we can simply return without processing the children. + return parseResultOk + } + + // Recursively process children + for argIndex := obj.firstArgIndex; argIndex != InvalidIndex; argIndex = p.objTree.ObjectAt(argIndex).nextSiblingIndex { + if p.parseDeferredBlocks(argIndex) != parseResultOk { + return parseResultFailed + } + } + + return parseResultOk +} + +// connectNonNamedObjArgs behaves in a similar way as connectNamedObjArgs but +// only operates on non-named objects. +func (p *Parser) connectNonNamedObjArgs(objIndex uint32) parseResult { + var ( + obj = p.objTree.ObjectAt(objIndex) + argObj *Object + argFlags pOpArgTypeList + argCount uint8 + termArgIndex uint8 + ) + + // The arg list must be visited in reverse order to handle nesting + for argIndex := obj.lastArgIndex; argIndex != InvalidIndex; argIndex = argObj.prevSiblingIndex { + // Recursively process children first + argObj = p.objTree.ObjectAt(argIndex) + if p.connectNonNamedObjArgs(argObj.index) != parseResultOk { + return parseResultFailed + } + + // Ignore named objects and objects not defined by the table currently parsed + if pOpcodeTable[argObj.infoIndex].flags&pOpFlagNamed != 0 || argObj.tableHandle != p.tableHandle { + continue + } + + // Check if this object's args specify a TermObj/DataRefObj which + // would cause the parser to consume any object found till the + // enclosing package end. + argFlags = pOpcodeTable[argObj.infoIndex].argFlags + argCount = argFlags.argCount() + for termArgIndex = 0; termArgIndex < argCount; termArgIndex++ { + if argType := argFlags.arg(termArgIndex); argType == pArgTypeTermArg || argType == pArgTypeDataRefObj { + break + } + } + + // No term args OR we have parsed beyond the TermArg; assume object has been completely parsed + if termArgIndex >= argCount || p.objTree.NumArgs(argObj) > uint32(termArgIndex) { + continue + } + + // The parser has already attached args [0, termArgIndex) to + // the object and has parsed the remaining args as siblings to + // the object. Detach the missing args from the sibling list and + // attach them to object. The following call may also return back + // parseResultRequireExtraPass which is OK at this stage. + if p.attachSiblingsAsArgs(obj, argObj, argCount-termArgIndex, true) == parseResultFailed { + return parseResultFailed + } + } + + return parseResultOk +} + +// resolveMethodCalls visits each object with the pOpIntNamePathOrMethodCall +// opcode and resolves it to either a pOpIntMethodCall or a pOpIntNamePath based +// on the result of a lookup using the attached namepath. +// +// If the namepath lookup resolves into a method definition, the object will be +// mutated into an pOpIntMethodCall and the expected number of arguments (as +// specified by the referenced method) will be extracted from the object's +// sibling list. +// +// If the nemepath resolves into a non-method object then the object will be +// instead mutated into an pOpIntResolvedNamePath. +// +// If the lookup fails, then the object will be mutated into an pOpIntNamePath +// to be resolved at run-time. +func (p *Parser) resolveMethodCalls(objIndex uint32) parseResult { + var ( + obj = p.objTree.ObjectAt(objIndex) + ok bool + argObj, resolvedObj *Object + argCount uint64 + targetIndex uint32 + ) + + // The arg list must be visited in reverse order to handle nesting: + // FOOF( BARB(1,2), 3) will appear in the stream as: FOOF BARB 1 2 3 + // By processing the objects in reverse order we sequentially transform + // the object list as follows: + // FOOF BARB(1,2) 3 + // FOOF( BARB(1,2), 3) + for argIndex := obj.lastArgIndex; argIndex != InvalidIndex; argIndex = argObj.prevSiblingIndex { + // Recursively process children first + argObj = p.objTree.ObjectAt(argIndex) + if p.resolveMethodCalls(argObj.index) != parseResultOk { + return parseResultFailed + } + + if argObj.opcode != pOpIntNamePathOrMethodCall || argObj.tableHandle != p.tableHandle { + continue + } + + // Resolve namepath + targetIndex = p.objTree.Find(argObj.parentIndex, argObj.value.([]byte)) + switch targetIndex { + case InvalidIndex: + // Treat this as a namepath to be resolved at run-time + argObj.opcode = pOpIntNamePath + argObj.infoIndex = pOpcodeTableIndex(argObj.opcode, true) + default: + resolvedObj = p.objTree.ObjectAt(targetIndex) + + switch resolvedObj.opcode { + case pOpMethod: + // Mutate into a method call with value pointing at the resolved method index + argObj.opcode = pOpIntMethodCall + argObj.infoIndex = pOpcodeTableIndex(argObj.opcode, true) + argObj.value = resolvedObj.index + + // Consume the required number of args which are encoded as + // bits [0:2] of the method obj 2nd arg + methodFlagsObj := p.objTree.ArgAt(resolvedObj, 1) + if methodFlagsObj == nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] target method \"%s\" is missing a flag object\n", p.tableName, argObj.amlOffset, resolvedObj.name[:]) + return parseResultFailed + } + + argCount, ok = methodFlagsObj.value.(uint64) + if !ok { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] target method \"%s\" contains a malformed flag object\n", p.tableName, argObj.amlOffset, resolvedObj.name[:]) + return parseResultFailed + } + + if p.attachSiblingsAsArgs(obj, argObj, uint8(argCount&0x7), true) != parseResultOk { + return parseResultFailed + } + default: + // Mutate into a resolved name path with value pointing at the resolved object intdex + argObj.opcode = pOpIntResolvedNamePath + argObj.infoIndex = pOpcodeTableIndex(argObj.opcode, true) + argObj.value = resolvedObj.index + } + } + } + + return parseResultOk +} + +// attachSiblingsAsArgs detaches numArgs sibling nodes of targetObj and +// re-attaches them as args to targetObj. If we run out of sibling nodes and +// useParentSiblings is set to true, then attachSiblingsAsArgs will continue +// detaching siblings from the parent +func (p *Parser) attachSiblingsAsArgs(parentObj, targetObj *Object, numArgs uint8, useParentSiblings bool) parseResult { + var siblingObj *Object + + for siblingIndex := targetObj.nextSiblingIndex; numArgs > 0; numArgs-- { + if siblingIndex == InvalidIndex && useParentSiblings { + siblingIndex = parentObj.nextSiblingIndex + } + + if siblingIndex == InvalidIndex { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] unexpected arg count for opcode: %s (0x%x)\n", p.tableName, targetObj.amlOffset, pOpcodeName(targetObj.opcode), targetObj.opcode) + return parseResultFailed + } + + // Update siblingIndex before siblingObj gets detached + siblingObj = p.objTree.ObjectAt(siblingIndex) + siblingIndex = siblingObj.nextSiblingIndex + + p.objTree.detach(parentObj, siblingObj) + p.objTree.append(targetObj, siblingObj) + } + return parseResultOk +} diff --git a/src/gopheros/device/acpi/aml/parser_fuzz.go b/src/gopheros/device/acpi/aml/parser_fuzz.go new file mode 100644 index 0000000..6d3822f --- /dev/null +++ b/src/gopheros/device/acpi/aml/parser_fuzz.go @@ -0,0 +1,40 @@ +// +build gofuzz +// +// The following lines contain paths to interesting corpus data and will be +// automatically grepped and copied by the Makefile when fuzzing. +// +//go-fuzz-corpus+=src/gopheros/device/acpi/table/tabletest/DSDT.aml +//go-fuzz-corpus+=src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.aml + +package aml + +import ( + "gopheros/device/acpi/table" + "io/ioutil" + "unsafe" +) + +// Fuzz is the driver for go-fuzz. The function must return 1 if the fuzzer +// should increase priority of the given input during subsequent fuzzing (for +// example, the input is lexically correct and was parsed successfully); -1 if +// the input must not be added to corpus even if gives new coverage; and 0 +// otherwise; other values are reserved for future use. +func Fuzz(data []byte) int { + // Setup SDT header pointing to data + headerLen := unsafe.Sizeof(table.SDTHeader{}) + stream := make([]byte, int(headerLen)+len(data)) + copy(stream[headerLen:], data) + + header := (*table.SDTHeader)(unsafe.Pointer(&stream[0])) + header.Signature = [4]byte{'D', 'S', 'D', 'T'} + header.Length = uint32(len(stream)) + header.Revision = 2 + + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + if err := NewParser(ioutil.Discard, tree).ParseAML(uint8(1), "DSDT", header); err != nil { + return 0 + } + + return 1 +} diff --git a/src/gopheros/device/acpi/aml/parser_opcode_table.go b/src/gopheros/device/acpi/aml/parser_opcode_table.go new file mode 100644 index 0000000..74bb7f9 --- /dev/null +++ b/src/gopheros/device/acpi/aml/parser_opcode_table.go @@ -0,0 +1,527 @@ +package aml + +// List of AML opcodes. +const ( + // Regular opcode list + pOpZero = uint16(0x00) + pOpOne = uint16(0x01) + pOpAlias = uint16(0x06) + pOpName = uint16(0x08) + pOpBytePrefix = uint16(0x0a) + pOpWordPrefix = uint16(0x0b) + pOpDwordPrefix = uint16(0x0c) + pOpStringPrefix = uint16(0x0d) + pOpQwordPrefix = uint16(0x0e) + pOpScope = uint16(0x10) + pOpBuffer = uint16(0x11) + pOpPackage = uint16(0x12) + pOpVarPackage = uint16(0x13) + pOpMethod = uint16(0x14) + pOpExternal = uint16(0x15) + pOpLocal0 = uint16(0x60) + pOpLocal1 = uint16(0x61) + pOpLocal2 = uint16(0x62) + pOpLocal3 = uint16(0x63) + pOpLocal4 = uint16(0x64) + pOpLocal5 = uint16(0x65) + pOpLocal6 = uint16(0x66) + pOpLocal7 = uint16(0x67) + pOpArg0 = uint16(0x68) + pOpArg1 = uint16(0x69) + pOpArg2 = uint16(0x6a) + pOpArg3 = uint16(0x6b) + pOpArg4 = uint16(0x6c) + pOpArg5 = uint16(0x6d) + pOpArg6 = uint16(0x6e) + pOpStore = uint16(0x70) + pOpRefOf = uint16(0x71) + pOpAdd = uint16(0x72) + pOpConcat = uint16(0x73) + pOpSubtract = uint16(0x74) + pOpIncrement = uint16(0x75) + pOpDecrement = uint16(0x76) + pOpMultiply = uint16(0x77) + pOpDivide = uint16(0x78) + pOpShiftLeft = uint16(0x79) + pOpShiftRight = uint16(0x7a) + pOpAnd = uint16(0x7b) + pOpNand = uint16(0x7c) + pOpOr = uint16(0x7d) + pOpNor = uint16(0x7e) + pOpXor = uint16(0x7f) + pOpNot = uint16(0x80) + pOpFindSetLeftBit = uint16(0x81) + pOpFindSetRightBit = uint16(0x82) + pOpDerefOf = uint16(0x83) + pOpConcatRes = uint16(0x84) + pOpMod = uint16(0x85) + pOpNotify = uint16(0x86) + pOpSizeOf = uint16(0x87) + pOpIndex = uint16(0x88) + pOpMatch = uint16(0x89) + pOpCreateDWordField = uint16(0x8a) + pOpCreateWordField = uint16(0x8b) + pOpCreateByteField = uint16(0x8c) + pOpCreateBitField = uint16(0x8d) + pOpObjectType = uint16(0x8e) + pOpCreateQWordField = uint16(0x8f) + pOpLand = uint16(0x90) + pOpLor = uint16(0x91) + pOpLnot = uint16(0x92) + pOpLEqual = uint16(0x93) + pOpLGreater = uint16(0x94) + pOpLLess = uint16(0x95) + pOpToBuffer = uint16(0x96) + pOpToDecimalString = uint16(0x97) + pOpToHexString = uint16(0x98) + pOpToInteger = uint16(0x99) + pOpToString = uint16(0x9c) + pOpCopyObject = uint16(0x9d) + pOpMid = uint16(0x9e) + pOpContinue = uint16(0x9f) + pOpIf = uint16(0xa0) + pOpElse = uint16(0xa1) + pOpWhile = uint16(0xa2) + pOpNoop = uint16(0xa3) + pOpReturn = uint16(0xa4) + pOpBreak = uint16(0xa5) + pOpBreakPoint = uint16(0xcc) + pOpOnes = uint16(0xff) + // Extended opcodes + pOpMutex = uint16(0xff + 0x01) + pOpEvent = uint16(0xff + 0x02) + pOpCondRefOf = uint16(0xff + 0x12) + pOpCreateField = uint16(0xff + 0x13) + pOpLoadTable = uint16(0xff + 0x1f) + pOpLoad = uint16(0xff + 0x20) + pOpStall = uint16(0xff + 0x21) + pOpSleep = uint16(0xff + 0x22) + pOpAcquire = uint16(0xff + 0x23) + pOpSignal = uint16(0xff + 0x24) + pOpWait = uint16(0xff + 0x25) + pOpReset = uint16(0xff + 0x26) + pOpRelease = uint16(0xff + 0x27) + pOpFromBCD = uint16(0xff + 0x28) + pOpToBCD = uint16(0xff + 0x29) + pOpUnload = uint16(0xff + 0x2a) + pOpRevision = uint16(0xff + 0x30) + pOpDebug = uint16(0xff + 0x31) + pOpFatal = uint16(0xff + 0x32) + pOpTimer = uint16(0xff + 0x33) + pOpOpRegion = uint16(0xff + 0x80) + pOpField = uint16(0xff + 0x81) + pOpDevice = uint16(0xff + 0x82) + pOpProcessor = uint16(0xff + 0x83) + pOpPowerRes = uint16(0xff + 0x84) + pOpThermalZone = uint16(0xff + 0x85) + pOpIndexField = uint16(0xff + 0x86) + pOpBankField = uint16(0xff + 0x87) + pOpDataRegion = uint16(0xff + 0x88) + // Special internal opcodes which are not part of the spec; these are + // for internal use by the AML parser. + pOpIntScopeBlock = uint16(0xff + 0xf7) + pOpIntByteList = uint16(0xff + 0xf8) + pOpIntConnection = uint16(0xff + 0xf9) + pOpIntNamedField = uint16(0xff + 0xfa) + pOpIntResolvedNamePath = uint16(0xff + 0xfb) + pOpIntNamePath = uint16(0xff + 0xfc) + pOpIntNamePathOrMethodCall = uint16(0xff + 0xfd) + pOpIntMethodCall = uint16(0xff + 0xfe) + // Sentinel value to indicate freed objects + pOpIntFreedObject = uint16(0xff + 0xff) +) + +// pOpIsLocalArg returns true if this opcode represents any of the supported local +// function args 0 to 7. +func pOpIsLocalArg(op uint16) bool { + return op >= pOpLocal0 && op <= pOpLocal7 +} + +// pOpIsMethodArg returns true if this opcode represents any of the supported +// input function args 0 to 6. +func pOpIsMethodArg(op uint16) bool { + return op >= pOpArg0 && op <= pOpArg6 +} + +// pOpIsArg returns true if this opcode is either a local or a method arg. +func pOpIsArg(op uint16) bool { + return pOpIsLocalArg(op) || pOpIsMethodArg(op) +} + +// pOpIsType2 returns true if this is a Type2Opcode. +// +// Grammar: +// 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 +func pOpIsType2(op uint16) bool { + switch op { + case pOpAcquire, pOpAdd, pOpAnd, pOpBuffer, pOpConcat, + pOpConcatRes, pOpCondRefOf, pOpCopyObject, pOpDecrement, + pOpDerefOf, pOpDivide, pOpFindSetLeftBit, pOpFindSetRightBit, + pOpFromBCD, pOpIncrement, pOpIndex, pOpLand, pOpLEqual, + pOpLGreater, pOpLLess, pOpMid, + pOpLnot, pOpLoadTable, pOpLor, pOpMatch, pOpMod, + pOpMultiply, pOpNand, pOpNor, pOpNot, pOpObjectType, pOpOr, + pOpPackage, pOpVarPackage, pOpRefOf, pOpShiftLeft, pOpShiftRight, + pOpSizeOf, pOpStore, pOpSubtract, pOpTimer, pOpToBCD, pOpToBuffer, + pOpToDecimalString, pOpToHexString, pOpToInteger, pOpToString, + pOpWait, pOpXor: + return true + default: + return false + } +} + +// pOpIsDataObject returns true if this opcode is part of a DataObject definition +// +// Grammar: +// DataObject := ComputationalData | DefPackage | DefVarPackage +// ComputationalData := ByteConst | WordConst | DWordConst | QWordConst | String | ConstObj | RevisionOp | DefBuffer +// ConstObj := ZeroOp | OneOp | OnesOp +func pOpIsDataObject(op uint16) bool { + switch op { + case pOpBytePrefix, pOpWordPrefix, pOpDwordPrefix, pOpQwordPrefix, pOpStringPrefix, + pOpZero, pOpOne, pOpOnes, pOpRevision, pOpBuffer, pOpPackage, pOpVarPackage: + return true + default: + return false + } +} + +const ( + badOpcode = 0xff + extOpPrefix = 0x5b +) + +// pOpFlag specifies a list of OR-able flags that describe the object +// type/attributes generated by a particular opcode. +type pOpFlag uint8 + +const ( + pOpFlagNamed = 1 << iota + pOpFlagConstant + pOpFlagReference + pOpFlagCreate + pOpFlagExecutable + pOpFlagScoped + pOpFlagDeferParsing +) + +// pOpArgTypeList encodes up to 7 opArgFlag values in a uint64 value. +type pOpArgTypeList uint64 + +// argCount returns the number of encoded args in the given arg type list. +func (fl pOpArgTypeList) argCount() (count uint8) { + // Each argument is specified using 8 bits with 0x0 indicating the end of the + // argument list + for ; fl&0xf != 0; fl, count = fl>>8, count+1 { + } + + return count +} + +// arg returns the arg type for argument "num" where num is the 0-based index +// of the argument to return. The allowed values for num are 0-6. +func (fl pOpArgTypeList) arg(num uint8) pArgType { + return pArgType((fl >> (num * 8)) & 0xf) +} + +// pArgType represents the type of an argument expected by a particular opcode. +type pArgType uint8 + +// The list of supported opArgFlag values. +const ( + _ pArgType = iota + pArgTypeTermList + pArgTypeTermArg + pArgTypeByteList + pArgTypeString + pArgTypeByteData + pArgTypeWordData + pArgTypeDwordData + pArgTypeQwordData + pArgTypeNameString + pArgTypeSuperName + pArgTypeSimpleName + pArgTypeDataRefObj + pArgTypeTarget + pArgTypeFieldList + pArgTypePkgLen +) + +func makeArg0() pOpArgTypeList { return 0 } +func makeArg1(arg0 pArgType) pOpArgTypeList { return pOpArgTypeList(arg0) } +func makeArg2(arg0, arg1 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} +func makeArg3(arg0, arg1, arg2 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg2)<<16 | pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} +func makeArg4(arg0, arg1, arg2, arg3 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg3)<<24 | pOpArgTypeList(arg2)<<16 | pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} +func makeArg5(arg0, arg1, arg2, arg3, arg4 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg4)<<32 | pOpArgTypeList(arg3)<<24 | pOpArgTypeList(arg2)<<16 | pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} +func makeArg6(arg0, arg1, arg2, arg3, arg4, arg5 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg5)<<40 | pOpArgTypeList(arg4)<<32 | pOpArgTypeList(arg3)<<24 | pOpArgTypeList(arg2)<<16 | pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} +func makeArg7(arg0, arg1, arg2, arg3, arg4, arg5, arg6 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg6)<<48 | pOpArgTypeList(arg5)<<40 | pOpArgTypeList(arg4)<<32 | pOpArgTypeList(arg3)<<24 | pOpArgTypeList(arg2)<<16 | pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} + +// pOpcodeInfo contains all known information about an opcode, +// its argument count and types as well as the type of object +// represented by it. +type pOpcodeInfo struct { + op uint16 + opName string + + flags pOpFlag + argFlags pOpArgTypeList +} + +// The opcode table contains all opcode-related information that the parser knows. +// This table is modeled after a similar table used in the acpica implementation. +var pOpcodeTable = []pOpcodeInfo{ + /*0x00*/ {pOpZero, "Zero", pOpFlagConstant, makeArg0()}, + /*0x01*/ {pOpOne, "One", pOpFlagConstant, makeArg0()}, + /*0x02*/ {pOpAlias, "Alias", pOpFlagNamed, makeArg2(pArgTypeNameString, pArgTypeNameString)}, + /*0x03*/ {pOpName, "Name", pOpFlagNamed, makeArg2(pArgTypeNameString, pArgTypeDataRefObj)}, + /*0x04*/ {pOpBytePrefix, "BytePrefix", pOpFlagConstant, makeArg1(pArgTypeByteData)}, + /*0x05*/ {pOpWordPrefix, "WordPrefix", pOpFlagConstant, makeArg1(pArgTypeWordData)}, + /*0x06*/ {pOpDwordPrefix, "DwordPrefix", pOpFlagConstant, makeArg1(pArgTypeDwordData)}, + /*0x07*/ {pOpStringPrefix, "StringPrefix", pOpFlagConstant, makeArg1(pArgTypeString)}, + /*0x08*/ {pOpQwordPrefix, "QwordPrefix", pOpFlagConstant, makeArg1(pArgTypeQwordData)}, + /*0x09*/ {pOpScope, "Scope", 0, makeArg3(pArgTypePkgLen, pArgTypeNameString, pArgTypeTermList)}, + /*0x0a*/ {pOpBuffer, "Buffer", pOpFlagDeferParsing | pOpFlagCreate, makeArg3(pArgTypePkgLen, pArgTypeTermArg, pArgTypeByteList)}, + /*0x0b*/ {pOpPackage, "Package", pOpFlagCreate, makeArg3(pArgTypePkgLen, pArgTypeByteData, pArgTypeTermList)}, + /*0x0c*/ {pOpVarPackage, "VarPackage", pOpFlagCreate, makeArg3(pArgTypePkgLen, pArgTypeByteData, pArgTypeTermList)}, + /*0x0d*/ {pOpMethod, "Method", pOpFlagNamed | pOpFlagScoped, makeArg4(pArgTypePkgLen, pArgTypeNameString, pArgTypeByteData, pArgTypeTermList)}, + /*0x0e*/ {pOpExternal, "External", pOpFlagNamed, makeArg3(pArgTypeNameString, pArgTypeByteData, pArgTypeByteData)}, + /*0x0f*/ {pOpLocal0, "Local0", pOpFlagExecutable, makeArg0()}, + /*0x10*/ {pOpLocal1, "Local1", pOpFlagExecutable, makeArg0()}, + /*0x11*/ {pOpLocal2, "Local2", pOpFlagExecutable, makeArg0()}, + /*0x12*/ {pOpLocal3, "Local3", pOpFlagExecutable, makeArg0()}, + /*0x13*/ {pOpLocal4, "Local4", pOpFlagExecutable, makeArg0()}, + /*0120*/ {pOpLocal5, "Local5", pOpFlagExecutable, makeArg0()}, + /*0x15*/ {pOpLocal6, "Local6", pOpFlagExecutable, makeArg0()}, + /*0x16*/ {pOpLocal7, "Local7", pOpFlagExecutable, makeArg0()}, + /*0x17*/ {pOpArg0, "Arg0", pOpFlagExecutable, makeArg0()}, + /*0x18*/ {pOpArg1, "Arg1", pOpFlagExecutable, makeArg0()}, + /*0x19*/ {pOpArg2, "Arg2", pOpFlagExecutable, makeArg0()}, + /*0x1a*/ {pOpArg3, "Arg3", pOpFlagExecutable, makeArg0()}, + /*0x1b*/ {pOpArg4, "Arg4", pOpFlagExecutable, makeArg0()}, + /*0x1c*/ {pOpArg5, "Arg5", pOpFlagExecutable, makeArg0()}, + /*0x1d*/ {pOpArg6, "Arg6", pOpFlagExecutable, makeArg0()}, + /*0x1e*/ {pOpStore, "Store", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeSuperName)}, + /*0x1f*/ {pOpRefOf, "RefOf", pOpFlagReference | pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x20*/ {pOpAdd, "Add", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x21*/ {pOpConcat, "Concat", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x22*/ {pOpSubtract, "Subtract", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x23*/ {pOpIncrement, "Increment", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x24*/ {pOpDecrement, "Decrement", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x25*/ {pOpMultiply, "Multiply", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x26*/ {pOpDivide, "Divide", pOpFlagExecutable, makeArg4(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget, pArgTypeTarget)}, + /*0x27*/ {pOpShiftLeft, "ShiftLeft", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x28*/ {pOpShiftRight, "ShiftRight", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x29*/ {pOpAnd, "And", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x2a*/ {pOpNand, "Nand", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x2b*/ {pOpOr, "Or", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x2c*/ {pOpNor, "Nor", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x2d*/ {pOpXor, "Xor", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x2e*/ {pOpNot, "Not", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x2f*/ {pOpFindSetLeftBit, "FindSetLeftBit", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x30*/ {pOpFindSetRightBit, "FindSetRightBit", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x31*/ {pOpDerefOf, "DerefOf", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x32*/ {pOpConcatRes, "ConcatRes", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x33*/ {pOpMod, "Mod", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x34*/ {pOpNotify, "Notify", pOpFlagExecutable, makeArg2(pArgTypeSuperName, pArgTypeTermArg)}, + /*0x35*/ {pOpSizeOf, "SizeOf", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x36*/ {pOpIndex, "Index", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x37*/ {pOpMatch, "Match", pOpFlagExecutable, makeArg6(pArgTypeTermArg, pArgTypeByteData, pArgTypeTermArg, pArgTypeByteData, pArgTypeTermArg, pArgTypeTermArg)}, + /*0x38*/ {pOpCreateDWordField, "CreateDWordField", pOpFlagCreate | pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x39*/ {pOpCreateWordField, "CreateWordField", pOpFlagCreate | pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x3a*/ {pOpCreateByteField, "CreateByteField", pOpFlagCreate | pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x3b*/ {pOpCreateBitField, "CreateBitField", pOpFlagCreate | pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x3c*/ {pOpObjectType, "ObjectType", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x3d*/ {pOpCreateQWordField, "CreateQWordField", pOpFlagCreate, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x3e*/ {pOpLand, "Land", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTermArg)}, + /*0x3f*/ {pOpLor, "Lor", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTermArg)}, + /*0x40*/ {pOpLnot, "Lnot", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x41*/ {pOpLEqual, "LEqual", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTermArg)}, + /*0x42*/ {pOpLGreater, "LGreater", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTermArg)}, + /*0x43*/ {pOpLLess, "LLess", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTermArg)}, + /*0x44*/ {pOpToBuffer, "ToBuffer", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x45*/ {pOpToDecimalString, "ToDecimalString", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x46*/ {pOpToHexString, "ToHexString", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x47*/ {pOpToInteger, "ToInteger", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x48*/ {pOpToString, "ToString", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x49*/ {pOpCopyObject, "CopyObject", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeSimpleName)}, + /*0x4a*/ {pOpMid, "Mid", pOpFlagExecutable, makeArg4(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x4b*/ {pOpContinue, "Continue", pOpFlagExecutable, makeArg0()}, + /*0x4c*/ {pOpIf, "If", pOpFlagExecutable | pOpFlagScoped, makeArg3(pArgTypePkgLen, pArgTypeTermArg, pArgTypeTermList)}, + /*0x4d*/ {pOpElse, "Else", pOpFlagExecutable | pOpFlagScoped, makeArg2(pArgTypePkgLen, pArgTypeTermList)}, + /*0x4e*/ {pOpWhile, "While", pOpFlagDeferParsing | pOpFlagExecutable | pOpFlagScoped, makeArg3(pArgTypePkgLen, pArgTypeTermArg, pArgTypeTermList)}, + /*0x4f*/ {pOpNoop, "Noop", pOpFlagExecutable, makeArg0()}, + /*0x50*/ {pOpReturn, "Return", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x51*/ {pOpBreak, "Break", pOpFlagExecutable, makeArg0()}, + /*0x52*/ {pOpBreakPoint, "BreakPoint", pOpFlagExecutable, makeArg0()}, + /*0x53*/ {pOpOnes, "Ones", pOpFlagConstant, makeArg0()}, + /*0x54*/ {pOpMutex, "Mutex", pOpFlagNamed, makeArg2(pArgTypeNameString, pArgTypeByteData)}, + /*0x55*/ {pOpEvent, "Event", pOpFlagNamed, makeArg1(pArgTypeNameString)}, + /*0x56*/ {pOpCondRefOf, "CondRefOf", pOpFlagExecutable, makeArg2(pArgTypeSuperName, pArgTypeSuperName)}, + /*0x57*/ {pOpCreateField, "CreateField", pOpFlagExecutable, makeArg4(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x58*/ {pOpLoadTable, "LoadTable", pOpFlagExecutable, makeArg7(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg)}, + /*0x59*/ {pOpLoad, "Load", pOpFlagExecutable, makeArg2(pArgTypeNameString, pArgTypeSuperName)}, + /*0x5a*/ {pOpStall, "Stall", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x5b*/ {pOpSleep, "Sleep", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x5c*/ {pOpAcquire, "Acquire", pOpFlagExecutable, makeArg2(pArgTypeSuperName, pArgTypeWordData)}, + /*0x5d*/ {pOpSignal, "Signal", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x5e*/ {pOpWait, "Wait", pOpFlagExecutable, makeArg2(pArgTypeSuperName, pArgTypeTermArg)}, + /*0x5f*/ {pOpReset, "Reset", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x60*/ {pOpRelease, "Release", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x61*/ {pOpFromBCD, "FromBCD", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x62*/ {pOpToBCD, "ToBCD", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x63*/ {pOpUnload, "Unload", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x64*/ {pOpRevision, "Revision", pOpFlagConstant | pOpFlagExecutable, makeArg0()}, + /*0x65*/ {pOpDebug, "Debug", pOpFlagExecutable, makeArg0()}, + /*0x66*/ {pOpFatal, "Fatal", pOpFlagExecutable, makeArg3(pArgTypeByteData, pArgTypeDwordData, pArgTypeTermArg)}, + /*0x67*/ {pOpTimer, "Timer", pOpFlagExecutable, makeArg0()}, + /*0x68*/ {pOpOpRegion, "OpRegion", pOpFlagNamed, makeArg4(pArgTypeNameString, pArgTypeByteData, pArgTypeTermArg, pArgTypeTermArg)}, + /*0x69*/ {pOpField, "Field", pOpFlagCreate, makeArg4(pArgTypePkgLen, pArgTypeNameString, pArgTypeByteData, pArgTypeFieldList)}, + /*0x6a*/ {pOpDevice, "Device", pOpFlagNamed | pOpFlagScoped, makeArg3(pArgTypePkgLen, pArgTypeNameString, pArgTypeTermList)}, + /*0x6b*/ {pOpProcessor, "Processor", pOpFlagNamed | pOpFlagScoped, makeArg6(pArgTypePkgLen, pArgTypeNameString, pArgTypeByteData, pArgTypeDwordData, pArgTypeByteData, pArgTypeTermList)}, + /*0x6c*/ {pOpPowerRes, "PowerRes", pOpFlagNamed | pOpFlagScoped, makeArg5(pArgTypePkgLen, pArgTypeNameString, pArgTypeByteData, pArgTypeWordData, pArgTypeTermList)}, + /*0x6d*/ {pOpThermalZone, "ThermalZone", pOpFlagNamed | pOpFlagScoped, makeArg3(pArgTypePkgLen, pArgTypeNameString, pArgTypeTermList)}, + /*0x6e*/ {pOpIndexField, "IndexField", pOpFlagCreate | pOpFlagNamed, makeArg5(pArgTypePkgLen, pArgTypeNameString, pArgTypeNameString, pArgTypeByteData, pArgTypeFieldList)}, + /*0x6f*/ {pOpBankField, "BankField", pOpFlagDeferParsing | pOpFlagCreate | pOpFlagNamed, makeArg6(pArgTypePkgLen, pArgTypeNameString, pArgTypeNameString, pArgTypeTermArg, pArgTypeByteData, pArgTypeFieldList)}, + /*0x70*/ {pOpDataRegion, "DataRegion", pOpFlagCreate | pOpFlagNamed, makeArg4(pArgTypeNameString, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg)}, + // Special internal opcodes + /*0xf7*/ {pOpIntScopeBlock, "ScopeBlock", pOpFlagCreate | pOpFlagNamed, makeArg1(pArgTypeTermList)}, + /*0xf8*/ {pOpIntByteList, "ByteList", pOpFlagCreate, makeArg0()}, + /*0xf9*/ {pOpIntConnection, "Connection", pOpFlagCreate, makeArg0()}, + /*0xfa*/ {pOpIntNamedField, "NamedField", pOpFlagCreate, makeArg0()}, + /*0xfb*/ {pOpIntResolvedNamePath, "ResolvedNamePath", pOpFlagCreate, makeArg0()}, + /*0xfc*/ {pOpIntNamePath, "NamePath", pOpFlagCreate, makeArg0()}, + /*0xfd*/ {pOpIntNamePathOrMethodCall, "NamePath or MethodCall", pOpFlagCreate, makeArg0()}, + /*0xfe*/ {pOpIntMethodCall, "MethodCall", pOpFlagCreate, makeArg0()}, +} + +// opcodeMap maps an AML opcode to an entry in the opcode table. Entries with +// the value 0xff indicate an invalid/unsupported opcode. +var opcodeMap = [256]uint8{ + /* 0 1 2 3 4 5 6 7*/ + /*0x00 - 0x07*/ 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0x02, 0xff, + /*0x08 - 0x0f*/ 0x03, 0xff, 0x04, 0x05, 0x06, 0x07, 0x08, 0xff, + /*0x10 - 0x17*/ 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0xff, 0xff, + /*0x18 - 0x1f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x20 - 0x27*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x28 - 0x2f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x30 - 0x37*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x38 - 0x3f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x40 - 0x47*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x48 - 0x4f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x50 - 0x57*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x58 - 0x5f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x60 - 0x67*/ 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, + /*0x68 - 0x6f*/ 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0xff, + /*0x70 - 0x77*/ 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, + /*0x78 - 0x7f*/ 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, + /*0x80 - 0x87*/ 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, + /*0x88 - 0x8f*/ 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, + /*0x90 - 0x97*/ 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, + /*0x98 - 0x9f*/ 0x46, 0x47, 0xff, 0xff, 0x48, 0x49, 0x4a, 0x4b, + /*0xa0 - 0xa7*/ 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0xff, 0xff, + /*0xa8 - 0xaf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xb0 - 0xb7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xb8 - 0xbf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xc0 - 0xc7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xc8 - 0xcf*/ 0xff, 0xff, 0xff, 0xff, 0x52, 0xff, 0xff, 0xff, + /*0xd0 - 0xd7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xd8 - 0xdf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xe0 - 0xe7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xe8 - 0xef*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xf0 - 0xf7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xf8 - 0xff*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x53, +} + +// extendedOpcodeMap maps an AML extended opcode (extOpPrefix + code) to an +// entry in the opcode table. Entries with the value 0xff indicate an +// invalid/unsupported opcode. +var extendedOpcodeMap = [256]uint8{ + /* 0 1 2 3 4 5 6 7*/ + /*0x00 - 0x07*/ 0xff, 0x54, 0x55, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x08 - 0x0f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x10 - 0x17*/ 0xff, 0xff, 0x56, 0x57, 0xff, 0xff, 0xff, 0xff, + /*0x18 - 0x1f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x58, + /*0x20 - 0x27*/ 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, + /*0x28 - 0x2f*/ 0x61, 0x62, 0x63, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x30 - 0x37*/ 0x64, 0x65, 0x66, 0x67, 0xff, 0xff, 0xff, 0xff, + /*0x38 - 0x3f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x40 - 0x47*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x48 - 0x4f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x50 - 0x57*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x58 - 0x5f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x60 - 0x67*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x68 - 0x6f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x70 - 0x77*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x78 - 0x7f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x80 - 0x87*/ 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + /*0x88 - 0x8f*/ 0x70, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x90 - 0x97*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x98 - 0x9f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xa0 - 0xa7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xa8 - 0xaf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xb0 - 0xb7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xb8 - 0xbf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xc0 - 0xc7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xc8 - 0xcf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xd0 - 0xd7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xd8 - 0xdf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xe0 - 0xe7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xe8 - 0xef*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xf0 - 0xf7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xf8 - 0xff*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +} + +// pOpcodeName returns the name of an opcode as a string. +func pOpcodeName(opcode uint16) string { + index := pOpcodeTableIndex(opcode, true) + if index == badOpcode { + return "unknown" + } + + return pOpcodeTable[index].opName +} + +// pOpcodeTableIndex returns the opcode table index for opcode or badOpcode(0xff) +// if opcode does not map to a valid opcode table entry. +func pOpcodeTableIndex(opcode uint16, allowInternalOp bool) uint8 { + if opcode <= 0xff { + return opcodeMap[opcode] + } + + index := extendedOpcodeMap[opcode-0xff] + + // internal opcodes do not have entries in the extendedOpcodeMap. They get + // allocated descending opcode values starting from (0xff + 0xfe). They do + // however have entries in the opcodeTable. To calculate their index we use + // the following formula: len(opcodeTable) - 1 - (0x1fd - intOpcode) or the + // equivalent: len(opcodeTable) + (intOpcode - 0x1fe) + // with + if index == badOpcode && allowInternalOp { + index = uint8(len(pOpcodeTable) + int(opcode) - 0x1fe) + } + + return index +} diff --git a/src/gopheros/device/acpi/aml/parser_opcode_table_test.go b/src/gopheros/device/acpi/aml/parser_opcode_table_test.go new file mode 100644 index 0000000..083a250 --- /dev/null +++ b/src/gopheros/device/acpi/aml/parser_opcode_table_test.go @@ -0,0 +1,143 @@ +package aml + +import "testing" + +func TestOpcodeIsX(t *testing.T) { + specs := []struct { + op uint16 + testFn func(uint16) bool + want bool + }{ + // OpIsLocalArg + {pOpLocal0, pOpIsLocalArg, true}, + {pOpLocal1, pOpIsLocalArg, true}, + {pOpLocal2, pOpIsLocalArg, true}, + {pOpLocal3, pOpIsLocalArg, true}, + {pOpLocal4, pOpIsLocalArg, true}, + {pOpLocal5, pOpIsLocalArg, true}, + {pOpLocal6, pOpIsLocalArg, true}, + {pOpLocal7, pOpIsLocalArg, true}, + {pOpArg0, pOpIsLocalArg, false}, + {pOpDivide, pOpIsLocalArg, false}, + // OpIsMethodArg + {pOpArg0, pOpIsMethodArg, true}, + {pOpArg1, pOpIsMethodArg, true}, + {pOpArg2, pOpIsMethodArg, true}, + {pOpArg3, pOpIsMethodArg, true}, + {pOpArg4, pOpIsMethodArg, true}, + {pOpArg5, pOpIsMethodArg, true}, + {pOpArg6, pOpIsMethodArg, true}, + {pOpLocal7, pOpIsMethodArg, false}, + {pOpIf, pOpIsMethodArg, false}, + // OpIsArg + {pOpLocal5, pOpIsArg, true}, + {pOpArg1, pOpIsArg, true}, + {pOpDivide, pOpIsArg, false}, + // OpIsType2 + {pOpAcquire, pOpIsType2, true}, + {pOpAdd, pOpIsType2, true}, + {pOpAnd, pOpIsType2, true}, + {pOpBuffer, pOpIsType2, true}, + {pOpConcat, pOpIsType2, true}, + {pOpConcatRes, pOpIsType2, true}, + {pOpCondRefOf, pOpIsType2, true}, + {pOpCopyObject, pOpIsType2, true}, + {pOpDecrement, pOpIsType2, true}, + {pOpDerefOf, pOpIsType2, true}, + {pOpDivide, pOpIsType2, true}, + {pOpFindSetLeftBit, pOpIsType2, true}, + {pOpFindSetRightBit, pOpIsType2, true}, + {pOpFromBCD, pOpIsType2, true}, + {pOpIncrement, pOpIsType2, true}, + {pOpIndex, pOpIsType2, true}, + {pOpLand, pOpIsType2, true}, + {pOpLEqual, pOpIsType2, true}, + {pOpLGreater, pOpIsType2, true}, + {pOpLLess, pOpIsType2, true}, + {pOpMid, pOpIsType2, true}, + {pOpLnot, pOpIsType2, true}, + {pOpLoadTable, pOpIsType2, true}, + {pOpLor, pOpIsType2, true}, + {pOpMatch, pOpIsType2, true}, + {pOpMod, pOpIsType2, true}, + {pOpMultiply, pOpIsType2, true}, + {pOpNand, pOpIsType2, true}, + {pOpNor, pOpIsType2, true}, + {pOpNot, pOpIsType2, true}, + {pOpObjectType, pOpIsType2, true}, + {pOpOr, pOpIsType2, true}, + {pOpPackage, pOpIsType2, true}, + {pOpVarPackage, pOpIsType2, true}, + {pOpRefOf, pOpIsType2, true}, + {pOpShiftLeft, pOpIsType2, true}, + {pOpShiftRight, pOpIsType2, true}, + {pOpSizeOf, pOpIsType2, true}, + {pOpStore, pOpIsType2, true}, + {pOpSubtract, pOpIsType2, true}, + {pOpTimer, pOpIsType2, true}, + {pOpToBCD, pOpIsType2, true}, + {pOpToBuffer, pOpIsType2, true}, + {pOpToDecimalString, pOpIsType2, true}, + {pOpToHexString, pOpIsType2, true}, + {pOpToInteger, pOpIsType2, true}, + {pOpToString, pOpIsType2, true}, + {pOpWait, pOpIsType2, true}, + {pOpXor, pOpIsType2, true}, + {pOpBytePrefix, pOpIsType2, false}, + // OpIsDataObject + {pOpBytePrefix, pOpIsDataObject, true}, + {pOpWordPrefix, pOpIsDataObject, true}, + {pOpDwordPrefix, pOpIsDataObject, true}, + {pOpQwordPrefix, pOpIsDataObject, true}, + {pOpStringPrefix, pOpIsDataObject, true}, + {pOpZero, pOpIsDataObject, true}, + {pOpOne, pOpIsDataObject, true}, + {pOpOnes, pOpIsDataObject, true}, + {pOpRevision, pOpIsDataObject, true}, + {pOpBuffer, pOpIsDataObject, true}, + {pOpPackage, pOpIsDataObject, true}, + {pOpVarPackage, pOpIsDataObject, true}, + {pOpLor, pOpIsDataObject, false}, + } + + for specIndex, spec := range specs { + if got := spec.testFn(spec.op); got != spec.want { + t.Errorf("[spec %d] opcode %q: expected to get %t; got %t", specIndex, spec.op, spec.want, got) + } + } +} + +func TestOpcodeName(t *testing.T) { + for specIndex, spec := range pOpcodeTable { + if got := pOpcodeName(spec.op); got != spec.opName { + t.Errorf("[spec %d] expected OpcodeName(0x%x) to return %q; got %q", specIndex, spec.op, spec.opName, got) + } + } + + if exp, got := "unknown", pOpcodeName(0xf8); got != exp { + t.Fatalf("expected OpcodeName to return %q for unknown opcode; got %q", exp, got) + } +} + +func TestOpcodeMap(t *testing.T) { + freqs := make(map[uint8]int) + for _, tableIndex := range opcodeMap { + if tableIndex == badOpcode { + continue + } + freqs[tableIndex]++ + } + + for _, tableIndex := range extendedOpcodeMap { + if tableIndex == badOpcode { + continue + } + freqs[tableIndex]++ + } + + for tableIndex, freq := range freqs { + if freq > 1 { + t.Errorf("[index 0x%x] found %d duplicate entries in opcodeMap/extendedOpcodeMap for %s", tableIndex, freq, pOpcodeTable[tableIndex].opName) + } + } +} diff --git a/src/gopheros/device/acpi/aml/parser_test.go b/src/gopheros/device/acpi/aml/parser_test.go new file mode 100644 index 0000000..2f514c9 --- /dev/null +++ b/src/gopheros/device/acpi/aml/parser_test.go @@ -0,0 +1,1062 @@ +package aml + +import ( + "bytes" + "flag" + "fmt" + "gopheros/device/acpi/table" + "io/ioutil" + "os" + "path/filepath" + "reflect" + "runtime" + "strings" + "testing" + "unsafe" +) + +var ( + regenExpFiles = flag.Bool("aml-regenerate-parser-exp-files", false, "Regenerate the expected output files for AML parser tests against real AML files") + replayCrashersFrom = flag.String("aml-replay-crashers-from", "", "Replay go-fuzz generated crasher files from this folder") +) + +// TestParserCrashers scans through the crasher corpus generated by go-fuzz and +// pipes each corpus through the AML parser. +func TestParserCrashers(t *testing.T) { + if *replayCrashersFrom == "" { + t.Skip("-aml-replay-crashers-from not specified; skipping") + return + } + + fuzzFiles, err := filepath.Glob(filepath.Join(*replayCrashersFrom, "*")) + if err != nil { + t.Fatal(err) + } + + for _, fuzzFile := range fuzzFiles { + // corpus files lack an extension + if filepath.Ext(fuzzFile) != "" { + continue + } + + data, err := ioutil.ReadFile(fuzzFile) + if err != nil { + t.Fatal(err) + } + + t.Logf("trying to parse crash corpus: %q", fuzzFile) + p, resolver := parserForMockPayload(t, data) + _ = p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")) + } + +} + +func TestParser(t *testing.T) { + flag.Parse() + + pathToDumps := pkgDir() + "/../table/tabletest/" + + specs := []struct { + expTreeContentFile string + tableFiles []string + }{ + { + "DSDT-SSDT.exp", + []string{"DSDT.aml", "SSDT.aml"}, + }, + { + "parser-testsuite-DSDT.exp", + []string{"parser-testsuite-DSDT.aml"}, + }, + } + + for _, spec := range specs { + t.Run(fmt.Sprintf("parse [%s]", strings.Join(spec.tableFiles, ", ")), func(t *testing.T) { + var resolver = mockResolver{ + pathToDumps: pathToDumps, + tableFiles: spec.tableFiles, + } + + tree := NewObjectTree() + tree.CreateDefaultScopes(42) + + p := NewParser(&testWriter{t: t}, tree) + for tableIndex, tableFile := range spec.tableFiles { + tableName := strings.Replace(tableFile, ".aml", "", -1) + if err := p.ParseAML(uint8(tableIndex), tableName, resolver.LookupTable(tableName)); err != nil { + t.Errorf("[%s]: %v", tableName, err) + return + } + } + + // Pretty-print tree + var treeDump bytes.Buffer + tree.PrettyPrint(&treeDump) + + // Check if we need to rebuild the exp files + pathToExpFile := filepath.Join(pathToDumps, spec.expTreeContentFile) + if *regenExpFiles { + f, err := os.Create(pathToExpFile) + if err != nil { + t.Fatal(err) + } + defer func() { _ = f.Close() }() + + if _, err = treeDump.WriteTo(f); err != nil { + t.Fatal(err) + } + t.Logf("regenerated exp file contents: %s", pathToExpFile) + return + } + + // Read the exp file and compare its contents to the generated dump + expDump, err := ioutil.ReadFile(pathToExpFile) + if err != nil { + t.Fatalf("error opening exp file: %s; try running tests with -aml-regenerate-parser-exp-files", pathToExpFile) + } + + if !reflect.DeepEqual(expDump, treeDump.Bytes()) { + t.Fatal("parsed tree content does not match expected content") + } + }) + } +} + +func TestParseAMLErrors(t *testing.T) { + t.Run("parseObjectList failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{uint8(pOpBuffer)}) + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("connectNamedObjArgs failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + namedObj := p.objTree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + p.objTree.append(namedObj, p.objTree.newObject(pOpDwordPrefix, 0)) + p.objTree.append(p.objTree.ObjectAt(1), namedObj) // Attach to first child of root scope + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("mergeScopeDirectives failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + scopeDirective := p.objTree.newObject(pOpScope, 0) + p.objTree.append(p.objTree.ObjectAt(1), scopeDirective) // Attach to first child of root scope + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("relocateNamedObjects failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + namedObj := p.objTree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + namepath := p.objTree.newObject(pOpIntNamePath, 0) + namepath.value = []byte{'^', '^', 'F', 'O', 'O', 'F'} + target := p.objTree.newObject(pOpOnes, 0) + p.objTree.append(namedObj, namepath) + p.objTree.append(namedObj, target) + p.objTree.append(p.objTree.ObjectAt(0), namedObj) + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("parseDeferredBlocks failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + // Attach a deferred block to the first child of the root scope + def := p.objTree.newObject(pOpBankField, 0) + def.pkgEnd = 1 + p.objTree.append(p.objTree.ObjectAt(1), def) + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("resolveMethodCalls failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + method := p.objTree.newNamedObject(pOpMethod, 0, [amlNameLen]byte{'M', 'T', 'H', 'D'}) + namepath := p.objTree.newObject(pOpIntNamePath, 0) + namepath.value = []byte{'M', 'T', 'H', 'D'} + p.objTree.append(method, namepath) + p.objTree.append(p.objTree.ObjectAt(0), method) + + inv := p.objTree.newObject(pOpIntNamePathOrMethodCall, 0) + inv.value = []byte{'M', 'T', 'H', 'D'} + p.objTree.append(p.objTree.ObjectAt(0), inv) + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("connectNonNamedObjArgs failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + // Use a named object whose args contain a TermArg + obj := p.objTree.newObject(pOpMatch, 0) + p.objTree.append(p.objTree.ObjectAt(0), obj) + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) +} + +func TestParseObjectListErrors(t *testing.T) { + p, _ := parserForMockPayload(t, []byte{uint8(pOpBuffer)}) + p.scopeEnter(0) + if res := p.parseObjectList(); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } +} + +func TestParseArgErrors(t *testing.T) { + info := new(pOpcodeInfo) + obj := new(Object) + + t.Run("parsePkgLength error", func(t *testing.T) { + // Incomplete pkg length + p, _ := parserForMockPayload(t, []byte{0xff}) + if _, res := p.parseArg(info, obj, pArgTypePkgLen); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("invalid pkgLen", func(t *testing.T) { + p, _ := parserForMockPayload(t, []byte{0x4}) + if _, res := p.parseArg(info, obj, pArgTypePkgLen); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("parseTermList error", func(t *testing.T) { + p, _ := parserForMockPayload(t, []byte{extOpPrefix}) + p.mode = parseModeAllBlocks + if _, res := p.parseArg(info, obj, pArgTypeTermList); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func TestParseNameOrMethodCallErrors(t *testing.T) { + payload := []byte{ + // Namestring + 'F', 'O', 'O', 'F', + } + + t.Run("path not resolving to entity", func(t *testing.T) { + p, _ := parserForMockPayload(t, payload) + p.scopeEnter(0) + + p.mode = parseModeAllBlocks + if res := p.parseNamePathOrMethodCall(); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("incomplete method call", func(t *testing.T) { + p, _ := parserForMockPayload(t, payload) + p.mode = parseModeAllBlocks + + // Add a method FOOF object as a child of the root scope and set it up + // so that it requires 1 arg. + method := p.objTree.newNamedObject(pOpMethod, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + p.objTree.append(p.objTree.ObjectAt(0), method) + + p.objTree.append(method, p.objTree.newObject(pOpIntNamePath, 0)) + argCountObj := p.objTree.newObject(pOpBytePrefix, 0) + argCountObj.value = uint64(1) + p.objTree.append(method, argCountObj) + + // Enter one of the default child scopes of the root scope + // so the lookup for FOOF yields the object we just appended. + p.scopeEnter(1) + + p.mode = parseModeAllBlocks + if res := p.parseNamePathOrMethodCall(); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func TestParseStrictTermArgErrors(t *testing.T) { + // Set up the stream to include a non-Type2/arg opcode + p, _ := parserForMockPayload(t, []byte{uint8(pOpMethod)}) + p.scopeEnter(0) + + p.mode = parseModeAllBlocks + if _, res := p.parseStrictTermArg(new(Object)); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } +} + +func TestParseSimpleArg(t *testing.T) { + specs := []struct { + payload []byte + argType pArgType + expRes parseResult + expVal interface{} + }{ + { + []byte{0x32}, + pArgTypeByteData, + parseResultOk, + uint64(0x32), + }, + { + []byte{0x32, 0x33}, + pArgTypeWordData, + parseResultOk, + uint64(0x3332), + }, + { + []byte{0x32, 0x33, 0x34, 0x35}, + pArgTypeDwordData, + parseResultOk, + uint64(0x35343332), + }, + { + []byte{0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39}, + pArgTypeQwordData, + parseResultOk, + uint64(0x3938373635343332), + }, + { + []byte{'F', 'O', 'O', 0x00}, + pArgTypeString, + parseResultOk, + []byte{'F', 'O', 'O'}, + }, + { + []byte{'^', '^', 'F', 'O', 'O', 'F'}, + pArgTypeNameString, + parseResultOk, + []byte{'^', '^', 'F', 'O', 'O', 'F'}, + }, + // unsupported arg type + { + []byte{}, + pArgTypeFieldList, + parseResultFailed, + nil, + }, + } + + for specIndex, spec := range specs { + p, _ := parserForMockPayload(t, spec.payload) + obj, res := p.parseSimpleArg(spec.argType) + if res != spec.expRes { + t.Errorf("[spec %d] expected to get parse result %d; got %d", specIndex, spec.expRes, res) + continue + } + + if obj != nil && !reflect.DeepEqual(obj.value, spec.expVal) { + t.Errorf("[spec %d] expected to get value \"%v\"; got \"%v\"", specIndex, spec.expVal, obj.value) + } + } +} + +func TestParseTargetErrors(t *testing.T) { + // Set up the stream to include an un-expected opcode + p, _ := parserForMockPayload(t, []byte{uint8(pOpMethod)}) + p.scopeEnter(0) + + if _, res := p.parseTarget(); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } +} + +func TestParseFieldElementsErrors(t *testing.T) { + genFieldObj := func(tree *ObjectTree) *Object { + field := tree.newObject(pOpField, 0) + flags := tree.newObject(pOpBytePrefix, 0) + flags.value = uint64(0xfe) + tree.append(field, flags) + tree.append(tree.ObjectAt(0), field) + return field + } + + specs := []struct { + descr string + payload []byte + }{ + { + "reserved field parsePkgLength error", + []byte{ + 0x00, // ReservedField + }, + }, + { + "access field access type parse error", + []byte{ + 0x01, // AccessField + }, + }, + { + "access field access attrib parse error", + []byte{ + 0x01, // AccessField + 0x01, // AccessType + }, + }, + { + "ext. access field access type parse error", + []byte{ + 0x03, // ExtendedAccessField + }, + }, + { + "ext. access field access attrib parse error", + []byte{ + 0x03, // ExtendedAccessField + 0x01, // AccessType + }, + }, + { + "ext. access field access length parse error", + []byte{ + 0x03, // ExtendedAccessField + 0x01, // AccessType + 0x02, // AccessAttrib + }, + }, + { + "EOF parsing connection", + []byte{ + 0x02, // Connection + }, + }, + { + "connection buffer data parsePkgLength error", + []byte{ + 0x02, // Connection + uint8(pOpBuffer), + }, + }, + { + "connection buffer length exceeds stream length", + []byte{ + 0x02, // Connection + uint8(pOpBuffer), + 0x5, // pkgLen + }, + }, + { + "connection bad opcode type for buffer size", + []byte{ + 0x02, // Connection + uint8(pOpBuffer), + 0x1, // pkgLen + extOpPrefix, + }, + }, + { + "connection bad word buffer size", + []byte{ + 0x02, // Connection + uint8(pOpBuffer), + 0x2, // pkgLen + uint8(pOpWordPrefix), + 0x1, // missing next byte + }, + }, + { + "connection bad dword buffer size", + []byte{ + 0x02, // Connection + uint8(pOpBuffer), + 0x3, // pkgLen + uint8(pOpDwordPrefix), + 0x1, 0x2, 0x3, // missing next byte + }, + }, + { + "connection parse namestring error", + []byte{ + 0x02, // Connection + '^', + }, + }, + { + "incomplete named field name", + []byte{ + 'F', 'O', 'O', // missing last character + }, + }, + { + "error parsing named field pkgLength", + []byte{ + 'F', 'O', 'O', 'F', + 0xff, // incomplete pkg length + }, + }, + } + + for _, spec := range specs { + t.Run(spec.descr, func(t *testing.T) { + p, _ := parserForMockPayload(t, spec.payload) + if res := p.parseFieldElements(genFieldObj(p.objTree)); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + } +} + +func TestParsePkgLength(t *testing.T) { + specs := []struct { + payload []byte + exp uint32 + }{ + // lead byte bits (6:7) indicate 1 extra byte for the len. The + // parsed length will use bits 0:3 from the lead byte plus + // the full 8 bits of the following byte. + { + []byte{1<<6 | 7, 255}, + 4087, + }, + // lead byte bits (6:7) indicate 2 extra bytes for the len. The + // parsed length will use bits 0:3 from the lead byte plus + // the full 8 bits of the following bytes. + { + []byte{2<<6 | 8, 255, 128}, + 528376, + }, + // lead byte bits (6:7) indicate 3 extra bytes for the len. The + // parsed length will use bits 0:3 from the lead byte plus + // the full 8 bits of the following bytes. + { + []byte{3<<6 | 6, 255, 128, 42}, + 44568566, + }, + } + + for specIndex, spec := range specs { + p, _ := parserForMockPayload(t, spec.payload) + got, res := p.parsePkgLength() + + if res != parseResultOk { + t.Errorf("[spec %d] expected to get parseResultOk(%d); got %d", specIndex, parseResultOk, res) + continue + } + + if got != spec.exp { + t.Errorf("[spec %d] expected parsePkgLength to return %d; got %d", specIndex, spec.exp, got) + } + } +} + +func TestParsePkgLengthErrors(t *testing.T) { + specs := [][]byte{ + // lead byte bits (6:7) indicate 1 extra byte that is missing + []byte{1 << 6}, + // lead byte bits (6:7) indicate 2 extra bytes with the 1st and then 2nd missing + []byte{2 << 6}, + []byte{2 << 6, 0x1}, + // lead byte bits (6:7) indicate 3 extra bytes with the 1st and then 2nd and then 3rd missing + []byte{3 << 6}, + []byte{3 << 6, 0x1}, + []byte{3 << 6, 0x1, 0x2}, + } + + for specIndex, spec := range specs { + p, _ := parserForMockPayload(t, spec) + if _, res := p.parsePkgLength(); res != parseResultFailed { + t.Errorf("[spec %d] expected to get parseResultFailed(%d); got %d", specIndex, parseResultFailed, res) + } + } +} + +func TestParseStringErrors(t *testing.T) { + specs := [][]byte{ + // Unexpected EOF before terminating null byte + []byte{'A'}, + // Characters outside the allowed [0x01, 0x7f] range + []byte{'A', 0xba, 0xdf, 0x00}, + } + + for specIndex, spec := range specs { + p, _ := parserForMockPayload(t, spec) + + if _, res := p.parseString(); res != parseResultFailed { + t.Errorf("[spec %d] expected to get parseResultFailed(%d); got %d", specIndex, parseResultFailed, res) + } + } +} + +func TestParseNamestring(t *testing.T) { + specs := []struct { + payload []byte + expRes parseResult + expVal []byte + }{ + { + []byte{0x00}, + parseResultOk, + []byte{}, + }, + { + // NameSeg with root prefix + []byte{'\\', '_', 'F', 'O', 'O'}, + parseResultOk, + []byte{'\\', '_', 'F', 'O', 'O'}, + }, + { + // DualNamePath + []byte{0x2e, 'F', 'O', 'O', 'F', 'B', 'A', 'R', 'B'}, + parseResultOk, + []byte{0x2e, 'F', 'O', 'O', 'F', 'B', 'A', 'R', 'B'}, + }, + { + // MultiNamePath with caret prefix + []byte{'^', '^', + 0x2f, + 0x3, // 3 segments + 'F', 'O', 'O', 'F', + 'F', 'O', 'O', 'F', + 'F', 'O', 'O', 'F', + }, + parseResultOk, + []byte{'^', '^', + 0x2f, + 0x3, // 3 segments + 'F', 'O', 'O', 'F', + 'F', 'O', 'O', 'F', + 'F', 'O', 'O', 'F', + }, + }, + { + // Unexpected EOF after prefix + []byte{'^'}, + parseResultFailed, + nil, + }, + { + // Unexpected EOF in DualNamePath + []byte{0x2e, 'F', 'O', 'O', 'F', 'B', 'A', 'R'}, // missing last char + parseResultFailed, + nil, + }, + { + // Unexpected EOF reading SegCount in MultiNamePath + []byte{'^', '^', + 0x2f, + // missing segment count + }, + parseResultFailed, + nil, + }, + { + // Unexpected EOF in MultiNamePath + []byte{'^', '^', + 0x2f, + 0x3, // 3 segments + 'F', 'O', 'O', 'F', + 'F', 'O', 'O', 'F', + // missing third segment + }, + parseResultFailed, + nil, + }, + { + // Unexpected EOF in NameSeg + []byte{'F', 'O', 'O'}, // missing last char + parseResultFailed, + nil, + }, + { + // Invalid lead char for NameSeg + []byte{'0', 'F', 'O', 'O'}, + parseResultFailed, + nil, + }, + } + + for specIndex, spec := range specs { + p, _ := parserForMockPayload(t, spec.payload) + obj, res := p.parseNameString() + if res != spec.expRes { + t.Errorf("[spec %d] expected to get parse result %d; got %d", specIndex, spec.expRes, res) + continue + } + + if obj != nil && !reflect.DeepEqual(obj, spec.expVal) { + t.Errorf("[spec %d] expected to get value \"%v\"; got \"%v\"", specIndex, spec.expVal, obj) + } + } +} + +func TestConnectNamedObjectsErrors(t *testing.T) { + t.Run("first arg is not a namepath", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + namedObj := tree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + tree.append(namedObj, tree.newObject(pOpDwordPrefix, 0)) + tree.append(tree.ObjectAt(1), namedObj) // Attach to first child of root scope + + p := NewParser(ioutil.Discard, tree) + if res := p.connectNamedObjArgs(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("named object arg count mismatch", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + // Use a named object whose args contain a TermArg + namedObj := tree.newNamedObject(pOpBankField, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'F', 'O', 'O', 'F'} + tree.append(namedObj, namepathObj) + tree.append(tree.ObjectAt(0), namedObj) + + p := NewParser(ioutil.Discard, tree) + if res := p.connectNamedObjArgs(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("incomplete namepath", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + // Use a named object whose args contain a TermArg + namedObj := tree.newNamedObject(pOpBankField, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'F', 'O'} // namepath len < amlNameLen + tree.append(namedObj, namepathObj) + tree.append(tree.ObjectAt(0), namedObj) + + p := NewParser(ioutil.Discard, tree) + if res := p.connectNamedObjArgs(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + +} + +func TestMergeScopeDirectivesErrors(t *testing.T) { + t.Run("malformed scope object", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + scopeDirective := tree.newObject(pOpScope, 0) + tree.append(tree.ObjectAt(1), scopeDirective) // Attach to first child of root scope + + p := NewParser(ioutil.Discard, tree) + if res := p.mergeScopeDirectives(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("unable to resolve scope reference", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + scopeDirective := tree.newObject(pOpScope, 0) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'F', 'O', 'O', 'F'} + tree.append(scopeDirective, namepathObj) + tree.append(tree.ObjectAt(1), scopeDirective) // Attach to first child of root scope + + // Simulate second mergeScopes attempt + p := NewParser(ioutil.Discard, tree) + p.resolvePasses = 2 + + if res := p.mergeScopeDirectives(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("scope target resolves to obj without IntScopeBlock child", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + scopeDirective := tree.newObject(pOpScope, 0) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'D', 'E', 'V', '0'} + tree.append(scopeDirective, namepathObj) + tree.append(tree.ObjectAt(1), scopeDirective) // Attach to first child of root scope + + tree.append(tree.ObjectAt(0), tree.newNamedObject(pOpDevice, 0, [amlNameLen]byte{'D', 'E', 'V', '0'})) + + // Simulate second mergeScopes attempt + p := NewParser(ioutil.Discard, tree) + p.resolvePasses = 2 + + if res := p.mergeScopeDirectives(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func TestRelocateNamedObjectsErrors(t *testing.T) { + t.Run("first arg is not a namepath", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + namedObj := tree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + tree.append(namedObj, tree.newObject(pOpDwordPrefix, 0)) + tree.append(tree.ObjectAt(1), namedObj) // Attach to first child of root scope + + p := NewParser(ioutil.Discard, tree) + if res := p.relocateNamedObjects(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("unresolved relocation target", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + scope := tree.newNamedObject(pOpIntScopeBlock, 0, [amlNameLen]byte{'S', 'C', 'O', 'P'}) + tree.append(tree.ObjectAt(1), scope) + + namedObj := tree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'^', '^', '^', '^', 'F', 'O', 'O', 'F'} + tree.append(namedObj, namepathObj) + tree.append(scope, namedObj) + + p := NewParser(ioutil.Discard, tree) + if res := p.relocateNamedObjects(0); res != parseResultRequireExtraPass { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultRequireExtraPass, res) + } + }) + + t.Run("unresolved relocation target after maxResolvePasses", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + namedObj := tree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'^', '^', 'F', 'O', 'O', 'F'} + tree.append(namedObj, namepathObj) + + // call relocateNamedObjects on detached nameObj and simulate maxResolvePasses relocateNamedObjects calls + p := NewParser(ioutil.Discard, tree) + p.resolvePasses = maxResolvePasses + 1 + + if res := p.relocateNamedObjects(namedObj.index); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("resolve target resolves to obj without IntScopeBlock child", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + dev0 := tree.newNamedObject(pOpDevice, 0, [amlNameLen]byte{'D', 'E', 'V', '0'}) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'D', 'E', 'V', '0'} + tree.append(dev0, namepathObj) + tree.append(tree.ObjectAt(0), dev0) + + dev1 := tree.newNamedObject(pOpDevice, 0, [amlNameLen]byte{'D', 'E', 'V', '1'}) + namepathObj = tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'^', 'D', 'E', 'V', '1'} + tree.append(dev1, namepathObj) + + // place another named obj between dev0 and dev1 so that the caret in + // dev1 namepath resolves to dev0 + cpu0 := tree.newNamedObject(pOpProcessor, 0, [amlNameLen]byte{'C', 'P', 'U', '0'}) + namepathObj = tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'C', 'P', 'U', '0'} + tree.append(cpu0, namepathObj) + tree.append(dev0, cpu0) + tree.append(cpu0, dev1) + + p := NewParser(ioutil.Discard, tree) + if res := p.relocateNamedObjects(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func TestParseDeferredBlocksErrors(t *testing.T) { + p, _ := parserForMockPayload(t, []byte{extOpPrefix}) + + // Attach a deferred block to the first child of the root scope + def := p.objTree.newObject(pOpBankField, 0) + def.pkgEnd = 1 + p.objTree.append(p.objTree.ObjectAt(1), def) + + if res := p.parseDeferredBlocks(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } +} + +func TestConnectNonNamedObjectsErrors(t *testing.T) { + // Allocate a tree but don't create default scopes to make sure that we lack + // the number of args (siblings OR parent's siblings) required for the pOpAdd opcode + tree := NewObjectTree() + root := tree.newObject(pOpIntScopeBlock, 0) + scope := tree.newObject(pOpIntScopeBlock, 0) + tree.append(root, scope) + + // Use a named object whose args contain a TermArg + obj := tree.newObject(pOpAdd, 0) + tree.append(scope, obj) + + p := NewParser(os.Stdout, tree) + if res := p.connectNonNamedObjArgs(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } +} + +func TestResolveMethodCallsErrors(t *testing.T) { + t.Run("method missing flag object", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + method := tree.newNamedObject(pOpMethod, 0, [amlNameLen]byte{'M', 'T', 'H', 'D'}) + namepath := tree.newObject(pOpIntNamePath, 0) + namepath.value = []byte{'M', 'T', 'H', 'D'} + tree.append(method, namepath) + tree.append(tree.ObjectAt(0), method) + + inv := tree.newObject(pOpIntNamePathOrMethodCall, 0) + inv.value = []byte{'M', 'T', 'H', 'D'} + tree.append(tree.ObjectAt(0), inv) + + p := NewParser(os.Stdout, tree) + if res := p.resolveMethodCalls(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("method contains malformed flag object", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + method := tree.newNamedObject(pOpMethod, 0, [amlNameLen]byte{'M', 'T', 'H', 'D'}) + namepath := tree.newObject(pOpIntNamePath, 0) + namepath.value = []byte{'M', 'T', 'H', 'D'} + flags := tree.newObject(pOpStringPrefix, 0) + flags.value = []byte{'F', 'O', 'O'} // malformed flags: this should be a uint64 + tree.append(method, namepath) + tree.append(method, flags) + tree.append(tree.ObjectAt(0), method) + + inv := tree.newObject(pOpIntNamePathOrMethodCall, 0) + inv.value = []byte{'M', 'T', 'H', 'D'} + tree.append(tree.ObjectAt(0), inv) + + p := NewParser(os.Stdout, tree) + if res := p.resolveMethodCalls(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("method call arg count mismatch", func(t *testing.T) { + // Allocate a tree but don't create default scopes to make sure that we lack + // the number of args (siblings OR parent's siblings) required for the method + // invocation + tree := NewObjectTree() + root := tree.newObject(pOpIntScopeBlock, 0) + scope := tree.newObject(pOpIntScopeBlock, 0) + tree.append(root, scope) + + // MTHD calls expect 6 args + method := tree.newNamedObject(pOpMethod, 0, [amlNameLen]byte{'M', 'T', 'H', 'D'}) + namepath := tree.newObject(pOpIntNamePath, 0) + namepath.value = []byte{'M', 'T', 'H', 'D'} + flags := tree.newObject(pOpBytePrefix, 0) + flags.value = uint64(0x6) + tree.append(method, namepath) + tree.append(method, flags) + tree.append(scope, method) + + inv := tree.newObject(pOpIntNamePathOrMethodCall, 0) + inv.value = []byte{'M', 'T', 'H', 'D'} + tree.append(scope, inv) + + p := NewParser(os.Stdout, tree) + if res := p.resolveMethodCalls(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func parserForMockPayload(t *testing.T, payload []byte) (*Parser, table.Resolver) { + tree := NewObjectTree() + tree.CreateDefaultScopes(42) + p := NewParser(&testWriter{t: t}, tree) + + resolver := mockByteDataResolver(payload) + + p.init(0, "DSDT", resolver.LookupTable("DSDT")) + return p, resolver +} + +type testWriter struct { + t *testing.T + buf bytes.Buffer +} + +func (t *testWriter) Write(data []byte) (int, error) { + for _, b := range data { + if b == '\n' { + t.t.Log(t.buf.String()) + t.buf.Reset() + continue + } + _ = t.buf.WriteByte(b) + } + + return len(data), nil +} + +type mockByteDataResolver []byte + +func (m mockByteDataResolver) LookupTable(string) *table.SDTHeader { + headerLen := unsafe.Sizeof(table.SDTHeader{}) + stream := make([]byte, int(headerLen)+len(m)) + copy(stream[headerLen:], m) + + header := (*table.SDTHeader)(unsafe.Pointer(&stream[0])) + header.Signature = [4]byte{'D', 'S', 'D', 'T'} + header.Length = uint32(len(stream)) + header.Revision = 2 + + return header +} + +func pkgDir() string { + _, f, _, _ := runtime.Caller(1) + return filepath.Dir(f) +} + +type mockResolver struct { + pathToDumps string + tableFiles []string +} + +func (m mockResolver) LookupTable(name string) *table.SDTHeader { + for _, f := range m.tableFiles { + if !strings.Contains(f, name) { + continue + } + + data, err := ioutil.ReadFile(filepath.Join(m.pathToDumps, f)) + if err != nil { + panic(err) + } + + return (*table.SDTHeader)(unsafe.Pointer(&data[0])) + } + + return nil +} diff --git a/src/gopheros/device/acpi/aml/stream_reader.go b/src/gopheros/device/acpi/aml/stream_reader.go new file mode 100644 index 0000000..a0a70f8 --- /dev/null +++ b/src/gopheros/device/acpi/aml/stream_reader.go @@ -0,0 +1,107 @@ +package aml + +import ( + "gopheros/kernel" + "reflect" + "unsafe" +) + +var ( + errInvalidUnreadByte = &kernel.Error{Module: "acpi_aml_parser", Message: "bad call to UnreadByte; stream offset is 0"} + errInvalidPkgEnd = &kernel.Error{Module: "acpi_aml_parser", Message: "attempted to set pkgEnd past the end of the stream"} + errReadPastPkgEnd = &kernel.Error{Module: "acpi_aml_parser", Message: "attempted to read past pkgEnd"} +) + +type amlStreamReader struct { + offset uint32 + data []byte + pkgEnd uint32 +} + +// Init sets up the reader so it can read up to dataLen bytes from the virtual +// memory address dataAddr. If a non-zero initialOffset is specified, it will +// be used as the current offset in the stream. +func (r *amlStreamReader) Init(dataAddr uintptr, dataLen, initialOffset uint32) { + // Overlay a byte slice on top of the memory block to be accessed. + r.data = *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{ + Len: int(dataLen), + Cap: int(dataLen), + Data: dataAddr, + })) + + r.SetPkgEnd(dataLen) + r.SetOffset(initialOffset) +} + +// EOF returns true if the end of the pkg has been reached. +func (r *amlStreamReader) EOF() bool { + return r.offset >= r.pkgEnd +} + +func (r *amlStreamReader) SetPkgEnd(pkgEnd uint32) error { + if pkgEnd > uint32(len(r.data)) { + return errInvalidPkgEnd + } + + r.pkgEnd = pkgEnd + return nil +} + +// ReadByte returns the next byte from the stream. +func (r *amlStreamReader) ReadByte() (byte, error) { + if r.EOF() { + return 0, errReadPastPkgEnd + } + + r.offset++ + return r.data[r.offset-1], nil +} + +// PeekByte returns the next byte from the stream without advancing the read pointer. +func (r *amlStreamReader) PeekByte() (byte, error) { + if r.EOF() { + return 0, errReadPastPkgEnd + } + + return r.data[r.offset], nil +} + +// LastByte returns the last byte read off the stream +func (r *amlStreamReader) LastByte() (byte, error) { + if r.offset == 0 { + return 0, errReadPastPkgEnd + } + + return r.data[r.offset-1], nil +} + +// UnreadByte moves back the read pointer by one byte. +func (r *amlStreamReader) UnreadByte() error { + if r.offset == 0 { + return errInvalidUnreadByte + } + + r.offset-- + return nil +} + +// Offset returns the current offset. +func (r *amlStreamReader) Offset() uint32 { + return r.offset +} + +// DataPtr returns a pointer to the stream contents at the current stream offset. +func (r *amlStreamReader) DataPtr() uintptr { + if r.EOF() { + return 0 + } + return uintptr(unsafe.Pointer(&r.data[r.offset])) +} + +// SetOffset sets the reader offset to the supplied value. +func (r *amlStreamReader) SetOffset(off uint32) { + if max := uint32(len(r.data)); off > max { + off = max + } + r.offset = off +} diff --git a/src/gopheros/device/acpi/aml/stream_reader_test.go b/src/gopheros/device/acpi/aml/stream_reader_test.go new file mode 100644 index 0000000..4fab06d --- /dev/null +++ b/src/gopheros/device/acpi/aml/stream_reader_test.go @@ -0,0 +1,131 @@ +package aml + +import ( + "math" + "testing" + "unsafe" +) + +func TestAMLStreamReader(t *testing.T) { + buf := make([]byte, 16) + for i := 0; i < len(buf); i++ { + buf[i] = byte(i) + } + + t.Run("without offset", func(t *testing.T) { + var r amlStreamReader + r.Init( + uintptr(unsafe.Pointer(&buf[0])), + uint32(len(buf)), + 0, + ) + + if err := r.SetPkgEnd(uint32(len(buf) + 1)); err != errInvalidPkgEnd { + t.Fatalf("expected to get errInvalidPkgEnd; got: %v", err) + } + + if err := r.SetPkgEnd(uint32(len(buf))); err != nil { + t.Fatal(err) + } + + if r.EOF() { + t.Fatal("unexpected EOF") + } + + if err := r.UnreadByte(); err != errInvalidUnreadByte { + t.Fatalf("expected errInvalidUnreadByte; got %v", err) + } + + if _, err := r.LastByte(); err != errReadPastPkgEnd { + t.Fatalf("unexpected error: %v", err) + } + + for i := 0; i < len(buf); i++ { + exp := byte(i) + + next, err := r.PeekByte() + if err != nil { + t.Fatal(err) + } + if next != exp { + t.Fatalf("expected PeekByte to return %d; got %d", exp, next) + } + + next, err = r.ReadByte() + if err != nil { + t.Fatal(err) + } + if next != exp { + t.Fatalf("expected ReadByte to return %d; got %d", exp, next) + } + + last, err := r.LastByte() + if err != nil { + t.Fatal(err) + } + if last != exp { + t.Fatalf("expected LastByte to return %d; got %d", exp, last) + } + } + + if err := r.UnreadByte(); err != nil { + t.Fatalf("unexpected error: %v", err) + } + + // Set offset past EOF; reader should cap the offset to len(buf) + r.SetOffset(math.MaxUint32) + + if _, err := r.PeekByte(); err != errReadPastPkgEnd { + t.Fatalf("unexpected error: %v", err) + } + if _, err := r.ReadByte(); err != errReadPastPkgEnd { + t.Fatalf("unexpected error: %v", err) + } + exp := byte(len(buf) - 1) + if last, _ := r.LastByte(); last != exp { + t.Fatalf("expected LastByte to return %d; got %d", exp, last) + } + + }) + + t.Run("with offset", func(t *testing.T) { + var r amlStreamReader + r.Init( + uintptr(unsafe.Pointer(&buf[0])), + uint32(len(buf)), + 8, + ) + + if r.EOF() { + t.Fatal("unexpected EOF") + } + + if exp, got := uint32(8), r.Offset(); got != exp { + t.Fatalf("expected Offset() to return %d; got %d", exp, got) + } + + exp := byte(8) + if next, _ := r.ReadByte(); next != exp { + t.Fatalf("expected ReadByte to return %d; got %d", exp, next) + } + }) + + t.Run("ptr to data", func(t *testing.T) { + var r amlStreamReader + r.Init( + uintptr(unsafe.Pointer(&buf[0])), + uint32(len(buf)), + 8, + ) + + if r.EOF() { + t.Fatal("unexpected EOF") + } + + r.SetOffset(2) + ptr := r.DataPtr() + if got := *((*byte)(unsafe.Pointer(ptr))); got != buf[2] { + t.Fatal("expected DataPtr to return a pointer to buf[2]") + } + }) +} diff --git a/src/gopheros/device/acpi/table/tabletest/DSDT-SSDT.exp b/src/gopheros/device/acpi/table/tabletest/DSDT-SSDT.exp new file mode 100644 index 0000000..9d6afac --- /dev/null +++ b/src/gopheros/device/acpi/table/tabletest/DSDT-SSDT.exp @@ -0,0 +1,3594 @@ + +- [ScopeBlock, name: "\", table: 42, index: 0, offset: 0x0] + +- [ScopeBlock, name: "_GPE", table: 42, index: 1, offset: 0x0] + | +- [Method, name: "_L02", argCount: 0, table: 0, index: 2735, offset: 0x1993] + | | +- [NamePath, table: 0, index: 2736, offset: 0x1995] -> [namepath: "_L02"] + | | +- [BytePrefix, table: 0, index: 2737, offset: 0x1999] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 2738, offset: 0x199a] + | | +- [Notify, table: 0, index: 2739, offset: 0x199a] + | | +- [NamePath, table: 0, index: 2740, offset: 0x199b] -> [namepath: "\/_SB_PCI0GFX0"] + | | +- [BytePrefix, table: 0, index: 2741, offset: 0x19aa] -> [num value; dec: 129, hex: 0x81] + | +- [Method, name: "_L00", argCount: 0, table: 0, index: 2840, offset: 0x1a8d] + | +- [NamePath, table: 0, index: 2841, offset: 0x1a8f] -> [namepath: "_L00"] + | +- [BytePrefix, table: 0, index: 2842, offset: 0x1a93] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 0, index: 2843, offset: 0x1a94] + | +- [Notify, table: 0, index: 2844, offset: 0x1a94] + | | +- [NamePath, table: 0, index: 2845, offset: 0x1a95] -> [namepath: "\/_SB_PCI0BAT0"] + | | +- [BytePrefix, table: 0, index: 2846, offset: 0x1aa4] -> [num value; dec: 128, hex: 0x80] + | +- [Notify, table: 0, index: 2847, offset: 0x1aa6] + | +- [NamePath, table: 0, index: 2848, offset: 0x1aa7] -> [namepath: "\/_SB_PCI0AC__"] + | +- [BytePrefix, table: 0, index: 2849, offset: 0x1ab6] -> [num value; dec: 128, hex: 0x80] + +- [ScopeBlock, name: "_PR_", table: 42, index: 2, offset: 0x0] + | +- [Processor, name: "CPU0", table: 1, index: 3580, offset: 0x2c] + | +- [NamePath, table: 1, index: 3581, offset: 0x2f] -> [namepath: "CPU0"] + | +- [BytePrefix, table: 1, index: 3582, offset: 0x33] -> [num value; dec: 0, hex: 0x0] + | +- [DwordPrefix, table: 1, index: 3583, offset: 0x34] -> [num value; dec: 0, hex: 0x0] + | +- [BytePrefix, table: 1, index: 3584, offset: 0x38] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 1, index: 3585, offset: 0x39] + +- [ScopeBlock, name: "_SB_", table: 42, index: 3, offset: 0x0] + | +- [Method, name: "_INI", argCount: 0, table: 0, index: 369, offset: 0x4cc] + | | +- [NamePath, table: 0, index: 370, offset: 0x4cf] -> [namepath: "_INI"] + | | +- [BytePrefix, table: 0, index: 371, offset: 0x4d3] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 372, offset: 0x4d4] + | | +- [Store, table: 0, index: 373, offset: 0x4d4] + | | | +- [DwordPrefix, table: 0, index: 374, offset: 0x4d5] -> [num value; dec: 195936478, hex: 0xbadc0de] + | | | +- [ResolvedNamePath, table: 0, index: 375, offset: 0x4da] -> [resolved to "VAIN", table: 0, index: 365, offset: 0x4bf] + | | +- [MethodCall, table: 0, index: 376, offset: 0x4de] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 377, offset: 0x4e2] -> [string value: "MEML: "] + | | +- [MethodCall, table: 0, index: 378, offset: 0x4ea] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | +- [ResolvedNamePath, table: 0, index: 379, offset: 0x4ee] -> [resolved to "MEML", table: 0, index: 333, offset: 0x41a] + | | +- [MethodCall, table: 0, index: 380, offset: 0x4f2] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 381, offset: 0x4f6] -> [string value: "UIOA: "] + | | +- [MethodCall, table: 0, index: 382, offset: 0x4fe] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | +- [ResolvedNamePath, table: 0, index: 383, offset: 0x502] -> [resolved to "UIOA", table: 0, index: 334, offset: 0x41f] + | | +- [MethodCall, table: 0, index: 384, offset: 0x506] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 385, offset: 0x50a] -> [string value: "UHPT: "] + | | +- [MethodCall, table: 0, index: 386, offset: 0x512] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | +- [ResolvedNamePath, table: 0, index: 387, offset: 0x516] -> [resolved to "UHPT", table: 0, index: 335, offset: 0x424] + | | +- [MethodCall, table: 0, index: 388, offset: 0x51a] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 389, offset: 0x51e] -> [string value: "USMC: "] + | | +- [MethodCall, table: 0, index: 390, offset: 0x526] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | +- [ResolvedNamePath, table: 0, index: 391, offset: 0x52a] -> [resolved to "USMC", table: 0, index: 336, offset: 0x429] + | | +- [MethodCall, table: 0, index: 392, offset: 0x52e] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 393, offset: 0x532] -> [string value: "UFDC: "] + | | +- [MethodCall, table: 0, index: 394, offset: 0x53a] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | +- [ResolvedNamePath, table: 0, index: 395, offset: 0x53e] -> [resolved to "UFDC", table: 0, index: 337, offset: 0x42e] + | | +- [MethodCall, table: 0, index: 396, offset: 0x542] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 397, offset: 0x546] -> [string value: "PMNN: "] + | | +- [MethodCall, table: 0, index: 398, offset: 0x54e] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | +- [ResolvedNamePath, table: 0, index: 399, offset: 0x552] -> [resolved to "PMNN", table: 0, index: 342, offset: 0x447] + | +- [Name, name: "PR00", table: 0, index: 400, offset: 0x556] + | | +- [NamePath, table: 0, index: 401, offset: 0x557] -> [namepath: "PR00"] + | | +- [Package, table: 0, index: 402, offset: 0x55b] + | | +- [BytePrefix, table: 0, index: 403, offset: 0x55e] -> [num value; dec: 120, hex: 0x78] + | | +- [ScopeBlock, table: 0, index: 404, offset: 0x55f] + | | +- [Package, table: 0, index: 405, offset: 0x55f] + | | | +- [BytePrefix, table: 0, index: 406, offset: 0x561] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 407, offset: 0x562] + | | | +- [DwordPrefix, table: 0, index: 408, offset: 0x562] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [Zero, table: 0, index: 409, offset: 0x567] + | | | +- [ResolvedNamePath, table: 0, index: 410, offset: 0x568] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 411, offset: 0x56c] + | | +- [Package, table: 0, index: 412, offset: 0x56d] + | | | +- [BytePrefix, table: 0, index: 413, offset: 0x56f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 414, offset: 0x570] + | | | +- [DwordPrefix, table: 0, index: 415, offset: 0x570] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [One, table: 0, index: 416, offset: 0x575] + | | | +- [ResolvedNamePath, table: 0, index: 417, offset: 0x576] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 418, offset: 0x57a] + | | +- [Package, table: 0, index: 419, offset: 0x57b] + | | | +- [BytePrefix, table: 0, index: 420, offset: 0x57d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 421, offset: 0x57e] + | | | +- [DwordPrefix, table: 0, index: 422, offset: 0x57e] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [BytePrefix, table: 0, index: 423, offset: 0x583] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 424, offset: 0x585] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 425, offset: 0x589] + | | +- [Package, table: 0, index: 426, offset: 0x58a] + | | | +- [BytePrefix, table: 0, index: 427, offset: 0x58c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 428, offset: 0x58d] + | | | +- [DwordPrefix, table: 0, index: 429, offset: 0x58d] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [BytePrefix, table: 0, index: 430, offset: 0x592] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 431, offset: 0x594] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 432, offset: 0x598] + | | +- [Package, table: 0, index: 433, offset: 0x599] + | | | +- [BytePrefix, table: 0, index: 434, offset: 0x59b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 435, offset: 0x59c] + | | | +- [DwordPrefix, table: 0, index: 436, offset: 0x59c] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [Zero, table: 0, index: 437, offset: 0x5a1] + | | | +- [ResolvedNamePath, table: 0, index: 438, offset: 0x5a2] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 439, offset: 0x5a6] + | | +- [Package, table: 0, index: 440, offset: 0x5a7] + | | | +- [BytePrefix, table: 0, index: 441, offset: 0x5a9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 442, offset: 0x5aa] + | | | +- [DwordPrefix, table: 0, index: 443, offset: 0x5aa] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [One, table: 0, index: 444, offset: 0x5af] + | | | +- [ResolvedNamePath, table: 0, index: 445, offset: 0x5b0] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 446, offset: 0x5b4] + | | +- [Package, table: 0, index: 447, offset: 0x5b5] + | | | +- [BytePrefix, table: 0, index: 448, offset: 0x5b7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 449, offset: 0x5b8] + | | | +- [DwordPrefix, table: 0, index: 450, offset: 0x5b8] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [BytePrefix, table: 0, index: 451, offset: 0x5bd] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 452, offset: 0x5bf] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 453, offset: 0x5c3] + | | +- [Package, table: 0, index: 454, offset: 0x5c4] + | | | +- [BytePrefix, table: 0, index: 455, offset: 0x5c6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 456, offset: 0x5c7] + | | | +- [DwordPrefix, table: 0, index: 457, offset: 0x5c7] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [BytePrefix, table: 0, index: 458, offset: 0x5cc] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 459, offset: 0x5ce] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 460, offset: 0x5d2] + | | +- [Package, table: 0, index: 461, offset: 0x5d3] + | | | +- [BytePrefix, table: 0, index: 462, offset: 0x5d5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 463, offset: 0x5d6] + | | | +- [DwordPrefix, table: 0, index: 464, offset: 0x5d6] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [Zero, table: 0, index: 465, offset: 0x5db] + | | | +- [ResolvedNamePath, table: 0, index: 466, offset: 0x5dc] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 467, offset: 0x5e0] + | | +- [Package, table: 0, index: 468, offset: 0x5e1] + | | | +- [BytePrefix, table: 0, index: 469, offset: 0x5e3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 470, offset: 0x5e4] + | | | +- [DwordPrefix, table: 0, index: 471, offset: 0x5e4] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [One, table: 0, index: 472, offset: 0x5e9] + | | | +- [ResolvedNamePath, table: 0, index: 473, offset: 0x5ea] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 474, offset: 0x5ee] + | | +- [Package, table: 0, index: 475, offset: 0x5ef] + | | | +- [BytePrefix, table: 0, index: 476, offset: 0x5f1] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 477, offset: 0x5f2] + | | | +- [DwordPrefix, table: 0, index: 478, offset: 0x5f2] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [BytePrefix, table: 0, index: 479, offset: 0x5f7] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 480, offset: 0x5f9] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 481, offset: 0x5fd] + | | +- [Package, table: 0, index: 482, offset: 0x5fe] + | | | +- [BytePrefix, table: 0, index: 483, offset: 0x600] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 484, offset: 0x601] + | | | +- [DwordPrefix, table: 0, index: 485, offset: 0x601] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [BytePrefix, table: 0, index: 486, offset: 0x606] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 487, offset: 0x608] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 488, offset: 0x60c] + | | +- [Package, table: 0, index: 489, offset: 0x60d] + | | | +- [BytePrefix, table: 0, index: 490, offset: 0x60f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 491, offset: 0x610] + | | | +- [DwordPrefix, table: 0, index: 492, offset: 0x610] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [Zero, table: 0, index: 493, offset: 0x615] + | | | +- [ResolvedNamePath, table: 0, index: 494, offset: 0x616] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 495, offset: 0x61a] + | | +- [Package, table: 0, index: 496, offset: 0x61b] + | | | +- [BytePrefix, table: 0, index: 497, offset: 0x61d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 498, offset: 0x61e] + | | | +- [DwordPrefix, table: 0, index: 499, offset: 0x61e] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [One, table: 0, index: 500, offset: 0x623] + | | | +- [ResolvedNamePath, table: 0, index: 501, offset: 0x624] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 502, offset: 0x628] + | | +- [Package, table: 0, index: 503, offset: 0x629] + | | | +- [BytePrefix, table: 0, index: 504, offset: 0x62b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 505, offset: 0x62c] + | | | +- [DwordPrefix, table: 0, index: 506, offset: 0x62c] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [BytePrefix, table: 0, index: 507, offset: 0x631] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 508, offset: 0x633] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 509, offset: 0x637] + | | +- [Package, table: 0, index: 510, offset: 0x638] + | | | +- [BytePrefix, table: 0, index: 511, offset: 0x63a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 512, offset: 0x63b] + | | | +- [DwordPrefix, table: 0, index: 513, offset: 0x63b] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [BytePrefix, table: 0, index: 514, offset: 0x640] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 515, offset: 0x642] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 516, offset: 0x646] + | | +- [Package, table: 0, index: 517, offset: 0x647] + | | | +- [BytePrefix, table: 0, index: 518, offset: 0x649] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 519, offset: 0x64a] + | | | +- [DwordPrefix, table: 0, index: 520, offset: 0x64a] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [Zero, table: 0, index: 521, offset: 0x64f] + | | | +- [ResolvedNamePath, table: 0, index: 522, offset: 0x650] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 523, offset: 0x654] + | | +- [Package, table: 0, index: 524, offset: 0x655] + | | | +- [BytePrefix, table: 0, index: 525, offset: 0x657] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 526, offset: 0x658] + | | | +- [DwordPrefix, table: 0, index: 527, offset: 0x658] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [One, table: 0, index: 528, offset: 0x65d] + | | | +- [ResolvedNamePath, table: 0, index: 529, offset: 0x65e] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 530, offset: 0x662] + | | +- [Package, table: 0, index: 531, offset: 0x663] + | | | +- [BytePrefix, table: 0, index: 532, offset: 0x665] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 533, offset: 0x666] + | | | +- [DwordPrefix, table: 0, index: 534, offset: 0x666] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [BytePrefix, table: 0, index: 535, offset: 0x66b] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 536, offset: 0x66d] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 537, offset: 0x671] + | | +- [Package, table: 0, index: 538, offset: 0x672] + | | | +- [BytePrefix, table: 0, index: 539, offset: 0x674] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 540, offset: 0x675] + | | | +- [DwordPrefix, table: 0, index: 541, offset: 0x675] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [BytePrefix, table: 0, index: 542, offset: 0x67a] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 543, offset: 0x67c] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 544, offset: 0x680] + | | +- [Package, table: 0, index: 545, offset: 0x681] + | | | +- [BytePrefix, table: 0, index: 546, offset: 0x683] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 547, offset: 0x684] + | | | +- [DwordPrefix, table: 0, index: 548, offset: 0x684] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [Zero, table: 0, index: 549, offset: 0x689] + | | | +- [ResolvedNamePath, table: 0, index: 550, offset: 0x68a] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 551, offset: 0x68e] + | | +- [Package, table: 0, index: 552, offset: 0x68f] + | | | +- [BytePrefix, table: 0, index: 553, offset: 0x691] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 554, offset: 0x692] + | | | +- [DwordPrefix, table: 0, index: 555, offset: 0x692] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [One, table: 0, index: 556, offset: 0x697] + | | | +- [ResolvedNamePath, table: 0, index: 557, offset: 0x698] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 558, offset: 0x69c] + | | +- [Package, table: 0, index: 559, offset: 0x69d] + | | | +- [BytePrefix, table: 0, index: 560, offset: 0x69f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 561, offset: 0x6a0] + | | | +- [DwordPrefix, table: 0, index: 562, offset: 0x6a0] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [BytePrefix, table: 0, index: 563, offset: 0x6a5] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 564, offset: 0x6a7] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 565, offset: 0x6ab] + | | +- [Package, table: 0, index: 566, offset: 0x6ac] + | | | +- [BytePrefix, table: 0, index: 567, offset: 0x6ae] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 568, offset: 0x6af] + | | | +- [DwordPrefix, table: 0, index: 569, offset: 0x6af] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [BytePrefix, table: 0, index: 570, offset: 0x6b4] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 571, offset: 0x6b6] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 572, offset: 0x6ba] + | | +- [Package, table: 0, index: 573, offset: 0x6bb] + | | | +- [BytePrefix, table: 0, index: 574, offset: 0x6bd] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 575, offset: 0x6be] + | | | +- [DwordPrefix, table: 0, index: 576, offset: 0x6be] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [Zero, table: 0, index: 577, offset: 0x6c3] + | | | +- [ResolvedNamePath, table: 0, index: 578, offset: 0x6c4] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 579, offset: 0x6c8] + | | +- [Package, table: 0, index: 580, offset: 0x6c9] + | | | +- [BytePrefix, table: 0, index: 581, offset: 0x6cb] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 582, offset: 0x6cc] + | | | +- [DwordPrefix, table: 0, index: 583, offset: 0x6cc] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [One, table: 0, index: 584, offset: 0x6d1] + | | | +- [ResolvedNamePath, table: 0, index: 585, offset: 0x6d2] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 586, offset: 0x6d6] + | | +- [Package, table: 0, index: 587, offset: 0x6d7] + | | | +- [BytePrefix, table: 0, index: 588, offset: 0x6d9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 589, offset: 0x6da] + | | | +- [DwordPrefix, table: 0, index: 590, offset: 0x6da] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [BytePrefix, table: 0, index: 591, offset: 0x6df] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 592, offset: 0x6e1] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 593, offset: 0x6e5] + | | +- [Package, table: 0, index: 594, offset: 0x6e6] + | | | +- [BytePrefix, table: 0, index: 595, offset: 0x6e8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 596, offset: 0x6e9] + | | | +- [DwordPrefix, table: 0, index: 597, offset: 0x6e9] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [BytePrefix, table: 0, index: 598, offset: 0x6ee] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 599, offset: 0x6f0] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 600, offset: 0x6f4] + | | +- [Package, table: 0, index: 601, offset: 0x6f5] + | | | +- [BytePrefix, table: 0, index: 602, offset: 0x6f7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 603, offset: 0x6f8] + | | | +- [DwordPrefix, table: 0, index: 604, offset: 0x6f8] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [Zero, table: 0, index: 605, offset: 0x6fd] + | | | +- [ResolvedNamePath, table: 0, index: 606, offset: 0x6fe] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 607, offset: 0x702] + | | +- [Package, table: 0, index: 608, offset: 0x703] + | | | +- [BytePrefix, table: 0, index: 609, offset: 0x705] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 610, offset: 0x706] + | | | +- [DwordPrefix, table: 0, index: 611, offset: 0x706] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [One, table: 0, index: 612, offset: 0x70b] + | | | +- [ResolvedNamePath, table: 0, index: 613, offset: 0x70c] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 614, offset: 0x710] + | | +- [Package, table: 0, index: 615, offset: 0x711] + | | | +- [BytePrefix, table: 0, index: 616, offset: 0x713] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 617, offset: 0x714] + | | | +- [DwordPrefix, table: 0, index: 618, offset: 0x714] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [BytePrefix, table: 0, index: 619, offset: 0x719] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 620, offset: 0x71b] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 621, offset: 0x71f] + | | +- [Package, table: 0, index: 622, offset: 0x720] + | | | +- [BytePrefix, table: 0, index: 623, offset: 0x722] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 624, offset: 0x723] + | | | +- [DwordPrefix, table: 0, index: 625, offset: 0x723] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [BytePrefix, table: 0, index: 626, offset: 0x728] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 627, offset: 0x72a] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 628, offset: 0x72e] + | | +- [Package, table: 0, index: 629, offset: 0x72f] + | | | +- [BytePrefix, table: 0, index: 630, offset: 0x731] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 631, offset: 0x732] + | | | +- [DwordPrefix, table: 0, index: 632, offset: 0x732] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [Zero, table: 0, index: 633, offset: 0x737] + | | | +- [ResolvedNamePath, table: 0, index: 634, offset: 0x738] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 635, offset: 0x73c] + | | +- [Package, table: 0, index: 636, offset: 0x73d] + | | | +- [BytePrefix, table: 0, index: 637, offset: 0x73f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 638, offset: 0x740] + | | | +- [DwordPrefix, table: 0, index: 639, offset: 0x740] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [One, table: 0, index: 640, offset: 0x745] + | | | +- [ResolvedNamePath, table: 0, index: 641, offset: 0x746] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 642, offset: 0x74a] + | | +- [Package, table: 0, index: 643, offset: 0x74b] + | | | +- [BytePrefix, table: 0, index: 644, offset: 0x74d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 645, offset: 0x74e] + | | | +- [DwordPrefix, table: 0, index: 646, offset: 0x74e] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [BytePrefix, table: 0, index: 647, offset: 0x753] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 648, offset: 0x755] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 649, offset: 0x759] + | | +- [Package, table: 0, index: 650, offset: 0x75a] + | | | +- [BytePrefix, table: 0, index: 651, offset: 0x75c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 652, offset: 0x75d] + | | | +- [DwordPrefix, table: 0, index: 653, offset: 0x75d] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [BytePrefix, table: 0, index: 654, offset: 0x762] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 655, offset: 0x764] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 656, offset: 0x768] + | | +- [Package, table: 0, index: 657, offset: 0x769] + | | | +- [BytePrefix, table: 0, index: 658, offset: 0x76b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 659, offset: 0x76c] + | | | +- [DwordPrefix, table: 0, index: 660, offset: 0x76c] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [Zero, table: 0, index: 661, offset: 0x771] + | | | +- [ResolvedNamePath, table: 0, index: 662, offset: 0x772] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 663, offset: 0x776] + | | +- [Package, table: 0, index: 664, offset: 0x777] + | | | +- [BytePrefix, table: 0, index: 665, offset: 0x779] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 666, offset: 0x77a] + | | | +- [DwordPrefix, table: 0, index: 667, offset: 0x77a] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [One, table: 0, index: 668, offset: 0x77f] + | | | +- [ResolvedNamePath, table: 0, index: 669, offset: 0x780] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 670, offset: 0x784] + | | +- [Package, table: 0, index: 671, offset: 0x785] + | | | +- [BytePrefix, table: 0, index: 672, offset: 0x787] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 673, offset: 0x788] + | | | +- [DwordPrefix, table: 0, index: 674, offset: 0x788] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [BytePrefix, table: 0, index: 675, offset: 0x78d] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 676, offset: 0x78f] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 677, offset: 0x793] + | | +- [Package, table: 0, index: 678, offset: 0x794] + | | | +- [BytePrefix, table: 0, index: 679, offset: 0x796] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 680, offset: 0x797] + | | | +- [DwordPrefix, table: 0, index: 681, offset: 0x797] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [BytePrefix, table: 0, index: 682, offset: 0x79c] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 683, offset: 0x79e] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 684, offset: 0x7a2] + | | +- [Package, table: 0, index: 685, offset: 0x7a3] + | | | +- [BytePrefix, table: 0, index: 686, offset: 0x7a5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 687, offset: 0x7a6] + | | | +- [DwordPrefix, table: 0, index: 688, offset: 0x7a6] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [Zero, table: 0, index: 689, offset: 0x7ab] + | | | +- [ResolvedNamePath, table: 0, index: 690, offset: 0x7ac] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 691, offset: 0x7b0] + | | +- [Package, table: 0, index: 692, offset: 0x7b1] + | | | +- [BytePrefix, table: 0, index: 693, offset: 0x7b3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 694, offset: 0x7b4] + | | | +- [DwordPrefix, table: 0, index: 695, offset: 0x7b4] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [One, table: 0, index: 696, offset: 0x7b9] + | | | +- [ResolvedNamePath, table: 0, index: 697, offset: 0x7ba] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 698, offset: 0x7be] + | | +- [Package, table: 0, index: 699, offset: 0x7bf] + | | | +- [BytePrefix, table: 0, index: 700, offset: 0x7c1] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 701, offset: 0x7c2] + | | | +- [DwordPrefix, table: 0, index: 702, offset: 0x7c2] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [BytePrefix, table: 0, index: 703, offset: 0x7c7] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 704, offset: 0x7c9] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 705, offset: 0x7cd] + | | +- [Package, table: 0, index: 706, offset: 0x7ce] + | | | +- [BytePrefix, table: 0, index: 707, offset: 0x7d0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 708, offset: 0x7d1] + | | | +- [DwordPrefix, table: 0, index: 709, offset: 0x7d1] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [BytePrefix, table: 0, index: 710, offset: 0x7d6] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 711, offset: 0x7d8] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 712, offset: 0x7dc] + | | +- [Package, table: 0, index: 713, offset: 0x7dd] + | | | +- [BytePrefix, table: 0, index: 714, offset: 0x7df] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 715, offset: 0x7e0] + | | | +- [DwordPrefix, table: 0, index: 716, offset: 0x7e0] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [Zero, table: 0, index: 717, offset: 0x7e5] + | | | +- [ResolvedNamePath, table: 0, index: 718, offset: 0x7e6] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 719, offset: 0x7ea] + | | +- [Package, table: 0, index: 720, offset: 0x7eb] + | | | +- [BytePrefix, table: 0, index: 721, offset: 0x7ed] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 722, offset: 0x7ee] + | | | +- [DwordPrefix, table: 0, index: 723, offset: 0x7ee] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [One, table: 0, index: 724, offset: 0x7f3] + | | | +- [ResolvedNamePath, table: 0, index: 725, offset: 0x7f4] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 726, offset: 0x7f8] + | | +- [Package, table: 0, index: 727, offset: 0x7f9] + | | | +- [BytePrefix, table: 0, index: 728, offset: 0x7fb] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 729, offset: 0x7fc] + | | | +- [DwordPrefix, table: 0, index: 730, offset: 0x7fc] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [BytePrefix, table: 0, index: 731, offset: 0x801] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 732, offset: 0x803] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 733, offset: 0x807] + | | +- [Package, table: 0, index: 734, offset: 0x808] + | | | +- [BytePrefix, table: 0, index: 735, offset: 0x80a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 736, offset: 0x80b] + | | | +- [DwordPrefix, table: 0, index: 737, offset: 0x80b] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [BytePrefix, table: 0, index: 738, offset: 0x810] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 739, offset: 0x812] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 740, offset: 0x816] + | | +- [Package, table: 0, index: 741, offset: 0x817] + | | | +- [BytePrefix, table: 0, index: 742, offset: 0x819] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 743, offset: 0x81a] + | | | +- [DwordPrefix, table: 0, index: 744, offset: 0x81a] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [Zero, table: 0, index: 745, offset: 0x81f] + | | | +- [ResolvedNamePath, table: 0, index: 746, offset: 0x820] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 747, offset: 0x824] + | | +- [Package, table: 0, index: 748, offset: 0x825] + | | | +- [BytePrefix, table: 0, index: 749, offset: 0x827] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 750, offset: 0x828] + | | | +- [DwordPrefix, table: 0, index: 751, offset: 0x828] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [One, table: 0, index: 752, offset: 0x82d] + | | | +- [ResolvedNamePath, table: 0, index: 753, offset: 0x82e] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 754, offset: 0x832] + | | +- [Package, table: 0, index: 755, offset: 0x833] + | | | +- [BytePrefix, table: 0, index: 756, offset: 0x835] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 757, offset: 0x836] + | | | +- [DwordPrefix, table: 0, index: 758, offset: 0x836] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [BytePrefix, table: 0, index: 759, offset: 0x83b] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 760, offset: 0x83d] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 761, offset: 0x841] + | | +- [Package, table: 0, index: 762, offset: 0x842] + | | | +- [BytePrefix, table: 0, index: 763, offset: 0x844] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 764, offset: 0x845] + | | | +- [DwordPrefix, table: 0, index: 765, offset: 0x845] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [BytePrefix, table: 0, index: 766, offset: 0x84a] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 767, offset: 0x84c] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 768, offset: 0x850] + | | +- [Package, table: 0, index: 769, offset: 0x851] + | | | +- [BytePrefix, table: 0, index: 770, offset: 0x853] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 771, offset: 0x854] + | | | +- [DwordPrefix, table: 0, index: 772, offset: 0x854] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [Zero, table: 0, index: 773, offset: 0x859] + | | | +- [ResolvedNamePath, table: 0, index: 774, offset: 0x85a] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 775, offset: 0x85e] + | | +- [Package, table: 0, index: 776, offset: 0x85f] + | | | +- [BytePrefix, table: 0, index: 777, offset: 0x861] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 778, offset: 0x862] + | | | +- [DwordPrefix, table: 0, index: 779, offset: 0x862] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [One, table: 0, index: 780, offset: 0x867] + | | | +- [ResolvedNamePath, table: 0, index: 781, offset: 0x868] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 782, offset: 0x86c] + | | +- [Package, table: 0, index: 783, offset: 0x86d] + | | | +- [BytePrefix, table: 0, index: 784, offset: 0x86f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 785, offset: 0x870] + | | | +- [DwordPrefix, table: 0, index: 786, offset: 0x870] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [BytePrefix, table: 0, index: 787, offset: 0x875] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 788, offset: 0x877] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 789, offset: 0x87b] + | | +- [Package, table: 0, index: 790, offset: 0x87c] + | | | +- [BytePrefix, table: 0, index: 791, offset: 0x87e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 792, offset: 0x87f] + | | | +- [DwordPrefix, table: 0, index: 793, offset: 0x87f] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [BytePrefix, table: 0, index: 794, offset: 0x884] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 795, offset: 0x886] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 796, offset: 0x88a] + | | +- [Package, table: 0, index: 797, offset: 0x88b] + | | | +- [BytePrefix, table: 0, index: 798, offset: 0x88d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 799, offset: 0x88e] + | | | +- [DwordPrefix, table: 0, index: 800, offset: 0x88e] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [Zero, table: 0, index: 801, offset: 0x893] + | | | +- [ResolvedNamePath, table: 0, index: 802, offset: 0x894] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 803, offset: 0x898] + | | +- [Package, table: 0, index: 804, offset: 0x899] + | | | +- [BytePrefix, table: 0, index: 805, offset: 0x89b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 806, offset: 0x89c] + | | | +- [DwordPrefix, table: 0, index: 807, offset: 0x89c] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [One, table: 0, index: 808, offset: 0x8a1] + | | | +- [ResolvedNamePath, table: 0, index: 809, offset: 0x8a2] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 810, offset: 0x8a6] + | | +- [Package, table: 0, index: 811, offset: 0x8a7] + | | | +- [BytePrefix, table: 0, index: 812, offset: 0x8a9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 813, offset: 0x8aa] + | | | +- [DwordPrefix, table: 0, index: 814, offset: 0x8aa] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [BytePrefix, table: 0, index: 815, offset: 0x8af] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 816, offset: 0x8b1] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 817, offset: 0x8b5] + | | +- [Package, table: 0, index: 818, offset: 0x8b6] + | | | +- [BytePrefix, table: 0, index: 819, offset: 0x8b8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 820, offset: 0x8b9] + | | | +- [DwordPrefix, table: 0, index: 821, offset: 0x8b9] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [BytePrefix, table: 0, index: 822, offset: 0x8be] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 823, offset: 0x8c0] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 824, offset: 0x8c4] + | | +- [Package, table: 0, index: 825, offset: 0x8c5] + | | | +- [BytePrefix, table: 0, index: 826, offset: 0x8c7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 827, offset: 0x8c8] + | | | +- [DwordPrefix, table: 0, index: 828, offset: 0x8c8] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [Zero, table: 0, index: 829, offset: 0x8cd] + | | | +- [ResolvedNamePath, table: 0, index: 830, offset: 0x8ce] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 831, offset: 0x8d2] + | | +- [Package, table: 0, index: 832, offset: 0x8d3] + | | | +- [BytePrefix, table: 0, index: 833, offset: 0x8d5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 834, offset: 0x8d6] + | | | +- [DwordPrefix, table: 0, index: 835, offset: 0x8d6] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [One, table: 0, index: 836, offset: 0x8db] + | | | +- [ResolvedNamePath, table: 0, index: 837, offset: 0x8dc] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 838, offset: 0x8e0] + | | +- [Package, table: 0, index: 839, offset: 0x8e1] + | | | +- [BytePrefix, table: 0, index: 840, offset: 0x8e3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 841, offset: 0x8e4] + | | | +- [DwordPrefix, table: 0, index: 842, offset: 0x8e4] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [BytePrefix, table: 0, index: 843, offset: 0x8e9] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 844, offset: 0x8eb] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 845, offset: 0x8ef] + | | +- [Package, table: 0, index: 846, offset: 0x8f0] + | | | +- [BytePrefix, table: 0, index: 847, offset: 0x8f2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 848, offset: 0x8f3] + | | | +- [DwordPrefix, table: 0, index: 849, offset: 0x8f3] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [BytePrefix, table: 0, index: 850, offset: 0x8f8] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 851, offset: 0x8fa] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 852, offset: 0x8fe] + | | +- [Package, table: 0, index: 853, offset: 0x8ff] + | | | +- [BytePrefix, table: 0, index: 854, offset: 0x901] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 855, offset: 0x902] + | | | +- [DwordPrefix, table: 0, index: 856, offset: 0x902] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [Zero, table: 0, index: 857, offset: 0x907] + | | | +- [ResolvedNamePath, table: 0, index: 858, offset: 0x908] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 859, offset: 0x90c] + | | +- [Package, table: 0, index: 860, offset: 0x90d] + | | | +- [BytePrefix, table: 0, index: 861, offset: 0x90f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 862, offset: 0x910] + | | | +- [DwordPrefix, table: 0, index: 863, offset: 0x910] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [One, table: 0, index: 864, offset: 0x915] + | | | +- [ResolvedNamePath, table: 0, index: 865, offset: 0x916] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 866, offset: 0x91a] + | | +- [Package, table: 0, index: 867, offset: 0x91b] + | | | +- [BytePrefix, table: 0, index: 868, offset: 0x91d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 869, offset: 0x91e] + | | | +- [DwordPrefix, table: 0, index: 870, offset: 0x91e] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [BytePrefix, table: 0, index: 871, offset: 0x923] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 872, offset: 0x925] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 873, offset: 0x929] + | | +- [Package, table: 0, index: 874, offset: 0x92a] + | | | +- [BytePrefix, table: 0, index: 875, offset: 0x92c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 876, offset: 0x92d] + | | | +- [DwordPrefix, table: 0, index: 877, offset: 0x92d] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [BytePrefix, table: 0, index: 878, offset: 0x932] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 879, offset: 0x934] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 880, offset: 0x938] + | | +- [Package, table: 0, index: 881, offset: 0x939] + | | | +- [BytePrefix, table: 0, index: 882, offset: 0x93b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 883, offset: 0x93c] + | | | +- [DwordPrefix, table: 0, index: 884, offset: 0x93c] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [Zero, table: 0, index: 885, offset: 0x941] + | | | +- [ResolvedNamePath, table: 0, index: 886, offset: 0x942] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 887, offset: 0x946] + | | +- [Package, table: 0, index: 888, offset: 0x947] + | | | +- [BytePrefix, table: 0, index: 889, offset: 0x949] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 890, offset: 0x94a] + | | | +- [DwordPrefix, table: 0, index: 891, offset: 0x94a] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [One, table: 0, index: 892, offset: 0x94f] + | | | +- [ResolvedNamePath, table: 0, index: 893, offset: 0x950] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 894, offset: 0x954] + | | +- [Package, table: 0, index: 895, offset: 0x955] + | | | +- [BytePrefix, table: 0, index: 896, offset: 0x957] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 897, offset: 0x958] + | | | +- [DwordPrefix, table: 0, index: 898, offset: 0x958] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [BytePrefix, table: 0, index: 899, offset: 0x95d] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 900, offset: 0x95f] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 901, offset: 0x963] + | | +- [Package, table: 0, index: 902, offset: 0x964] + | | | +- [BytePrefix, table: 0, index: 903, offset: 0x966] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 904, offset: 0x967] + | | | +- [DwordPrefix, table: 0, index: 905, offset: 0x967] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [BytePrefix, table: 0, index: 906, offset: 0x96c] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 907, offset: 0x96e] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 908, offset: 0x972] + | | +- [Package, table: 0, index: 909, offset: 0x973] + | | | +- [BytePrefix, table: 0, index: 910, offset: 0x975] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 911, offset: 0x976] + | | | +- [DwordPrefix, table: 0, index: 912, offset: 0x976] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [Zero, table: 0, index: 913, offset: 0x97b] + | | | +- [ResolvedNamePath, table: 0, index: 914, offset: 0x97c] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 915, offset: 0x980] + | | +- [Package, table: 0, index: 916, offset: 0x981] + | | | +- [BytePrefix, table: 0, index: 917, offset: 0x983] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 918, offset: 0x984] + | | | +- [DwordPrefix, table: 0, index: 919, offset: 0x984] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [One, table: 0, index: 920, offset: 0x989] + | | | +- [ResolvedNamePath, table: 0, index: 921, offset: 0x98a] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 922, offset: 0x98e] + | | +- [Package, table: 0, index: 923, offset: 0x98f] + | | | +- [BytePrefix, table: 0, index: 924, offset: 0x991] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 925, offset: 0x992] + | | | +- [DwordPrefix, table: 0, index: 926, offset: 0x992] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [BytePrefix, table: 0, index: 927, offset: 0x997] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 928, offset: 0x999] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 929, offset: 0x99d] + | | +- [Package, table: 0, index: 930, offset: 0x99e] + | | | +- [BytePrefix, table: 0, index: 931, offset: 0x9a0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 932, offset: 0x9a1] + | | | +- [DwordPrefix, table: 0, index: 933, offset: 0x9a1] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [BytePrefix, table: 0, index: 934, offset: 0x9a6] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 935, offset: 0x9a8] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 936, offset: 0x9ac] + | | +- [Package, table: 0, index: 937, offset: 0x9ad] + | | | +- [BytePrefix, table: 0, index: 938, offset: 0x9af] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 939, offset: 0x9b0] + | | | +- [DwordPrefix, table: 0, index: 940, offset: 0x9b0] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [Zero, table: 0, index: 941, offset: 0x9b5] + | | | +- [ResolvedNamePath, table: 0, index: 942, offset: 0x9b6] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 943, offset: 0x9ba] + | | +- [Package, table: 0, index: 944, offset: 0x9bb] + | | | +- [BytePrefix, table: 0, index: 945, offset: 0x9bd] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 946, offset: 0x9be] + | | | +- [DwordPrefix, table: 0, index: 947, offset: 0x9be] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [One, table: 0, index: 948, offset: 0x9c3] + | | | +- [ResolvedNamePath, table: 0, index: 949, offset: 0x9c4] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 950, offset: 0x9c8] + | | +- [Package, table: 0, index: 951, offset: 0x9c9] + | | | +- [BytePrefix, table: 0, index: 952, offset: 0x9cb] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 953, offset: 0x9cc] + | | | +- [DwordPrefix, table: 0, index: 954, offset: 0x9cc] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [BytePrefix, table: 0, index: 955, offset: 0x9d1] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 956, offset: 0x9d3] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 957, offset: 0x9d7] + | | +- [Package, table: 0, index: 958, offset: 0x9d8] + | | | +- [BytePrefix, table: 0, index: 959, offset: 0x9da] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 960, offset: 0x9db] + | | | +- [DwordPrefix, table: 0, index: 961, offset: 0x9db] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [BytePrefix, table: 0, index: 962, offset: 0x9e0] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 963, offset: 0x9e2] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 964, offset: 0x9e6] + | | +- [Package, table: 0, index: 965, offset: 0x9e7] + | | | +- [BytePrefix, table: 0, index: 966, offset: 0x9e9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 967, offset: 0x9ea] + | | | +- [DwordPrefix, table: 0, index: 968, offset: 0x9ea] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [Zero, table: 0, index: 969, offset: 0x9ef] + | | | +- [ResolvedNamePath, table: 0, index: 970, offset: 0x9f0] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 971, offset: 0x9f4] + | | +- [Package, table: 0, index: 972, offset: 0x9f5] + | | | +- [BytePrefix, table: 0, index: 973, offset: 0x9f7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 974, offset: 0x9f8] + | | | +- [DwordPrefix, table: 0, index: 975, offset: 0x9f8] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [One, table: 0, index: 976, offset: 0x9fd] + | | | +- [ResolvedNamePath, table: 0, index: 977, offset: 0x9fe] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 978, offset: 0xa02] + | | +- [Package, table: 0, index: 979, offset: 0xa03] + | | | +- [BytePrefix, table: 0, index: 980, offset: 0xa05] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 981, offset: 0xa06] + | | | +- [DwordPrefix, table: 0, index: 982, offset: 0xa06] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [BytePrefix, table: 0, index: 983, offset: 0xa0b] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 984, offset: 0xa0d] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 985, offset: 0xa11] + | | +- [Package, table: 0, index: 986, offset: 0xa12] + | | | +- [BytePrefix, table: 0, index: 987, offset: 0xa14] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 988, offset: 0xa15] + | | | +- [DwordPrefix, table: 0, index: 989, offset: 0xa15] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [BytePrefix, table: 0, index: 990, offset: 0xa1a] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 991, offset: 0xa1c] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 992, offset: 0xa20] + | | +- [Package, table: 0, index: 993, offset: 0xa21] + | | | +- [BytePrefix, table: 0, index: 994, offset: 0xa23] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 995, offset: 0xa24] + | | | +- [DwordPrefix, table: 0, index: 996, offset: 0xa24] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [Zero, table: 0, index: 997, offset: 0xa29] + | | | +- [ResolvedNamePath, table: 0, index: 998, offset: 0xa2a] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 999, offset: 0xa2e] + | | +- [Package, table: 0, index: 1000, offset: 0xa2f] + | | | +- [BytePrefix, table: 0, index: 1001, offset: 0xa31] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1002, offset: 0xa32] + | | | +- [DwordPrefix, table: 0, index: 1003, offset: 0xa32] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [One, table: 0, index: 1004, offset: 0xa37] + | | | +- [ResolvedNamePath, table: 0, index: 1005, offset: 0xa38] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1006, offset: 0xa3c] + | | +- [Package, table: 0, index: 1007, offset: 0xa3d] + | | | +- [BytePrefix, table: 0, index: 1008, offset: 0xa3f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1009, offset: 0xa40] + | | | +- [DwordPrefix, table: 0, index: 1010, offset: 0xa40] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [BytePrefix, table: 0, index: 1011, offset: 0xa45] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1012, offset: 0xa47] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1013, offset: 0xa4b] + | | +- [Package, table: 0, index: 1014, offset: 0xa4c] + | | | +- [BytePrefix, table: 0, index: 1015, offset: 0xa4e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1016, offset: 0xa4f] + | | | +- [DwordPrefix, table: 0, index: 1017, offset: 0xa4f] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [BytePrefix, table: 0, index: 1018, offset: 0xa54] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1019, offset: 0xa56] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1020, offset: 0xa5a] + | | +- [Package, table: 0, index: 1021, offset: 0xa5b] + | | | +- [BytePrefix, table: 0, index: 1022, offset: 0xa5d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1023, offset: 0xa5e] + | | | +- [DwordPrefix, table: 0, index: 1024, offset: 0xa5e] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [Zero, table: 0, index: 1025, offset: 0xa63] + | | | +- [ResolvedNamePath, table: 0, index: 1026, offset: 0xa64] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1027, offset: 0xa68] + | | +- [Package, table: 0, index: 1028, offset: 0xa69] + | | | +- [BytePrefix, table: 0, index: 1029, offset: 0xa6b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1030, offset: 0xa6c] + | | | +- [DwordPrefix, table: 0, index: 1031, offset: 0xa6c] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [One, table: 0, index: 1032, offset: 0xa71] + | | | +- [ResolvedNamePath, table: 0, index: 1033, offset: 0xa72] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1034, offset: 0xa76] + | | +- [Package, table: 0, index: 1035, offset: 0xa77] + | | | +- [BytePrefix, table: 0, index: 1036, offset: 0xa79] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1037, offset: 0xa7a] + | | | +- [DwordPrefix, table: 0, index: 1038, offset: 0xa7a] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [BytePrefix, table: 0, index: 1039, offset: 0xa7f] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1040, offset: 0xa81] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1041, offset: 0xa85] + | | +- [Package, table: 0, index: 1042, offset: 0xa86] + | | | +- [BytePrefix, table: 0, index: 1043, offset: 0xa88] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1044, offset: 0xa89] + | | | +- [DwordPrefix, table: 0, index: 1045, offset: 0xa89] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [BytePrefix, table: 0, index: 1046, offset: 0xa8e] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1047, offset: 0xa90] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1048, offset: 0xa94] + | | +- [Package, table: 0, index: 1049, offset: 0xa95] + | | | +- [BytePrefix, table: 0, index: 1050, offset: 0xa97] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1051, offset: 0xa98] + | | | +- [DwordPrefix, table: 0, index: 1052, offset: 0xa98] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [Zero, table: 0, index: 1053, offset: 0xa9d] + | | | +- [ResolvedNamePath, table: 0, index: 1054, offset: 0xa9e] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1055, offset: 0xaa2] + | | +- [Package, table: 0, index: 1056, offset: 0xaa3] + | | | +- [BytePrefix, table: 0, index: 1057, offset: 0xaa5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1058, offset: 0xaa6] + | | | +- [DwordPrefix, table: 0, index: 1059, offset: 0xaa6] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [One, table: 0, index: 1060, offset: 0xaab] + | | | +- [ResolvedNamePath, table: 0, index: 1061, offset: 0xaac] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1062, offset: 0xab0] + | | +- [Package, table: 0, index: 1063, offset: 0xab1] + | | | +- [BytePrefix, table: 0, index: 1064, offset: 0xab3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1065, offset: 0xab4] + | | | +- [DwordPrefix, table: 0, index: 1066, offset: 0xab4] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [BytePrefix, table: 0, index: 1067, offset: 0xab9] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1068, offset: 0xabb] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1069, offset: 0xabf] + | | +- [Package, table: 0, index: 1070, offset: 0xac0] + | | | +- [BytePrefix, table: 0, index: 1071, offset: 0xac2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1072, offset: 0xac3] + | | | +- [DwordPrefix, table: 0, index: 1073, offset: 0xac3] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [BytePrefix, table: 0, index: 1074, offset: 0xac8] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1075, offset: 0xaca] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1076, offset: 0xace] + | | +- [Package, table: 0, index: 1077, offset: 0xacf] + | | | +- [BytePrefix, table: 0, index: 1078, offset: 0xad1] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1079, offset: 0xad2] + | | | +- [DwordPrefix, table: 0, index: 1080, offset: 0xad2] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [Zero, table: 0, index: 1081, offset: 0xad7] + | | | +- [ResolvedNamePath, table: 0, index: 1082, offset: 0xad8] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1083, offset: 0xadc] + | | +- [Package, table: 0, index: 1084, offset: 0xadd] + | | | +- [BytePrefix, table: 0, index: 1085, offset: 0xadf] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1086, offset: 0xae0] + | | | +- [DwordPrefix, table: 0, index: 1087, offset: 0xae0] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [One, table: 0, index: 1088, offset: 0xae5] + | | | +- [ResolvedNamePath, table: 0, index: 1089, offset: 0xae6] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1090, offset: 0xaea] + | | +- [Package, table: 0, index: 1091, offset: 0xaeb] + | | | +- [BytePrefix, table: 0, index: 1092, offset: 0xaed] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1093, offset: 0xaee] + | | | +- [DwordPrefix, table: 0, index: 1094, offset: 0xaee] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [BytePrefix, table: 0, index: 1095, offset: 0xaf3] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1096, offset: 0xaf5] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1097, offset: 0xaf9] + | | +- [Package, table: 0, index: 1098, offset: 0xafa] + | | | +- [BytePrefix, table: 0, index: 1099, offset: 0xafc] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1100, offset: 0xafd] + | | | +- [DwordPrefix, table: 0, index: 1101, offset: 0xafd] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [BytePrefix, table: 0, index: 1102, offset: 0xb02] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1103, offset: 0xb04] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1104, offset: 0xb08] + | | +- [Package, table: 0, index: 1105, offset: 0xb09] + | | | +- [BytePrefix, table: 0, index: 1106, offset: 0xb0b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1107, offset: 0xb0c] + | | | +- [DwordPrefix, table: 0, index: 1108, offset: 0xb0c] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [Zero, table: 0, index: 1109, offset: 0xb11] + | | | +- [ResolvedNamePath, table: 0, index: 1110, offset: 0xb12] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1111, offset: 0xb16] + | | +- [Package, table: 0, index: 1112, offset: 0xb17] + | | | +- [BytePrefix, table: 0, index: 1113, offset: 0xb19] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1114, offset: 0xb1a] + | | | +- [DwordPrefix, table: 0, index: 1115, offset: 0xb1a] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [One, table: 0, index: 1116, offset: 0xb1f] + | | | +- [ResolvedNamePath, table: 0, index: 1117, offset: 0xb20] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1118, offset: 0xb24] + | | +- [Package, table: 0, index: 1119, offset: 0xb25] + | | | +- [BytePrefix, table: 0, index: 1120, offset: 0xb27] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1121, offset: 0xb28] + | | | +- [DwordPrefix, table: 0, index: 1122, offset: 0xb28] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [BytePrefix, table: 0, index: 1123, offset: 0xb2d] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1124, offset: 0xb2f] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1125, offset: 0xb33] + | | +- [Package, table: 0, index: 1126, offset: 0xb34] + | | | +- [BytePrefix, table: 0, index: 1127, offset: 0xb36] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1128, offset: 0xb37] + | | | +- [DwordPrefix, table: 0, index: 1129, offset: 0xb37] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [BytePrefix, table: 0, index: 1130, offset: 0xb3c] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1131, offset: 0xb3e] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1132, offset: 0xb42] + | | +- [Package, table: 0, index: 1133, offset: 0xb43] + | | | +- [BytePrefix, table: 0, index: 1134, offset: 0xb45] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1135, offset: 0xb46] + | | | +- [DwordPrefix, table: 0, index: 1136, offset: 0xb46] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [Zero, table: 0, index: 1137, offset: 0xb4b] + | | | +- [ResolvedNamePath, table: 0, index: 1138, offset: 0xb4c] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1139, offset: 0xb50] + | | +- [Package, table: 0, index: 1140, offset: 0xb51] + | | | +- [BytePrefix, table: 0, index: 1141, offset: 0xb53] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1142, offset: 0xb54] + | | | +- [DwordPrefix, table: 0, index: 1143, offset: 0xb54] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [One, table: 0, index: 1144, offset: 0xb59] + | | | +- [ResolvedNamePath, table: 0, index: 1145, offset: 0xb5a] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1146, offset: 0xb5e] + | | +- [Package, table: 0, index: 1147, offset: 0xb5f] + | | | +- [BytePrefix, table: 0, index: 1148, offset: 0xb61] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1149, offset: 0xb62] + | | | +- [DwordPrefix, table: 0, index: 1150, offset: 0xb62] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [BytePrefix, table: 0, index: 1151, offset: 0xb67] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1152, offset: 0xb69] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1153, offset: 0xb6d] + | | +- [Package, table: 0, index: 1154, offset: 0xb6e] + | | | +- [BytePrefix, table: 0, index: 1155, offset: 0xb70] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1156, offset: 0xb71] + | | | +- [DwordPrefix, table: 0, index: 1157, offset: 0xb71] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [BytePrefix, table: 0, index: 1158, offset: 0xb76] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1159, offset: 0xb78] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1160, offset: 0xb7c] + | | +- [Package, table: 0, index: 1161, offset: 0xb7d] + | | | +- [BytePrefix, table: 0, index: 1162, offset: 0xb7f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1163, offset: 0xb80] + | | | +- [DwordPrefix, table: 0, index: 1164, offset: 0xb80] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [Zero, table: 0, index: 1165, offset: 0xb85] + | | | +- [ResolvedNamePath, table: 0, index: 1166, offset: 0xb86] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1167, offset: 0xb8a] + | | +- [Package, table: 0, index: 1168, offset: 0xb8b] + | | | +- [BytePrefix, table: 0, index: 1169, offset: 0xb8d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1170, offset: 0xb8e] + | | | +- [DwordPrefix, table: 0, index: 1171, offset: 0xb8e] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [One, table: 0, index: 1172, offset: 0xb93] + | | | +- [ResolvedNamePath, table: 0, index: 1173, offset: 0xb94] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1174, offset: 0xb98] + | | +- [Package, table: 0, index: 1175, offset: 0xb99] + | | | +- [BytePrefix, table: 0, index: 1176, offset: 0xb9b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1177, offset: 0xb9c] + | | | +- [DwordPrefix, table: 0, index: 1178, offset: 0xb9c] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [BytePrefix, table: 0, index: 1179, offset: 0xba1] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1180, offset: 0xba3] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1181, offset: 0xba7] + | | +- [Package, table: 0, index: 1182, offset: 0xba8] + | | | +- [BytePrefix, table: 0, index: 1183, offset: 0xbaa] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1184, offset: 0xbab] + | | | +- [DwordPrefix, table: 0, index: 1185, offset: 0xbab] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [BytePrefix, table: 0, index: 1186, offset: 0xbb0] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1187, offset: 0xbb2] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1188, offset: 0xbb6] + | | +- [Package, table: 0, index: 1189, offset: 0xbb7] + | | | +- [BytePrefix, table: 0, index: 1190, offset: 0xbb9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1191, offset: 0xbba] + | | | +- [DwordPrefix, table: 0, index: 1192, offset: 0xbba] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [Zero, table: 0, index: 1193, offset: 0xbbf] + | | | +- [ResolvedNamePath, table: 0, index: 1194, offset: 0xbc0] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1195, offset: 0xbc4] + | | +- [Package, table: 0, index: 1196, offset: 0xbc5] + | | | +- [BytePrefix, table: 0, index: 1197, offset: 0xbc7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1198, offset: 0xbc8] + | | | +- [DwordPrefix, table: 0, index: 1199, offset: 0xbc8] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [One, table: 0, index: 1200, offset: 0xbcd] + | | | +- [ResolvedNamePath, table: 0, index: 1201, offset: 0xbce] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1202, offset: 0xbd2] + | | +- [Package, table: 0, index: 1203, offset: 0xbd3] + | | | +- [BytePrefix, table: 0, index: 1204, offset: 0xbd5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1205, offset: 0xbd6] + | | | +- [DwordPrefix, table: 0, index: 1206, offset: 0xbd6] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [BytePrefix, table: 0, index: 1207, offset: 0xbdb] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1208, offset: 0xbdd] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1209, offset: 0xbe1] + | | +- [Package, table: 0, index: 1210, offset: 0xbe2] + | | | +- [BytePrefix, table: 0, index: 1211, offset: 0xbe4] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1212, offset: 0xbe5] + | | | +- [DwordPrefix, table: 0, index: 1213, offset: 0xbe5] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [BytePrefix, table: 0, index: 1214, offset: 0xbea] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1215, offset: 0xbec] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1216, offset: 0xbf0] + | | +- [Package, table: 0, index: 1217, offset: 0xbf1] + | | | +- [BytePrefix, table: 0, index: 1218, offset: 0xbf3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1219, offset: 0xbf4] + | | | +- [DwordPrefix, table: 0, index: 1220, offset: 0xbf4] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [Zero, table: 0, index: 1221, offset: 0xbf9] + | | | +- [ResolvedNamePath, table: 0, index: 1222, offset: 0xbfa] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1223, offset: 0xbfe] + | | +- [Package, table: 0, index: 1224, offset: 0xbff] + | | | +- [BytePrefix, table: 0, index: 1225, offset: 0xc01] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1226, offset: 0xc02] + | | | +- [DwordPrefix, table: 0, index: 1227, offset: 0xc02] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [One, table: 0, index: 1228, offset: 0xc07] + | | | +- [ResolvedNamePath, table: 0, index: 1229, offset: 0xc08] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1230, offset: 0xc0c] + | | +- [Package, table: 0, index: 1231, offset: 0xc0d] + | | | +- [BytePrefix, table: 0, index: 1232, offset: 0xc0f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1233, offset: 0xc10] + | | | +- [DwordPrefix, table: 0, index: 1234, offset: 0xc10] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [BytePrefix, table: 0, index: 1235, offset: 0xc15] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1236, offset: 0xc17] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1237, offset: 0xc1b] + | | +- [Package, table: 0, index: 1238, offset: 0xc1c] + | | +- [BytePrefix, table: 0, index: 1239, offset: 0xc1e] -> [num value; dec: 4, hex: 0x4] + | | +- [ScopeBlock, table: 0, index: 1240, offset: 0xc1f] + | | +- [DwordPrefix, table: 0, index: 1241, offset: 0xc1f] -> [num value; dec: 2097151, hex: 0x1fffff] + | | +- [BytePrefix, table: 0, index: 1242, offset: 0xc24] -> [num value; dec: 3, hex: 0x3] + | | +- [ResolvedNamePath, table: 0, index: 1243, offset: 0xc26] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | +- [Zero, table: 0, index: 1244, offset: 0xc2a] + | +- [Name, name: "PR01", table: 0, index: 1245, offset: 0xc2b] + | | +- [NamePath, table: 0, index: 1246, offset: 0xc2c] -> [namepath: "PR01"] + | | +- [Package, table: 0, index: 1247, offset: 0xc30] + | | +- [BytePrefix, table: 0, index: 1248, offset: 0xc33] -> [num value; dec: 120, hex: 0x78] + | | +- [ScopeBlock, table: 0, index: 1249, offset: 0xc34] + | | +- [Package, table: 0, index: 1250, offset: 0xc34] + | | | +- [BytePrefix, table: 0, index: 1251, offset: 0xc36] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1252, offset: 0xc37] + | | | +- [DwordPrefix, table: 0, index: 1253, offset: 0xc37] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [Zero, table: 0, index: 1254, offset: 0xc3c] + | | | +- [Zero, table: 0, index: 1255, offset: 0xc3d] + | | | +- [BytePrefix, table: 0, index: 1256, offset: 0xc3e] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1257, offset: 0xc40] + | | | +- [BytePrefix, table: 0, index: 1258, offset: 0xc42] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1259, offset: 0xc43] + | | | +- [DwordPrefix, table: 0, index: 1260, offset: 0xc43] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [One, table: 0, index: 1261, offset: 0xc48] + | | | +- [Zero, table: 0, index: 1262, offset: 0xc49] + | | | +- [BytePrefix, table: 0, index: 1263, offset: 0xc4a] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1264, offset: 0xc4c] + | | | +- [BytePrefix, table: 0, index: 1265, offset: 0xc4e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1266, offset: 0xc4f] + | | | +- [DwordPrefix, table: 0, index: 1267, offset: 0xc4f] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [BytePrefix, table: 0, index: 1268, offset: 0xc54] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1269, offset: 0xc56] + | | | +- [BytePrefix, table: 0, index: 1270, offset: 0xc57] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1271, offset: 0xc59] + | | | +- [BytePrefix, table: 0, index: 1272, offset: 0xc5b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1273, offset: 0xc5c] + | | | +- [DwordPrefix, table: 0, index: 1274, offset: 0xc5c] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [BytePrefix, table: 0, index: 1275, offset: 0xc61] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1276, offset: 0xc63] + | | | +- [BytePrefix, table: 0, index: 1277, offset: 0xc64] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1278, offset: 0xc66] + | | | +- [BytePrefix, table: 0, index: 1279, offset: 0xc68] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1280, offset: 0xc69] + | | | +- [DwordPrefix, table: 0, index: 1281, offset: 0xc69] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [Zero, table: 0, index: 1282, offset: 0xc6e] + | | | +- [Zero, table: 0, index: 1283, offset: 0xc6f] + | | | +- [BytePrefix, table: 0, index: 1284, offset: 0xc70] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1285, offset: 0xc72] + | | | +- [BytePrefix, table: 0, index: 1286, offset: 0xc74] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1287, offset: 0xc75] + | | | +- [DwordPrefix, table: 0, index: 1288, offset: 0xc75] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [One, table: 0, index: 1289, offset: 0xc7a] + | | | +- [Zero, table: 0, index: 1290, offset: 0xc7b] + | | | +- [BytePrefix, table: 0, index: 1291, offset: 0xc7c] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1292, offset: 0xc7e] + | | | +- [BytePrefix, table: 0, index: 1293, offset: 0xc80] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1294, offset: 0xc81] + | | | +- [DwordPrefix, table: 0, index: 1295, offset: 0xc81] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [BytePrefix, table: 0, index: 1296, offset: 0xc86] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1297, offset: 0xc88] + | | | +- [BytePrefix, table: 0, index: 1298, offset: 0xc89] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1299, offset: 0xc8b] + | | | +- [BytePrefix, table: 0, index: 1300, offset: 0xc8d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1301, offset: 0xc8e] + | | | +- [DwordPrefix, table: 0, index: 1302, offset: 0xc8e] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [BytePrefix, table: 0, index: 1303, offset: 0xc93] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1304, offset: 0xc95] + | | | +- [BytePrefix, table: 0, index: 1305, offset: 0xc96] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1306, offset: 0xc98] + | | | +- [BytePrefix, table: 0, index: 1307, offset: 0xc9a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1308, offset: 0xc9b] + | | | +- [DwordPrefix, table: 0, index: 1309, offset: 0xc9b] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [Zero, table: 0, index: 1310, offset: 0xca0] + | | | +- [Zero, table: 0, index: 1311, offset: 0xca1] + | | | +- [BytePrefix, table: 0, index: 1312, offset: 0xca2] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1313, offset: 0xca4] + | | | +- [BytePrefix, table: 0, index: 1314, offset: 0xca6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1315, offset: 0xca7] + | | | +- [DwordPrefix, table: 0, index: 1316, offset: 0xca7] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [One, table: 0, index: 1317, offset: 0xcac] + | | | +- [Zero, table: 0, index: 1318, offset: 0xcad] + | | | +- [BytePrefix, table: 0, index: 1319, offset: 0xcae] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1320, offset: 0xcb0] + | | | +- [BytePrefix, table: 0, index: 1321, offset: 0xcb2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1322, offset: 0xcb3] + | | | +- [DwordPrefix, table: 0, index: 1323, offset: 0xcb3] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [BytePrefix, table: 0, index: 1324, offset: 0xcb8] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1325, offset: 0xcba] + | | | +- [BytePrefix, table: 0, index: 1326, offset: 0xcbb] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1327, offset: 0xcbd] + | | | +- [BytePrefix, table: 0, index: 1328, offset: 0xcbf] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1329, offset: 0xcc0] + | | | +- [DwordPrefix, table: 0, index: 1330, offset: 0xcc0] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [BytePrefix, table: 0, index: 1331, offset: 0xcc5] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1332, offset: 0xcc7] + | | | +- [BytePrefix, table: 0, index: 1333, offset: 0xcc8] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1334, offset: 0xcca] + | | | +- [BytePrefix, table: 0, index: 1335, offset: 0xccc] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1336, offset: 0xccd] + | | | +- [DwordPrefix, table: 0, index: 1337, offset: 0xccd] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [Zero, table: 0, index: 1338, offset: 0xcd2] + | | | +- [Zero, table: 0, index: 1339, offset: 0xcd3] + | | | +- [BytePrefix, table: 0, index: 1340, offset: 0xcd4] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1341, offset: 0xcd6] + | | | +- [BytePrefix, table: 0, index: 1342, offset: 0xcd8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1343, offset: 0xcd9] + | | | +- [DwordPrefix, table: 0, index: 1344, offset: 0xcd9] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [One, table: 0, index: 1345, offset: 0xcde] + | | | +- [Zero, table: 0, index: 1346, offset: 0xcdf] + | | | +- [BytePrefix, table: 0, index: 1347, offset: 0xce0] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1348, offset: 0xce2] + | | | +- [BytePrefix, table: 0, index: 1349, offset: 0xce4] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1350, offset: 0xce5] + | | | +- [DwordPrefix, table: 0, index: 1351, offset: 0xce5] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [BytePrefix, table: 0, index: 1352, offset: 0xcea] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1353, offset: 0xcec] + | | | +- [BytePrefix, table: 0, index: 1354, offset: 0xced] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1355, offset: 0xcef] + | | | +- [BytePrefix, table: 0, index: 1356, offset: 0xcf1] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1357, offset: 0xcf2] + | | | +- [DwordPrefix, table: 0, index: 1358, offset: 0xcf2] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [BytePrefix, table: 0, index: 1359, offset: 0xcf7] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1360, offset: 0xcf9] + | | | +- [BytePrefix, table: 0, index: 1361, offset: 0xcfa] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1362, offset: 0xcfc] + | | | +- [BytePrefix, table: 0, index: 1363, offset: 0xcfe] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1364, offset: 0xcff] + | | | +- [DwordPrefix, table: 0, index: 1365, offset: 0xcff] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [Zero, table: 0, index: 1366, offset: 0xd04] + | | | +- [Zero, table: 0, index: 1367, offset: 0xd05] + | | | +- [BytePrefix, table: 0, index: 1368, offset: 0xd06] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1369, offset: 0xd08] + | | | +- [BytePrefix, table: 0, index: 1370, offset: 0xd0a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1371, offset: 0xd0b] + | | | +- [DwordPrefix, table: 0, index: 1372, offset: 0xd0b] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [One, table: 0, index: 1373, offset: 0xd10] + | | | +- [Zero, table: 0, index: 1374, offset: 0xd11] + | | | +- [BytePrefix, table: 0, index: 1375, offset: 0xd12] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1376, offset: 0xd14] + | | | +- [BytePrefix, table: 0, index: 1377, offset: 0xd16] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1378, offset: 0xd17] + | | | +- [DwordPrefix, table: 0, index: 1379, offset: 0xd17] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [BytePrefix, table: 0, index: 1380, offset: 0xd1c] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1381, offset: 0xd1e] + | | | +- [BytePrefix, table: 0, index: 1382, offset: 0xd1f] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1383, offset: 0xd21] + | | | +- [BytePrefix, table: 0, index: 1384, offset: 0xd23] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1385, offset: 0xd24] + | | | +- [DwordPrefix, table: 0, index: 1386, offset: 0xd24] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [BytePrefix, table: 0, index: 1387, offset: 0xd29] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1388, offset: 0xd2b] + | | | +- [BytePrefix, table: 0, index: 1389, offset: 0xd2c] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1390, offset: 0xd2e] + | | | +- [BytePrefix, table: 0, index: 1391, offset: 0xd30] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1392, offset: 0xd31] + | | | +- [DwordPrefix, table: 0, index: 1393, offset: 0xd31] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [Zero, table: 0, index: 1394, offset: 0xd36] + | | | +- [Zero, table: 0, index: 1395, offset: 0xd37] + | | | +- [BytePrefix, table: 0, index: 1396, offset: 0xd38] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1397, offset: 0xd3a] + | | | +- [BytePrefix, table: 0, index: 1398, offset: 0xd3c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1399, offset: 0xd3d] + | | | +- [DwordPrefix, table: 0, index: 1400, offset: 0xd3d] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [One, table: 0, index: 1401, offset: 0xd42] + | | | +- [Zero, table: 0, index: 1402, offset: 0xd43] + | | | +- [BytePrefix, table: 0, index: 1403, offset: 0xd44] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1404, offset: 0xd46] + | | | +- [BytePrefix, table: 0, index: 1405, offset: 0xd48] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1406, offset: 0xd49] + | | | +- [DwordPrefix, table: 0, index: 1407, offset: 0xd49] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [BytePrefix, table: 0, index: 1408, offset: 0xd4e] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1409, offset: 0xd50] + | | | +- [BytePrefix, table: 0, index: 1410, offset: 0xd51] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1411, offset: 0xd53] + | | | +- [BytePrefix, table: 0, index: 1412, offset: 0xd55] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1413, offset: 0xd56] + | | | +- [DwordPrefix, table: 0, index: 1414, offset: 0xd56] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [BytePrefix, table: 0, index: 1415, offset: 0xd5b] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1416, offset: 0xd5d] + | | | +- [BytePrefix, table: 0, index: 1417, offset: 0xd5e] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1418, offset: 0xd60] + | | | +- [BytePrefix, table: 0, index: 1419, offset: 0xd62] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1420, offset: 0xd63] + | | | +- [DwordPrefix, table: 0, index: 1421, offset: 0xd63] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [Zero, table: 0, index: 1422, offset: 0xd68] + | | | +- [Zero, table: 0, index: 1423, offset: 0xd69] + | | | +- [BytePrefix, table: 0, index: 1424, offset: 0xd6a] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1425, offset: 0xd6c] + | | | +- [BytePrefix, table: 0, index: 1426, offset: 0xd6e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1427, offset: 0xd6f] + | | | +- [DwordPrefix, table: 0, index: 1428, offset: 0xd6f] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [One, table: 0, index: 1429, offset: 0xd74] + | | | +- [Zero, table: 0, index: 1430, offset: 0xd75] + | | | +- [BytePrefix, table: 0, index: 1431, offset: 0xd76] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1432, offset: 0xd78] + | | | +- [BytePrefix, table: 0, index: 1433, offset: 0xd7a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1434, offset: 0xd7b] + | | | +- [DwordPrefix, table: 0, index: 1435, offset: 0xd7b] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [BytePrefix, table: 0, index: 1436, offset: 0xd80] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1437, offset: 0xd82] + | | | +- [BytePrefix, table: 0, index: 1438, offset: 0xd83] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1439, offset: 0xd85] + | | | +- [BytePrefix, table: 0, index: 1440, offset: 0xd87] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1441, offset: 0xd88] + | | | +- [DwordPrefix, table: 0, index: 1442, offset: 0xd88] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [BytePrefix, table: 0, index: 1443, offset: 0xd8d] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1444, offset: 0xd8f] + | | | +- [BytePrefix, table: 0, index: 1445, offset: 0xd90] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1446, offset: 0xd92] + | | | +- [BytePrefix, table: 0, index: 1447, offset: 0xd94] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1448, offset: 0xd95] + | | | +- [DwordPrefix, table: 0, index: 1449, offset: 0xd95] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [Zero, table: 0, index: 1450, offset: 0xd9a] + | | | +- [Zero, table: 0, index: 1451, offset: 0xd9b] + | | | +- [BytePrefix, table: 0, index: 1452, offset: 0xd9c] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1453, offset: 0xd9e] + | | | +- [BytePrefix, table: 0, index: 1454, offset: 0xda0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1455, offset: 0xda1] + | | | +- [DwordPrefix, table: 0, index: 1456, offset: 0xda1] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [One, table: 0, index: 1457, offset: 0xda6] + | | | +- [Zero, table: 0, index: 1458, offset: 0xda7] + | | | +- [BytePrefix, table: 0, index: 1459, offset: 0xda8] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1460, offset: 0xdaa] + | | | +- [BytePrefix, table: 0, index: 1461, offset: 0xdac] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1462, offset: 0xdad] + | | | +- [DwordPrefix, table: 0, index: 1463, offset: 0xdad] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [BytePrefix, table: 0, index: 1464, offset: 0xdb2] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1465, offset: 0xdb4] + | | | +- [BytePrefix, table: 0, index: 1466, offset: 0xdb5] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1467, offset: 0xdb7] + | | | +- [BytePrefix, table: 0, index: 1468, offset: 0xdb9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1469, offset: 0xdba] + | | | +- [DwordPrefix, table: 0, index: 1470, offset: 0xdba] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [BytePrefix, table: 0, index: 1471, offset: 0xdbf] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1472, offset: 0xdc1] + | | | +- [BytePrefix, table: 0, index: 1473, offset: 0xdc2] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1474, offset: 0xdc4] + | | | +- [BytePrefix, table: 0, index: 1475, offset: 0xdc6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1476, offset: 0xdc7] + | | | +- [DwordPrefix, table: 0, index: 1477, offset: 0xdc7] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [Zero, table: 0, index: 1478, offset: 0xdcc] + | | | +- [Zero, table: 0, index: 1479, offset: 0xdcd] + | | | +- [BytePrefix, table: 0, index: 1480, offset: 0xdce] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1481, offset: 0xdd0] + | | | +- [BytePrefix, table: 0, index: 1482, offset: 0xdd2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1483, offset: 0xdd3] + | | | +- [DwordPrefix, table: 0, index: 1484, offset: 0xdd3] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [One, table: 0, index: 1485, offset: 0xdd8] + | | | +- [Zero, table: 0, index: 1486, offset: 0xdd9] + | | | +- [BytePrefix, table: 0, index: 1487, offset: 0xdda] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1488, offset: 0xddc] + | | | +- [BytePrefix, table: 0, index: 1489, offset: 0xdde] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1490, offset: 0xddf] + | | | +- [DwordPrefix, table: 0, index: 1491, offset: 0xddf] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [BytePrefix, table: 0, index: 1492, offset: 0xde4] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1493, offset: 0xde6] + | | | +- [BytePrefix, table: 0, index: 1494, offset: 0xde7] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1495, offset: 0xde9] + | | | +- [BytePrefix, table: 0, index: 1496, offset: 0xdeb] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1497, offset: 0xdec] + | | | +- [DwordPrefix, table: 0, index: 1498, offset: 0xdec] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [BytePrefix, table: 0, index: 1499, offset: 0xdf1] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1500, offset: 0xdf3] + | | | +- [BytePrefix, table: 0, index: 1501, offset: 0xdf4] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1502, offset: 0xdf6] + | | | +- [BytePrefix, table: 0, index: 1503, offset: 0xdf8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1504, offset: 0xdf9] + | | | +- [DwordPrefix, table: 0, index: 1505, offset: 0xdf9] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [Zero, table: 0, index: 1506, offset: 0xdfe] + | | | +- [Zero, table: 0, index: 1507, offset: 0xdff] + | | | +- [BytePrefix, table: 0, index: 1508, offset: 0xe00] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1509, offset: 0xe02] + | | | +- [BytePrefix, table: 0, index: 1510, offset: 0xe04] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1511, offset: 0xe05] + | | | +- [DwordPrefix, table: 0, index: 1512, offset: 0xe05] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [One, table: 0, index: 1513, offset: 0xe0a] + | | | +- [Zero, table: 0, index: 1514, offset: 0xe0b] + | | | +- [BytePrefix, table: 0, index: 1515, offset: 0xe0c] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1516, offset: 0xe0e] + | | | +- [BytePrefix, table: 0, index: 1517, offset: 0xe10] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1518, offset: 0xe11] + | | | +- [DwordPrefix, table: 0, index: 1519, offset: 0xe11] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [BytePrefix, table: 0, index: 1520, offset: 0xe16] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1521, offset: 0xe18] + | | | +- [BytePrefix, table: 0, index: 1522, offset: 0xe19] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1523, offset: 0xe1b] + | | | +- [BytePrefix, table: 0, index: 1524, offset: 0xe1d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1525, offset: 0xe1e] + | | | +- [DwordPrefix, table: 0, index: 1526, offset: 0xe1e] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [BytePrefix, table: 0, index: 1527, offset: 0xe23] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1528, offset: 0xe25] + | | | +- [BytePrefix, table: 0, index: 1529, offset: 0xe26] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1530, offset: 0xe28] + | | | +- [BytePrefix, table: 0, index: 1531, offset: 0xe2a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1532, offset: 0xe2b] + | | | +- [DwordPrefix, table: 0, index: 1533, offset: 0xe2b] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [Zero, table: 0, index: 1534, offset: 0xe30] + | | | +- [Zero, table: 0, index: 1535, offset: 0xe31] + | | | +- [BytePrefix, table: 0, index: 1536, offset: 0xe32] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1537, offset: 0xe34] + | | | +- [BytePrefix, table: 0, index: 1538, offset: 0xe36] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1539, offset: 0xe37] + | | | +- [DwordPrefix, table: 0, index: 1540, offset: 0xe37] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [One, table: 0, index: 1541, offset: 0xe3c] + | | | +- [Zero, table: 0, index: 1542, offset: 0xe3d] + | | | +- [BytePrefix, table: 0, index: 1543, offset: 0xe3e] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1544, offset: 0xe40] + | | | +- [BytePrefix, table: 0, index: 1545, offset: 0xe42] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1546, offset: 0xe43] + | | | +- [DwordPrefix, table: 0, index: 1547, offset: 0xe43] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [BytePrefix, table: 0, index: 1548, offset: 0xe48] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1549, offset: 0xe4a] + | | | +- [BytePrefix, table: 0, index: 1550, offset: 0xe4b] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1551, offset: 0xe4d] + | | | +- [BytePrefix, table: 0, index: 1552, offset: 0xe4f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1553, offset: 0xe50] + | | | +- [DwordPrefix, table: 0, index: 1554, offset: 0xe50] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [BytePrefix, table: 0, index: 1555, offset: 0xe55] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1556, offset: 0xe57] + | | | +- [BytePrefix, table: 0, index: 1557, offset: 0xe58] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1558, offset: 0xe5a] + | | | +- [BytePrefix, table: 0, index: 1559, offset: 0xe5c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1560, offset: 0xe5d] + | | | +- [DwordPrefix, table: 0, index: 1561, offset: 0xe5d] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [Zero, table: 0, index: 1562, offset: 0xe62] + | | | +- [Zero, table: 0, index: 1563, offset: 0xe63] + | | | +- [BytePrefix, table: 0, index: 1564, offset: 0xe64] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1565, offset: 0xe66] + | | | +- [BytePrefix, table: 0, index: 1566, offset: 0xe68] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1567, offset: 0xe69] + | | | +- [DwordPrefix, table: 0, index: 1568, offset: 0xe69] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [One, table: 0, index: 1569, offset: 0xe6e] + | | | +- [Zero, table: 0, index: 1570, offset: 0xe6f] + | | | +- [BytePrefix, table: 0, index: 1571, offset: 0xe70] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1572, offset: 0xe72] + | | | +- [BytePrefix, table: 0, index: 1573, offset: 0xe74] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1574, offset: 0xe75] + | | | +- [DwordPrefix, table: 0, index: 1575, offset: 0xe75] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [BytePrefix, table: 0, index: 1576, offset: 0xe7a] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1577, offset: 0xe7c] + | | | +- [BytePrefix, table: 0, index: 1578, offset: 0xe7d] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1579, offset: 0xe7f] + | | | +- [BytePrefix, table: 0, index: 1580, offset: 0xe81] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1581, offset: 0xe82] + | | | +- [DwordPrefix, table: 0, index: 1582, offset: 0xe82] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [BytePrefix, table: 0, index: 1583, offset: 0xe87] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1584, offset: 0xe89] + | | | +- [BytePrefix, table: 0, index: 1585, offset: 0xe8a] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1586, offset: 0xe8c] + | | | +- [BytePrefix, table: 0, index: 1587, offset: 0xe8e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1588, offset: 0xe8f] + | | | +- [DwordPrefix, table: 0, index: 1589, offset: 0xe8f] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [Zero, table: 0, index: 1590, offset: 0xe94] + | | | +- [Zero, table: 0, index: 1591, offset: 0xe95] + | | | +- [BytePrefix, table: 0, index: 1592, offset: 0xe96] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1593, offset: 0xe98] + | | | +- [BytePrefix, table: 0, index: 1594, offset: 0xe9a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1595, offset: 0xe9b] + | | | +- [DwordPrefix, table: 0, index: 1596, offset: 0xe9b] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [One, table: 0, index: 1597, offset: 0xea0] + | | | +- [Zero, table: 0, index: 1598, offset: 0xea1] + | | | +- [BytePrefix, table: 0, index: 1599, offset: 0xea2] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1600, offset: 0xea4] + | | | +- [BytePrefix, table: 0, index: 1601, offset: 0xea6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1602, offset: 0xea7] + | | | +- [DwordPrefix, table: 0, index: 1603, offset: 0xea7] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [BytePrefix, table: 0, index: 1604, offset: 0xeac] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1605, offset: 0xeae] + | | | +- [BytePrefix, table: 0, index: 1606, offset: 0xeaf] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1607, offset: 0xeb1] + | | | +- [BytePrefix, table: 0, index: 1608, offset: 0xeb3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1609, offset: 0xeb4] + | | | +- [DwordPrefix, table: 0, index: 1610, offset: 0xeb4] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [BytePrefix, table: 0, index: 1611, offset: 0xeb9] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1612, offset: 0xebb] + | | | +- [BytePrefix, table: 0, index: 1613, offset: 0xebc] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1614, offset: 0xebe] + | | | +- [BytePrefix, table: 0, index: 1615, offset: 0xec0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1616, offset: 0xec1] + | | | +- [DwordPrefix, table: 0, index: 1617, offset: 0xec1] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [Zero, table: 0, index: 1618, offset: 0xec6] + | | | +- [Zero, table: 0, index: 1619, offset: 0xec7] + | | | +- [BytePrefix, table: 0, index: 1620, offset: 0xec8] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1621, offset: 0xeca] + | | | +- [BytePrefix, table: 0, index: 1622, offset: 0xecc] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1623, offset: 0xecd] + | | | +- [DwordPrefix, table: 0, index: 1624, offset: 0xecd] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [One, table: 0, index: 1625, offset: 0xed2] + | | | +- [Zero, table: 0, index: 1626, offset: 0xed3] + | | | +- [BytePrefix, table: 0, index: 1627, offset: 0xed4] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1628, offset: 0xed6] + | | | +- [BytePrefix, table: 0, index: 1629, offset: 0xed8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1630, offset: 0xed9] + | | | +- [DwordPrefix, table: 0, index: 1631, offset: 0xed9] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [BytePrefix, table: 0, index: 1632, offset: 0xede] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1633, offset: 0xee0] + | | | +- [BytePrefix, table: 0, index: 1634, offset: 0xee1] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1635, offset: 0xee3] + | | | +- [BytePrefix, table: 0, index: 1636, offset: 0xee5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1637, offset: 0xee6] + | | | +- [DwordPrefix, table: 0, index: 1638, offset: 0xee6] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [BytePrefix, table: 0, index: 1639, offset: 0xeeb] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1640, offset: 0xeed] + | | | +- [BytePrefix, table: 0, index: 1641, offset: 0xeee] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1642, offset: 0xef0] + | | | +- [BytePrefix, table: 0, index: 1643, offset: 0xef2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1644, offset: 0xef3] + | | | +- [DwordPrefix, table: 0, index: 1645, offset: 0xef3] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [Zero, table: 0, index: 1646, offset: 0xef8] + | | | +- [Zero, table: 0, index: 1647, offset: 0xef9] + | | | +- [BytePrefix, table: 0, index: 1648, offset: 0xefa] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1649, offset: 0xefc] + | | | +- [BytePrefix, table: 0, index: 1650, offset: 0xefe] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1651, offset: 0xeff] + | | | +- [DwordPrefix, table: 0, index: 1652, offset: 0xeff] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [One, table: 0, index: 1653, offset: 0xf04] + | | | +- [Zero, table: 0, index: 1654, offset: 0xf05] + | | | +- [BytePrefix, table: 0, index: 1655, offset: 0xf06] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1656, offset: 0xf08] + | | | +- [BytePrefix, table: 0, index: 1657, offset: 0xf0a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1658, offset: 0xf0b] + | | | +- [DwordPrefix, table: 0, index: 1659, offset: 0xf0b] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [BytePrefix, table: 0, index: 1660, offset: 0xf10] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1661, offset: 0xf12] + | | | +- [BytePrefix, table: 0, index: 1662, offset: 0xf13] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1663, offset: 0xf15] + | | | +- [BytePrefix, table: 0, index: 1664, offset: 0xf17] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1665, offset: 0xf18] + | | | +- [DwordPrefix, table: 0, index: 1666, offset: 0xf18] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [BytePrefix, table: 0, index: 1667, offset: 0xf1d] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1668, offset: 0xf1f] + | | | +- [BytePrefix, table: 0, index: 1669, offset: 0xf20] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1670, offset: 0xf22] + | | | +- [BytePrefix, table: 0, index: 1671, offset: 0xf24] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1672, offset: 0xf25] + | | | +- [DwordPrefix, table: 0, index: 1673, offset: 0xf25] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [Zero, table: 0, index: 1674, offset: 0xf2a] + | | | +- [Zero, table: 0, index: 1675, offset: 0xf2b] + | | | +- [BytePrefix, table: 0, index: 1676, offset: 0xf2c] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1677, offset: 0xf2e] + | | | +- [BytePrefix, table: 0, index: 1678, offset: 0xf30] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1679, offset: 0xf31] + | | | +- [DwordPrefix, table: 0, index: 1680, offset: 0xf31] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [One, table: 0, index: 1681, offset: 0xf36] + | | | +- [Zero, table: 0, index: 1682, offset: 0xf37] + | | | +- [BytePrefix, table: 0, index: 1683, offset: 0xf38] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1684, offset: 0xf3a] + | | | +- [BytePrefix, table: 0, index: 1685, offset: 0xf3c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1686, offset: 0xf3d] + | | | +- [DwordPrefix, table: 0, index: 1687, offset: 0xf3d] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [BytePrefix, table: 0, index: 1688, offset: 0xf42] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1689, offset: 0xf44] + | | | +- [BytePrefix, table: 0, index: 1690, offset: 0xf45] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1691, offset: 0xf47] + | | | +- [BytePrefix, table: 0, index: 1692, offset: 0xf49] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1693, offset: 0xf4a] + | | | +- [DwordPrefix, table: 0, index: 1694, offset: 0xf4a] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [BytePrefix, table: 0, index: 1695, offset: 0xf4f] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1696, offset: 0xf51] + | | | +- [BytePrefix, table: 0, index: 1697, offset: 0xf52] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1698, offset: 0xf54] + | | | +- [BytePrefix, table: 0, index: 1699, offset: 0xf56] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1700, offset: 0xf57] + | | | +- [DwordPrefix, table: 0, index: 1701, offset: 0xf57] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [Zero, table: 0, index: 1702, offset: 0xf5c] + | | | +- [Zero, table: 0, index: 1703, offset: 0xf5d] + | | | +- [BytePrefix, table: 0, index: 1704, offset: 0xf5e] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1705, offset: 0xf60] + | | | +- [BytePrefix, table: 0, index: 1706, offset: 0xf62] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1707, offset: 0xf63] + | | | +- [DwordPrefix, table: 0, index: 1708, offset: 0xf63] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [One, table: 0, index: 1709, offset: 0xf68] + | | | +- [Zero, table: 0, index: 1710, offset: 0xf69] + | | | +- [BytePrefix, table: 0, index: 1711, offset: 0xf6a] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1712, offset: 0xf6c] + | | | +- [BytePrefix, table: 0, index: 1713, offset: 0xf6e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1714, offset: 0xf6f] + | | | +- [DwordPrefix, table: 0, index: 1715, offset: 0xf6f] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [BytePrefix, table: 0, index: 1716, offset: 0xf74] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1717, offset: 0xf76] + | | | +- [BytePrefix, table: 0, index: 1718, offset: 0xf77] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1719, offset: 0xf79] + | | | +- [BytePrefix, table: 0, index: 1720, offset: 0xf7b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1721, offset: 0xf7c] + | | | +- [DwordPrefix, table: 0, index: 1722, offset: 0xf7c] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [BytePrefix, table: 0, index: 1723, offset: 0xf81] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1724, offset: 0xf83] + | | | +- [BytePrefix, table: 0, index: 1725, offset: 0xf84] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1726, offset: 0xf86] + | | | +- [BytePrefix, table: 0, index: 1727, offset: 0xf88] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1728, offset: 0xf89] + | | | +- [DwordPrefix, table: 0, index: 1729, offset: 0xf89] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [Zero, table: 0, index: 1730, offset: 0xf8e] + | | | +- [Zero, table: 0, index: 1731, offset: 0xf8f] + | | | +- [BytePrefix, table: 0, index: 1732, offset: 0xf90] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1733, offset: 0xf92] + | | | +- [BytePrefix, table: 0, index: 1734, offset: 0xf94] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1735, offset: 0xf95] + | | | +- [DwordPrefix, table: 0, index: 1736, offset: 0xf95] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [One, table: 0, index: 1737, offset: 0xf9a] + | | | +- [Zero, table: 0, index: 1738, offset: 0xf9b] + | | | +- [BytePrefix, table: 0, index: 1739, offset: 0xf9c] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1740, offset: 0xf9e] + | | | +- [BytePrefix, table: 0, index: 1741, offset: 0xfa0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1742, offset: 0xfa1] + | | | +- [DwordPrefix, table: 0, index: 1743, offset: 0xfa1] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [BytePrefix, table: 0, index: 1744, offset: 0xfa6] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1745, offset: 0xfa8] + | | | +- [BytePrefix, table: 0, index: 1746, offset: 0xfa9] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1747, offset: 0xfab] + | | | +- [BytePrefix, table: 0, index: 1748, offset: 0xfad] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1749, offset: 0xfae] + | | | +- [DwordPrefix, table: 0, index: 1750, offset: 0xfae] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [BytePrefix, table: 0, index: 1751, offset: 0xfb3] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1752, offset: 0xfb5] + | | | +- [BytePrefix, table: 0, index: 1753, offset: 0xfb6] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1754, offset: 0xfb8] + | | | +- [BytePrefix, table: 0, index: 1755, offset: 0xfba] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1756, offset: 0xfbb] + | | | +- [DwordPrefix, table: 0, index: 1757, offset: 0xfbb] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [Zero, table: 0, index: 1758, offset: 0xfc0] + | | | +- [Zero, table: 0, index: 1759, offset: 0xfc1] + | | | +- [BytePrefix, table: 0, index: 1760, offset: 0xfc2] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1761, offset: 0xfc4] + | | | +- [BytePrefix, table: 0, index: 1762, offset: 0xfc6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1763, offset: 0xfc7] + | | | +- [DwordPrefix, table: 0, index: 1764, offset: 0xfc7] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [One, table: 0, index: 1765, offset: 0xfcc] + | | | +- [Zero, table: 0, index: 1766, offset: 0xfcd] + | | | +- [BytePrefix, table: 0, index: 1767, offset: 0xfce] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1768, offset: 0xfd0] + | | | +- [BytePrefix, table: 0, index: 1769, offset: 0xfd2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1770, offset: 0xfd3] + | | | +- [DwordPrefix, table: 0, index: 1771, offset: 0xfd3] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [BytePrefix, table: 0, index: 1772, offset: 0xfd8] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1773, offset: 0xfda] + | | | +- [BytePrefix, table: 0, index: 1774, offset: 0xfdb] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1775, offset: 0xfdd] + | | | +- [BytePrefix, table: 0, index: 1776, offset: 0xfdf] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1777, offset: 0xfe0] + | | | +- [DwordPrefix, table: 0, index: 1778, offset: 0xfe0] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [BytePrefix, table: 0, index: 1779, offset: 0xfe5] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1780, offset: 0xfe7] + | | | +- [BytePrefix, table: 0, index: 1781, offset: 0xfe8] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1782, offset: 0xfea] + | | | +- [BytePrefix, table: 0, index: 1783, offset: 0xfec] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1784, offset: 0xfed] + | | | +- [DwordPrefix, table: 0, index: 1785, offset: 0xfed] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [Zero, table: 0, index: 1786, offset: 0xff2] + | | | +- [Zero, table: 0, index: 1787, offset: 0xff3] + | | | +- [BytePrefix, table: 0, index: 1788, offset: 0xff4] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1789, offset: 0xff6] + | | | +- [BytePrefix, table: 0, index: 1790, offset: 0xff8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1791, offset: 0xff9] + | | | +- [DwordPrefix, table: 0, index: 1792, offset: 0xff9] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [One, table: 0, index: 1793, offset: 0xffe] + | | | +- [Zero, table: 0, index: 1794, offset: 0xfff] + | | | +- [BytePrefix, table: 0, index: 1795, offset: 0x1000] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1796, offset: 0x1002] + | | | +- [BytePrefix, table: 0, index: 1797, offset: 0x1004] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1798, offset: 0x1005] + | | | +- [DwordPrefix, table: 0, index: 1799, offset: 0x1005] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [BytePrefix, table: 0, index: 1800, offset: 0x100a] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1801, offset: 0x100c] + | | | +- [BytePrefix, table: 0, index: 1802, offset: 0x100d] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1803, offset: 0x100f] + | | | +- [BytePrefix, table: 0, index: 1804, offset: 0x1011] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1805, offset: 0x1012] + | | | +- [DwordPrefix, table: 0, index: 1806, offset: 0x1012] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [BytePrefix, table: 0, index: 1807, offset: 0x1017] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1808, offset: 0x1019] + | | | +- [BytePrefix, table: 0, index: 1809, offset: 0x101a] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1810, offset: 0x101c] + | | | +- [BytePrefix, table: 0, index: 1811, offset: 0x101e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1812, offset: 0x101f] + | | | +- [DwordPrefix, table: 0, index: 1813, offset: 0x101f] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [Zero, table: 0, index: 1814, offset: 0x1024] + | | | +- [Zero, table: 0, index: 1815, offset: 0x1025] + | | | +- [BytePrefix, table: 0, index: 1816, offset: 0x1026] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1817, offset: 0x1028] + | | | +- [BytePrefix, table: 0, index: 1818, offset: 0x102a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1819, offset: 0x102b] + | | | +- [DwordPrefix, table: 0, index: 1820, offset: 0x102b] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [One, table: 0, index: 1821, offset: 0x1030] + | | | +- [Zero, table: 0, index: 1822, offset: 0x1031] + | | | +- [BytePrefix, table: 0, index: 1823, offset: 0x1032] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1824, offset: 0x1034] + | | | +- [BytePrefix, table: 0, index: 1825, offset: 0x1036] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1826, offset: 0x1037] + | | | +- [DwordPrefix, table: 0, index: 1827, offset: 0x1037] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [BytePrefix, table: 0, index: 1828, offset: 0x103c] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1829, offset: 0x103e] + | | | +- [BytePrefix, table: 0, index: 1830, offset: 0x103f] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1831, offset: 0x1041] + | | | +- [BytePrefix, table: 0, index: 1832, offset: 0x1043] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1833, offset: 0x1044] + | | | +- [DwordPrefix, table: 0, index: 1834, offset: 0x1044] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [BytePrefix, table: 0, index: 1835, offset: 0x1049] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1836, offset: 0x104b] + | | | +- [BytePrefix, table: 0, index: 1837, offset: 0x104c] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1838, offset: 0x104e] + | | | +- [BytePrefix, table: 0, index: 1839, offset: 0x1050] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1840, offset: 0x1051] + | | | +- [DwordPrefix, table: 0, index: 1841, offset: 0x1051] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [Zero, table: 0, index: 1842, offset: 0x1056] + | | | +- [Zero, table: 0, index: 1843, offset: 0x1057] + | | | +- [BytePrefix, table: 0, index: 1844, offset: 0x1058] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1845, offset: 0x105a] + | | | +- [BytePrefix, table: 0, index: 1846, offset: 0x105c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1847, offset: 0x105d] + | | | +- [DwordPrefix, table: 0, index: 1848, offset: 0x105d] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [One, table: 0, index: 1849, offset: 0x1062] + | | | +- [Zero, table: 0, index: 1850, offset: 0x1063] + | | | +- [BytePrefix, table: 0, index: 1851, offset: 0x1064] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1852, offset: 0x1066] + | | | +- [BytePrefix, table: 0, index: 1853, offset: 0x1068] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1854, offset: 0x1069] + | | | +- [DwordPrefix, table: 0, index: 1855, offset: 0x1069] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [BytePrefix, table: 0, index: 1856, offset: 0x106e] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1857, offset: 0x1070] + | | | +- [BytePrefix, table: 0, index: 1858, offset: 0x1071] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1859, offset: 0x1073] + | | | +- [BytePrefix, table: 0, index: 1860, offset: 0x1075] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1861, offset: 0x1076] + | | | +- [DwordPrefix, table: 0, index: 1862, offset: 0x1076] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [BytePrefix, table: 0, index: 1863, offset: 0x107b] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1864, offset: 0x107d] + | | | +- [BytePrefix, table: 0, index: 1865, offset: 0x107e] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1866, offset: 0x1080] + | | | +- [BytePrefix, table: 0, index: 1867, offset: 0x1082] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1868, offset: 0x1083] + | | | +- [DwordPrefix, table: 0, index: 1869, offset: 0x1083] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [Zero, table: 0, index: 1870, offset: 0x1088] + | | | +- [Zero, table: 0, index: 1871, offset: 0x1089] + | | | +- [BytePrefix, table: 0, index: 1872, offset: 0x108a] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1873, offset: 0x108c] + | | | +- [BytePrefix, table: 0, index: 1874, offset: 0x108e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1875, offset: 0x108f] + | | | +- [DwordPrefix, table: 0, index: 1876, offset: 0x108f] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [One, table: 0, index: 1877, offset: 0x1094] + | | | +- [Zero, table: 0, index: 1878, offset: 0x1095] + | | | +- [BytePrefix, table: 0, index: 1879, offset: 0x1096] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1880, offset: 0x1098] + | | | +- [BytePrefix, table: 0, index: 1881, offset: 0x109a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1882, offset: 0x109b] + | | | +- [DwordPrefix, table: 0, index: 1883, offset: 0x109b] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [BytePrefix, table: 0, index: 1884, offset: 0x10a0] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1885, offset: 0x10a2] + | | | +- [BytePrefix, table: 0, index: 1886, offset: 0x10a3] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1887, offset: 0x10a5] + | | | +- [BytePrefix, table: 0, index: 1888, offset: 0x10a7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1889, offset: 0x10a8] + | | | +- [DwordPrefix, table: 0, index: 1890, offset: 0x10a8] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [BytePrefix, table: 0, index: 1891, offset: 0x10ad] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1892, offset: 0x10af] + | | | +- [BytePrefix, table: 0, index: 1893, offset: 0x10b0] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1894, offset: 0x10b2] + | | | +- [BytePrefix, table: 0, index: 1895, offset: 0x10b4] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1896, offset: 0x10b5] + | | | +- [DwordPrefix, table: 0, index: 1897, offset: 0x10b5] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [Zero, table: 0, index: 1898, offset: 0x10ba] + | | | +- [Zero, table: 0, index: 1899, offset: 0x10bb] + | | | +- [BytePrefix, table: 0, index: 1900, offset: 0x10bc] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1901, offset: 0x10be] + | | | +- [BytePrefix, table: 0, index: 1902, offset: 0x10c0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1903, offset: 0x10c1] + | | | +- [DwordPrefix, table: 0, index: 1904, offset: 0x10c1] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [One, table: 0, index: 1905, offset: 0x10c6] + | | | +- [Zero, table: 0, index: 1906, offset: 0x10c7] + | | | +- [BytePrefix, table: 0, index: 1907, offset: 0x10c8] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1908, offset: 0x10ca] + | | | +- [BytePrefix, table: 0, index: 1909, offset: 0x10cc] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1910, offset: 0x10cd] + | | | +- [DwordPrefix, table: 0, index: 1911, offset: 0x10cd] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [BytePrefix, table: 0, index: 1912, offset: 0x10d2] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1913, offset: 0x10d4] + | | | +- [BytePrefix, table: 0, index: 1914, offset: 0x10d5] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1915, offset: 0x10d7] + | | | +- [BytePrefix, table: 0, index: 1916, offset: 0x10d9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1917, offset: 0x10da] + | | | +- [DwordPrefix, table: 0, index: 1918, offset: 0x10da] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [BytePrefix, table: 0, index: 1919, offset: 0x10df] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1920, offset: 0x10e1] + | | | +- [BytePrefix, table: 0, index: 1921, offset: 0x10e2] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1922, offset: 0x10e4] + | | | +- [BytePrefix, table: 0, index: 1923, offset: 0x10e6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1924, offset: 0x10e7] + | | | +- [DwordPrefix, table: 0, index: 1925, offset: 0x10e7] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [Zero, table: 0, index: 1926, offset: 0x10ec] + | | | +- [Zero, table: 0, index: 1927, offset: 0x10ed] + | | | +- [BytePrefix, table: 0, index: 1928, offset: 0x10ee] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1929, offset: 0x10f0] + | | | +- [BytePrefix, table: 0, index: 1930, offset: 0x10f2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1931, offset: 0x10f3] + | | | +- [DwordPrefix, table: 0, index: 1932, offset: 0x10f3] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [One, table: 0, index: 1933, offset: 0x10f8] + | | | +- [Zero, table: 0, index: 1934, offset: 0x10f9] + | | | +- [BytePrefix, table: 0, index: 1935, offset: 0x10fa] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1936, offset: 0x10fc] + | | | +- [BytePrefix, table: 0, index: 1937, offset: 0x10fe] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1938, offset: 0x10ff] + | | | +- [DwordPrefix, table: 0, index: 1939, offset: 0x10ff] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [BytePrefix, table: 0, index: 1940, offset: 0x1104] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1941, offset: 0x1106] + | | | +- [BytePrefix, table: 0, index: 1942, offset: 0x1107] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1943, offset: 0x1109] + | | | +- [BytePrefix, table: 0, index: 1944, offset: 0x110b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1945, offset: 0x110c] + | | | +- [DwordPrefix, table: 0, index: 1946, offset: 0x110c] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [BytePrefix, table: 0, index: 1947, offset: 0x1111] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1948, offset: 0x1113] + | | | +- [BytePrefix, table: 0, index: 1949, offset: 0x1114] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1950, offset: 0x1116] + | | | +- [BytePrefix, table: 0, index: 1951, offset: 0x1118] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1952, offset: 0x1119] + | | | +- [DwordPrefix, table: 0, index: 1953, offset: 0x1119] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [Zero, table: 0, index: 1954, offset: 0x111e] + | | | +- [Zero, table: 0, index: 1955, offset: 0x111f] + | | | +- [BytePrefix, table: 0, index: 1956, offset: 0x1120] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1957, offset: 0x1122] + | | | +- [BytePrefix, table: 0, index: 1958, offset: 0x1124] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1959, offset: 0x1125] + | | | +- [DwordPrefix, table: 0, index: 1960, offset: 0x1125] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [One, table: 0, index: 1961, offset: 0x112a] + | | | +- [Zero, table: 0, index: 1962, offset: 0x112b] + | | | +- [BytePrefix, table: 0, index: 1963, offset: 0x112c] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1964, offset: 0x112e] + | | | +- [BytePrefix, table: 0, index: 1965, offset: 0x1130] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1966, offset: 0x1131] + | | | +- [DwordPrefix, table: 0, index: 1967, offset: 0x1131] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [BytePrefix, table: 0, index: 1968, offset: 0x1136] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1969, offset: 0x1138] + | | | +- [BytePrefix, table: 0, index: 1970, offset: 0x1139] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1971, offset: 0x113b] + | | | +- [BytePrefix, table: 0, index: 1972, offset: 0x113d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1973, offset: 0x113e] + | | | +- [DwordPrefix, table: 0, index: 1974, offset: 0x113e] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [BytePrefix, table: 0, index: 1975, offset: 0x1143] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1976, offset: 0x1145] + | | | +- [BytePrefix, table: 0, index: 1977, offset: 0x1146] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1978, offset: 0x1148] + | | | +- [BytePrefix, table: 0, index: 1979, offset: 0x114a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1980, offset: 0x114b] + | | | +- [DwordPrefix, table: 0, index: 1981, offset: 0x114b] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [Zero, table: 0, index: 1982, offset: 0x1150] + | | | +- [Zero, table: 0, index: 1983, offset: 0x1151] + | | | +- [BytePrefix, table: 0, index: 1984, offset: 0x1152] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1985, offset: 0x1154] + | | | +- [BytePrefix, table: 0, index: 1986, offset: 0x1156] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1987, offset: 0x1157] + | | | +- [DwordPrefix, table: 0, index: 1988, offset: 0x1157] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [One, table: 0, index: 1989, offset: 0x115c] + | | | +- [Zero, table: 0, index: 1990, offset: 0x115d] + | | | +- [BytePrefix, table: 0, index: 1991, offset: 0x115e] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1992, offset: 0x1160] + | | | +- [BytePrefix, table: 0, index: 1993, offset: 0x1162] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1994, offset: 0x1163] + | | | +- [DwordPrefix, table: 0, index: 1995, offset: 0x1163] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [BytePrefix, table: 0, index: 1996, offset: 0x1168] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1997, offset: 0x116a] + | | | +- [BytePrefix, table: 0, index: 1998, offset: 0x116b] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1999, offset: 0x116d] + | | | +- [BytePrefix, table: 0, index: 2000, offset: 0x116f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2001, offset: 0x1170] + | | | +- [DwordPrefix, table: 0, index: 2002, offset: 0x1170] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [BytePrefix, table: 0, index: 2003, offset: 0x1175] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 2004, offset: 0x1177] + | | | +- [BytePrefix, table: 0, index: 2005, offset: 0x1178] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 2006, offset: 0x117a] + | | | +- [BytePrefix, table: 0, index: 2007, offset: 0x117c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2008, offset: 0x117d] + | | | +- [DwordPrefix, table: 0, index: 2009, offset: 0x117d] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [Zero, table: 0, index: 2010, offset: 0x1182] + | | | +- [Zero, table: 0, index: 2011, offset: 0x1183] + | | | +- [BytePrefix, table: 0, index: 2012, offset: 0x1184] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 2013, offset: 0x1186] + | | | +- [BytePrefix, table: 0, index: 2014, offset: 0x1188] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2015, offset: 0x1189] + | | | +- [DwordPrefix, table: 0, index: 2016, offset: 0x1189] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [One, table: 0, index: 2017, offset: 0x118e] + | | | +- [Zero, table: 0, index: 2018, offset: 0x118f] + | | | +- [BytePrefix, table: 0, index: 2019, offset: 0x1190] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 2020, offset: 0x1192] + | | | +- [BytePrefix, table: 0, index: 2021, offset: 0x1194] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2022, offset: 0x1195] + | | | +- [DwordPrefix, table: 0, index: 2023, offset: 0x1195] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [BytePrefix, table: 0, index: 2024, offset: 0x119a] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 2025, offset: 0x119c] + | | | +- [BytePrefix, table: 0, index: 2026, offset: 0x119d] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 2027, offset: 0x119f] + | | | +- [BytePrefix, table: 0, index: 2028, offset: 0x11a1] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2029, offset: 0x11a2] + | | | +- [DwordPrefix, table: 0, index: 2030, offset: 0x11a2] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [BytePrefix, table: 0, index: 2031, offset: 0x11a7] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 2032, offset: 0x11a9] + | | | +- [BytePrefix, table: 0, index: 2033, offset: 0x11aa] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 2034, offset: 0x11ac] + | | | +- [BytePrefix, table: 0, index: 2035, offset: 0x11ae] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2036, offset: 0x11af] + | | | +- [DwordPrefix, table: 0, index: 2037, offset: 0x11af] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [Zero, table: 0, index: 2038, offset: 0x11b4] + | | | +- [Zero, table: 0, index: 2039, offset: 0x11b5] + | | | +- [BytePrefix, table: 0, index: 2040, offset: 0x11b6] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 2041, offset: 0x11b8] + | | | +- [BytePrefix, table: 0, index: 2042, offset: 0x11ba] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2043, offset: 0x11bb] + | | | +- [DwordPrefix, table: 0, index: 2044, offset: 0x11bb] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [One, table: 0, index: 2045, offset: 0x11c0] + | | | +- [Zero, table: 0, index: 2046, offset: 0x11c1] + | | | +- [BytePrefix, table: 0, index: 2047, offset: 0x11c2] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 2048, offset: 0x11c4] + | | | +- [BytePrefix, table: 0, index: 2049, offset: 0x11c6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2050, offset: 0x11c7] + | | | +- [DwordPrefix, table: 0, index: 2051, offset: 0x11c7] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [BytePrefix, table: 0, index: 2052, offset: 0x11cc] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 2053, offset: 0x11ce] + | | | +- [BytePrefix, table: 0, index: 2054, offset: 0x11cf] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 2055, offset: 0x11d1] + | | | +- [BytePrefix, table: 0, index: 2056, offset: 0x11d3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2057, offset: 0x11d4] + | | | +- [DwordPrefix, table: 0, index: 2058, offset: 0x11d4] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [BytePrefix, table: 0, index: 2059, offset: 0x11d9] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 2060, offset: 0x11db] + | | | +- [BytePrefix, table: 0, index: 2061, offset: 0x11dc] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 2062, offset: 0x11de] + | | | +- [BytePrefix, table: 0, index: 2063, offset: 0x11e0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2064, offset: 0x11e1] + | | | +- [DwordPrefix, table: 0, index: 2065, offset: 0x11e1] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [Zero, table: 0, index: 2066, offset: 0x11e6] + | | | +- [Zero, table: 0, index: 2067, offset: 0x11e7] + | | | +- [BytePrefix, table: 0, index: 2068, offset: 0x11e8] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 2069, offset: 0x11ea] + | | | +- [BytePrefix, table: 0, index: 2070, offset: 0x11ec] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2071, offset: 0x11ed] + | | | +- [DwordPrefix, table: 0, index: 2072, offset: 0x11ed] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [One, table: 0, index: 2073, offset: 0x11f2] + | | | +- [Zero, table: 0, index: 2074, offset: 0x11f3] + | | | +- [BytePrefix, table: 0, index: 2075, offset: 0x11f4] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 2076, offset: 0x11f6] + | | | +- [BytePrefix, table: 0, index: 2077, offset: 0x11f8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2078, offset: 0x11f9] + | | | +- [DwordPrefix, table: 0, index: 2079, offset: 0x11f9] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [BytePrefix, table: 0, index: 2080, offset: 0x11fe] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 2081, offset: 0x1200] + | | | +- [BytePrefix, table: 0, index: 2082, offset: 0x1201] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 2083, offset: 0x1203] + | | +- [BytePrefix, table: 0, index: 2084, offset: 0x1205] -> [num value; dec: 4, hex: 0x4] + | | +- [ScopeBlock, table: 0, index: 2085, offset: 0x1206] + | | +- [DwordPrefix, table: 0, index: 2086, offset: 0x1206] -> [num value; dec: 2097151, hex: 0x1fffff] + | | +- [BytePrefix, table: 0, index: 2087, offset: 0x120b] -> [num value; dec: 3, hex: 0x3] + | | +- [Zero, table: 0, index: 2088, offset: 0x120d] + | | +- [BytePrefix, table: 0, index: 2089, offset: 0x120e] -> [num value; dec: 18, hex: 0x12] + | +- [Name, name: "PRSA", table: 0, index: 2090, offset: 0x1210] + | | +- [NamePath, table: 0, index: 2091, offset: 0x1211] -> [namepath: "PRSA"] + | | +- [Buffer, table: 0, index: 2092, offset: 0x1215] + | | +- [BytePrefix, table: 0, index: 3167, offset: 0x1217] -> [num value; dec: 6, hex: 0x6] + | | +- [ByteList, table: 0, index: 3169, offset: 0x1e80] -> [bytelist value; len: 6; data: [0x23, 0x20, 0xe, 0x18, 0x79, 0x0]] + | +- [Name, name: "PRSB", table: 0, index: 2093, offset: 0x121f] + | | +- [NamePath, table: 0, index: 2094, offset: 0x1220] -> [namepath: "PRSB"] + | | +- [Buffer, table: 0, index: 2095, offset: 0x1224] + | | +- [BytePrefix, table: 0, index: 3168, offset: 0x1226] -> [num value; dec: 6, hex: 0x6] + | | +- [ByteList, table: 0, index: 3088, offset: 0x1d10] -> [bytelist value; len: 6; data: [0x23, 0x20, 0xe, 0x18, 0x79, 0x0]] + | +- [Name, name: "PRSC", table: 0, index: 2096, offset: 0x122e] + | | +- [NamePath, table: 0, index: 2097, offset: 0x122f] -> [namepath: "PRSC"] + | | +- [Buffer, table: 0, index: 2098, offset: 0x1233] + | | +- [BytePrefix, table: 0, index: 3090, offset: 0x1235] -> [num value; dec: 6, hex: 0x6] + | | +- [ByteList, table: 0, index: 3089, offset: 0x1d13] -> [bytelist value; len: 6; data: [0x23, 0x20, 0xe, 0x18, 0x79, 0x0]] + | +- [Name, name: "PRSD", table: 0, index: 2099, offset: 0x123d] + | | +- [NamePath, table: 0, index: 2100, offset: 0x123e] -> [namepath: "PRSD"] + | | +- [Buffer, table: 0, index: 2101, offset: 0x1242] + | | +- [BytePrefix, table: 0, index: 3085, offset: 0x1244] -> [num value; dec: 6, hex: 0x6] + | | +- [ByteList, table: 0, index: 3087, offset: 0x1d10] -> [bytelist value; len: 6; data: [0x23, 0x20, 0xe, 0x18, 0x79, 0x0]] + | +- [Device, name: "PCI0", table: 0, index: 2102, offset: 0x124c] + | | +- [NamePath, table: 0, index: 2103, offset: 0x1250] -> [namepath: "PCI0"] + | | +- [ScopeBlock, table: 0, index: 2104, offset: 0x1254] + | | +- [Name, name: "_HID", table: 0, index: 2105, offset: 0x1254] + | | | +- [NamePath, table: 0, index: 2106, offset: 0x1255] -> [namepath: "_HID"] + | | | +- [DwordPrefix, table: 0, index: 2107, offset: 0x1259] -> [num value; dec: 51040321, hex: 0x30ad041] [EISA: "PNP0A03"] + | | +- [Method, name: "_ADR", argCount: 0, table: 0, index: 2108, offset: 0x125e] + | | | +- [NamePath, table: 0, index: 2109, offset: 0x1260] -> [namepath: "_ADR"] + | | | +- [BytePrefix, table: 0, index: 2110, offset: 0x1264] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 2111, offset: 0x1265] + | | | +- [Return, table: 0, index: 2112, offset: 0x1265] + | | | +- [ResolvedNamePath, table: 0, index: 2113, offset: 0x1266] -> [resolved to "HBCA", table: 0, index: 352, offset: 0x479] + | | +- [Name, name: "_BBN", table: 0, index: 2114, offset: 0x126a] + | | | +- [NamePath, table: 0, index: 2115, offset: 0x126b] -> [namepath: "_BBN"] + | | | +- [Zero, table: 0, index: 2116, offset: 0x126f] + | | +- [Name, name: "_UID", table: 0, index: 2117, offset: 0x1270] + | | | +- [NamePath, table: 0, index: 2118, offset: 0x1271] -> [namepath: "_UID"] + | | | +- [Zero, table: 0, index: 2119, offset: 0x1275] + | | +- [Method, name: "_PRT", argCount: 0, table: 0, index: 2120, offset: 0x1276] + | | | +- [NamePath, table: 0, index: 2121, offset: 0x1279] -> [namepath: "_PRT"] + | | | +- [BytePrefix, table: 0, index: 2122, offset: 0x127d] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 2123, offset: 0x127e] + | | | +- [If, table: 0, index: 2124, offset: 0x127e] + | | | | +- [LEqual, table: 0, index: 2125, offset: 0x1280] + | | | | | +- [Land, table: 0, index: 2126, offset: 0x1281] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2127, offset: 0x1282] -> [resolved to "PICM", table: 0, index: 305, offset: 0x3c7] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2128, offset: 0x1286] -> [resolved to "UIOA", table: 0, index: 334, offset: 0x41f] + | | | | | +- [Zero, table: 0, index: 2129, offset: 0x128a] + | | | | +- [MethodCall, table: 0, index: 2130, offset: 0x128b] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 2131, offset: 0x128f] -> [string value: "RETURNING PIC +"] + | | | +- [Store, table: 0, index: 2132, offset: 0x129f] + | | | | +- [Zero, table: 0, index: 2133, offset: 0x12a0] + | | | | +- [NamePath, table: 0, index: 2134, offset: 0x12a1] -> [namepath: "^.SBRGAPDE"] + | | | +- [Store, table: 0, index: 2135, offset: 0x12ab] + | | | | +- [Zero, table: 0, index: 2136, offset: 0x12ac] + | | | | +- [NamePath, table: 0, index: 2137, offset: 0x12ad] -> [namepath: "^.SBRGAPAD"] + | | | +- [Return, table: 0, index: 2138, offset: 0x12b7] + | | | | +- [ResolvedNamePath, table: 0, index: 2139, offset: 0x12b8] -> [resolved to "PR00", table: 0, index: 400, offset: 0x556] + | | | +- [Else, table: 0, index: 2140, offset: 0x12bc] + | | | +- [ScopeBlock, table: 0, index: 2141, offset: 0x12be] + | | | +- [MethodCall, table: 0, index: 2142, offset: 0x12be] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 2143, offset: 0x12c2] -> [string value: "RETURNING APIC +"] + | | | +- [Store, table: 0, index: 2144, offset: 0x12d3] + | | | | +- [BytePrefix, table: 0, index: 2145, offset: 0x12d4] -> [num value; dec: 190, hex: 0xbe] + | | | | +- [NamePath, table: 0, index: 2146, offset: 0x12d6] -> [namepath: "^.SBRGAPDE"] + | | | +- [Store, table: 0, index: 2147, offset: 0x12e0] + | | | | +- [BytePrefix, table: 0, index: 2148, offset: 0x12e1] -> [num value; dec: 239, hex: 0xef] + | | | | +- [NamePath, table: 0, index: 2149, offset: 0x12e3] -> [namepath: "^.SBRGAPAD"] + | | | +- [Return, table: 0, index: 2150, offset: 0x12ed] + | | | +- [ResolvedNamePath, table: 0, index: 2151, offset: 0x12ee] -> [resolved to "PR01", table: 0, index: 1245, offset: 0xc2b] + | | +- [Device, name: "SBRG", table: 0, index: 2152, offset: 0x12f2] + | | | +- [NamePath, table: 0, index: 2153, offset: 0x12f6] -> [namepath: "SBRG"] + | | | +- [ScopeBlock, table: 0, index: 2154, offset: 0x12fa] + | | | +- [Method, name: "_ADR", argCount: 0, table: 0, index: 2155, offset: 0x12fa] + | | | | +- [NamePath, table: 0, index: 2156, offset: 0x12fc] -> [namepath: "_ADR"] + | | | | +- [BytePrefix, table: 0, index: 2157, offset: 0x1300] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2158, offset: 0x1301] + | | | | +- [Return, table: 0, index: 2159, offset: 0x1301] + | | | | +- [ResolvedNamePath, table: 0, index: 2160, offset: 0x1302] -> [resolved to "IOCA", table: 0, index: 351, offset: 0x474] + | | | +- [OpRegion, name: "PCIC", table: 0, index: 2161, offset: 0x1306] + | | | | +- [NamePath, table: 0, index: 2162, offset: 0x1308] -> [namepath: "PCIC"] + | | | | +- [BytePrefix, table: 0, index: 2163, offset: 0x130c] -> [num value; dec: 2, hex: 0x2] + | | | | +- [Zero, table: 0, index: 2164, offset: 0x130d] + | | | | +- [BytePrefix, table: 0, index: 2165, offset: 0x130e] -> [num value; dec: 255, hex: 0xff] + | | | +- [Field, table: 0, index: 2166, offset: 0x1310] + | | | | +- [NamePath, table: 0, index: 2167, offset: 0x1313] -> [namepath: "PCIC"] + | | | | +- [BytePrefix, table: 0, index: 2168, offset: 0x1317] -> [num value; dec: 1, hex: 0x1] + | | | +- [NamedField, name: "APAD", table: 0, index: 2169, offset: 0x131b] -> [field index: 2166, offset(bytes): 0x568, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "APDE", table: 0, index: 2170, offset: 0x1323] -> [field index: 2166, offset(bytes): 0x6f0, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [Device, name: "PS2K", table: 0, index: 2217, offset: 0x13a3] + | | | | +- [NamePath, table: 0, index: 2218, offset: 0x13a6] -> [namepath: "PS2K"] + | | | | +- [ScopeBlock, table: 0, index: 2219, offset: 0x13aa] + | | | | +- [Name, name: "_HID", table: 0, index: 2220, offset: 0x13aa] + | | | | | +- [NamePath, table: 0, index: 2221, offset: 0x13ab] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2222, offset: 0x13af] -> [num value; dec: 50581569, hex: 0x303d041] [EISA: "PNP0303"] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2223, offset: 0x13b4] + | | | | | +- [NamePath, table: 0, index: 2224, offset: 0x13b6] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2225, offset: 0x13ba] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2226, offset: 0x13bb] + | | | | | +- [Return, table: 0, index: 2227, offset: 0x13bb] + | | | | | +- [BytePrefix, table: 0, index: 2228, offset: 0x13bc] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "_CRS", table: 0, index: 2229, offset: 0x13be] + | | | | +- [NamePath, table: 0, index: 2230, offset: 0x13bf] -> [namepath: "_CRS"] + | | | | +- [Buffer, table: 0, index: 2231, offset: 0x13c3] + | | | | +- [BytePrefix, table: 0, index: 3086, offset: 0x13c5] -> [num value; dec: 21, hex: 0x15] + | | | | +- [ByteList, table: 0, index: 2837, offset: 0x1a86] -> [bytelist value; len: 21; data: [0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x0, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x0, 0x1, 0x22, 0x2, 0x0, 0x79, 0x0]] + | | | +- [Device, name: "DMAC", table: 0, index: 2232, offset: 0x13dc] + | | | | +- [NamePath, table: 0, index: 2233, offset: 0x13df] -> [namepath: "DMAC"] + | | | | +- [ScopeBlock, table: 0, index: 2234, offset: 0x13e3] + | | | | +- [Name, name: "_HID", table: 0, index: 2235, offset: 0x13e3] + | | | | | +- [NamePath, table: 0, index: 2236, offset: 0x13e4] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2237, offset: 0x13e8] -> [num value; dec: 184385, hex: 0x2d041] [EISA: "PNP0200"] + | | | | +- [Name, name: "_CRS", table: 0, index: 2238, offset: 0x13ed] + | | | | +- [NamePath, table: 0, index: 2239, offset: 0x13ee] -> [namepath: "_CRS"] + | | | | +- [Buffer, table: 0, index: 2240, offset: 0x13f2] + | | | | +- [BytePrefix, table: 0, index: 2839, offset: 0x13f4] -> [num value; dec: 29, hex: 0x1d] + | | | | +- [ByteList, table: 0, index: 2838, offset: 0x1a88] -> [bytelist value; len: 29; data: [0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x10, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1, 0x10, 0x47, 0x1, 0xc0, 0x0, 0xc0, 0x0, 0x1, 0x20, 0x2a, 0x10, 0x5, 0x79, 0x0]] + | | | +- [Device, name: "FDC0", table: 0, index: 2241, offset: 0x1413] + | | | | +- [NamePath, table: 0, index: 2242, offset: 0x1417] -> [namepath: "FDC0"] + | | | | +- [ScopeBlock, table: 0, index: 2243, offset: 0x141b] + | | | | +- [Name, name: "_HID", table: 0, index: 2244, offset: 0x141b] + | | | | | +- [NamePath, table: 0, index: 2245, offset: 0x141c] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2246, offset: 0x1420] -> [num value; dec: 512065, hex: 0x7d041] [EISA: "PNP0700"] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2247, offset: 0x1425] + | | | | | +- [NamePath, table: 0, index: 2248, offset: 0x1427] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2249, offset: 0x142b] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2250, offset: 0x142c] + | | | | | +- [Return, table: 0, index: 2251, offset: 0x142c] + | | | | | +- [ResolvedNamePath, table: 0, index: 2252, offset: 0x142d] -> [resolved to "UFDC", table: 0, index: 337, offset: 0x42e] + | | | | +- [Name, name: "_CRS", table: 0, index: 2253, offset: 0x1431] + | | | | | +- [NamePath, table: 0, index: 2254, offset: 0x1432] -> [namepath: "_CRS"] + | | | | | +- [Buffer, table: 0, index: 2255, offset: 0x1436] + | | | | | +- [BytePrefix, table: 0, index: 2732, offset: 0x1438] -> [num value; dec: 24, hex: 0x18] + | | | | | +- [ByteList, table: 0, index: 2734, offset: 0x1993] -> [bytelist value; len: 24; data: [0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0x1, 0x6, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x1, 0x1, 0x22, 0x40, 0x0, 0x2a, 0x4, 0x0, 0x79, 0x0]] + | | | | +- [Name, name: "_PRS", table: 0, index: 2256, offset: 0x1452] + | | | | +- [NamePath, table: 0, index: 2257, offset: 0x1453] -> [namepath: "_PRS"] + | | | | +- [Buffer, table: 0, index: 2258, offset: 0x1457] + | | | | +- [BytePrefix, table: 0, index: 2733, offset: 0x1459] -> [num value; dec: 24, hex: 0x18] + | | | | +- [ByteList, table: 0, index: 366, offset: 0x4c4] -> [bytelist value; len: 24; data: [0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0x1, 0x6, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x1, 0x1, 0x22, 0x40, 0x0, 0x2a, 0x4, 0x0, 0x79, 0x0]] + | | | +- [Device, name: "PS2M", table: 0, index: 2259, offset: 0x1473] + | | | | +- [NamePath, table: 0, index: 2260, offset: 0x1476] -> [namepath: "PS2M"] + | | | | +- [ScopeBlock, table: 0, index: 2261, offset: 0x147a] + | | | | +- [Name, name: "_HID", table: 0, index: 2262, offset: 0x147a] + | | | | | +- [NamePath, table: 0, index: 2263, offset: 0x147b] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2264, offset: 0x147f] -> [num value; dec: 51368001, hex: 0x30fd041] [EISA: "PNP0F03"] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2265, offset: 0x1484] + | | | | | +- [NamePath, table: 0, index: 2266, offset: 0x1486] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2267, offset: 0x148a] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2268, offset: 0x148b] + | | | | | +- [Return, table: 0, index: 2269, offset: 0x148b] + | | | | | +- [BytePrefix, table: 0, index: 2270, offset: 0x148c] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "_CRS", table: 0, index: 2271, offset: 0x148e] + | | | | +- [NamePath, table: 0, index: 2272, offset: 0x148f] -> [namepath: "_CRS"] + | | | | +- [Buffer, table: 0, index: 2273, offset: 0x1493] + | | | | +- [BytePrefix, table: 0, index: 368, offset: 0x1495] -> [num value; dec: 5, hex: 0x5] + | | | | +- [ByteList, table: 0, index: 367, offset: 0x4c8] -> [bytelist value; len: 5; data: [0x22, 0x0, 0x10, 0x79, 0x0]] + | | | +- [Device, name: "TIMR", table: 0, index: 2598, offset: 0x17fa] + | | | | +- [NamePath, table: 0, index: 2599, offset: 0x17fd] -> [namepath: "TIMR"] + | | | | +- [ScopeBlock, table: 0, index: 2600, offset: 0x1801] + | | | | +- [Name, name: "_HID", table: 0, index: 2601, offset: 0x1801] + | | | | | +- [NamePath, table: 0, index: 2602, offset: 0x1802] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2603, offset: 0x1806] -> [num value; dec: 118849, hex: 0x1d041] [EISA: "PNP0100"] + | | | | +- [Name, name: "_CRS", table: 0, index: 2604, offset: 0x180b] + | | | | +- [NamePath, table: 0, index: 2605, offset: 0x180c] -> [namepath: "_CRS"] + | | | | +- [Buffer, table: 0, index: 2606, offset: 0x1810] + | | | | +- [BytePrefix, table: 0, index: 3491, offset: 0x1812] -> [num value; dec: 18, hex: 0x12] + | | | | +- [ByteList, table: 0, index: 3492, offset: 0x0] -> [bytelist value; len: 18; data: [0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x0, 0x4, 0x47, 0x1, 0x50, 0x0, 0x50, 0x0, 0x10, 0x4, 0x79, 0x0]] + | | | +- [Device, name: "PIC_", table: 0, index: 2607, offset: 0x1826] + | | | | +- [NamePath, table: 0, index: 2608, offset: 0x1829] -> [namepath: "PIC_"] + | | | | +- [ScopeBlock, table: 0, index: 2609, offset: 0x182d] + | | | | +- [Name, name: "_HID", table: 0, index: 2610, offset: 0x182d] + | | | | | +- [NamePath, table: 0, index: 2611, offset: 0x182e] -> [namepath: "_HID"] + | | | | | +- [WordPrefix, table: 0, index: 2612, offset: 0x1832] -> [num value; dec: 53313, hex: 0xd041] + | | | | +- [Name, name: "_CRS", table: 0, index: 2613, offset: 0x1835] + | | | | +- [NamePath, table: 0, index: 2614, offset: 0x1836] -> [namepath: "_CRS"] + | | | | +- [Buffer, table: 0, index: 2615, offset: 0x183a] + | | | | +- [BytePrefix, table: 0, index: 3493, offset: 0x183c] -> [num value; dec: 21, hex: 0x15] + | | | | +- [ByteList, table: 0, index: 3494, offset: 0x0] -> [bytelist value; len: 21; data: [0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0x0, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x0, 0x2, 0x22, 0x4, 0x0, 0x79, 0x0]] + | | | +- [Device, name: "RTC_", table: 0, index: 2616, offset: 0x1853] + | | | | +- [NamePath, table: 0, index: 2617, offset: 0x1856] -> [namepath: "RTC_"] + | | | | +- [ScopeBlock, table: 0, index: 2618, offset: 0x185a] + | | | | +- [Name, name: "_HID", table: 0, index: 2619, offset: 0x185a] + | | | | | +- [NamePath, table: 0, index: 2620, offset: 0x185b] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2621, offset: 0x185f] -> [num value; dec: 774209, hex: 0xbd041] [EISA: "PNP0B00"] + | | | | +- [Name, name: "_CRS", table: 0, index: 2622, offset: 0x1864] + | | | | | +- [NamePath, table: 0, index: 2623, offset: 0x1865] -> [namepath: "_CRS"] + | | | | | +- [Buffer, table: 0, index: 2624, offset: 0x1869] + | | | | | +- [BytePrefix, table: 0, index: 3495, offset: 0x186b] -> [num value; dec: 10, hex: 0xa] + | | | | | +- [ByteList, table: 0, index: 3496, offset: 0x0] -> [bytelist value; len: 10; data: [0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x1, 0x2, 0x79, 0x0]] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2625, offset: 0x1877] + | | | | +- [NamePath, table: 0, index: 2626, offset: 0x1879] -> [namepath: "_STA"] + | | | | +- [BytePrefix, table: 0, index: 2627, offset: 0x187d] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2628, offset: 0x187e] + | | | | +- [Return, table: 0, index: 2629, offset: 0x187e] + | | | | +- [ResolvedNamePath, table: 0, index: 2630, offset: 0x187f] -> [resolved to "URTC", table: 0, index: 343, offset: 0x44c] + | | | +- [Device, name: "HPET", table: 0, index: 2631, offset: 0x1883] + | | | | +- [NamePath, table: 0, index: 2632, offset: 0x1887] -> [namepath: "HPET"] + | | | | +- [ScopeBlock, table: 0, index: 2633, offset: 0x188b] + | | | | +- [Name, name: "_HID", table: 0, index: 2634, offset: 0x188b] + | | | | | +- [NamePath, table: 0, index: 2635, offset: 0x188c] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2636, offset: 0x1890] -> [num value; dec: 50450497, hex: 0x301d041] [EISA: "PNP0103"] + | | | | +- [Name, name: "_CID", table: 0, index: 2637, offset: 0x1895] + | | | | | +- [NamePath, table: 0, index: 2638, offset: 0x1896] -> [namepath: "_CID"] + | | | | | +- [DwordPrefix, table: 0, index: 2639, offset: 0x189a] -> [num value; dec: 17616961, hex: 0x10cd041] + | | | | +- [Name, name: "_UID", table: 0, index: 2640, offset: 0x189f] + | | | | | +- [NamePath, table: 0, index: 2641, offset: 0x18a0] -> [namepath: "_UID"] + | | | | | +- [Zero, table: 0, index: 2642, offset: 0x18a4] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2643, offset: 0x18a5] + | | | | | +- [NamePath, table: 0, index: 2644, offset: 0x18a7] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2645, offset: 0x18ab] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2646, offset: 0x18ac] + | | | | | +- [Return, table: 0, index: 2647, offset: 0x18ac] + | | | | | +- [ResolvedNamePath, table: 0, index: 2648, offset: 0x18ad] -> [resolved to "UHPT", table: 0, index: 335, offset: 0x424] + | | | | +- [Name, name: "CRS_", table: 0, index: 2649, offset: 0x18b1] + | | | | | +- [NamePath, table: 0, index: 2650, offset: 0x18b2] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2651, offset: 0x18b6] + | | | | | +- [BytePrefix, table: 0, index: 3497, offset: 0x18b8] -> [num value; dec: 20, hex: 0x14] + | | | | | +- [ByteList, table: 0, index: 3498, offset: 0x0] -> [bytelist value; len: 20; data: [0x22, 0x1, 0x0, 0x22, 0x0, 0x1, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xd0, 0xfe, 0x0, 0x4, 0x0, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2652, offset: 0x18ce] + | | | | +- [NamePath, table: 0, index: 2653, offset: 0x18d0] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2654, offset: 0x18d4] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2655, offset: 0x18d5] + | | | | +- [Return, table: 0, index: 2656, offset: 0x18d5] + | | | | +- [ResolvedNamePath, table: 0, index: 2657, offset: 0x18d6] -> [resolved to "CRS_", table: 0, index: 2649, offset: 0x18b1] + | | | +- [Device, name: "SMC_", table: 0, index: 2658, offset: 0x18da] + | | | | +- [NamePath, table: 0, index: 2659, offset: 0x18de] -> [namepath: "SMC_"] + | | | | +- [ScopeBlock, table: 0, index: 2660, offset: 0x18e2] + | | | | +- [Name, name: "_HID", table: 0, index: 2661, offset: 0x18e2] + | | | | | +- [NamePath, table: 0, index: 2662, offset: 0x18e3] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2663, offset: 0x18e7] -> [num value; dec: 16781318, hex: 0x1001006] [EISA: "APP0001"] + | | | | +- [Name, name: "_CID", table: 0, index: 2664, offset: 0x18ec] + | | | | | +- [NamePath, table: 0, index: 2665, offset: 0x18ed] -> [namepath: "_CID"] + | | | | | +- [StringPrefix, table: 0, index: 2666, offset: 0x18f1] -> [string value: "smc-napa"] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2667, offset: 0x18fb] + | | | | | +- [NamePath, table: 0, index: 2668, offset: 0x18fd] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2669, offset: 0x1901] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2670, offset: 0x1902] + | | | | | +- [Return, table: 0, index: 2671, offset: 0x1902] + | | | | | +- [ResolvedNamePath, table: 0, index: 2672, offset: 0x1903] -> [resolved to "USMC", table: 0, index: 336, offset: 0x429] + | | | | +- [Name, name: "CRS_", table: 0, index: 2673, offset: 0x1907] + | | | | | +- [NamePath, table: 0, index: 2674, offset: 0x1908] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2675, offset: 0x190c] + | | | | | +- [BytePrefix, table: 0, index: 3499, offset: 0x190e] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3500, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0x0, 0x3, 0x0, 0x3, 0x1, 0x20, 0x22, 0x40, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2676, offset: 0x191d] + | | | | +- [NamePath, table: 0, index: 2677, offset: 0x191f] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2678, offset: 0x1923] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2679, offset: 0x1924] + | | | | +- [Return, table: 0, index: 2680, offset: 0x1924] + | | | | +- [ResolvedNamePath, table: 0, index: 2681, offset: 0x1925] -> [resolved to "CRS_", table: 0, index: 2673, offset: 0x1907] + | | | +- [Device, name: "PCIE", table: 0, index: 2171, offset: 0x1328] + | | | | +- [NamePath, table: 0, index: 2172, offset: 0x132c] -> [namepath: "PCIE"] + | | | | +- [ScopeBlock, table: 0, index: 2173, offset: 0x1331] + | | | | +- [Name, name: "_HID", table: 0, index: 2174, offset: 0x1331] + | | | | | +- [NamePath, table: 0, index: 2175, offset: 0x1332] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2176, offset: 0x1336] -> [num value; dec: 34394177, hex: 0x20cd041] [EISA: "PNP0C02"] + | | | | +- [Name, name: "_UID", table: 0, index: 2177, offset: 0x133b] + | | | | | +- [NamePath, table: 0, index: 2178, offset: 0x133c] -> [namepath: "_UID"] + | | | | | +- [BytePrefix, table: 0, index: 2179, offset: 0x1340] -> [num value; dec: 17, hex: 0x11] + | | | | +- [Name, name: "CRS_", table: 0, index: 2180, offset: 0x1342] + | | | | | +- [NamePath, table: 0, index: 2181, offset: 0x1343] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2182, offset: 0x1347] + | | | | | +- [BytePrefix, table: 0, index: 3501, offset: 0x1349] -> [num value; dec: 14, hex: 0xe] + | | | | | +- [ByteList, table: 0, index: 3502, offset: 0x0] -> [bytelist value; len: 14; data: [0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdc, 0x0, 0x0, 0x0, 0x4, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2183, offset: 0x1359] + | | | | | +- [NamePath, table: 0, index: 2184, offset: 0x135b] -> [namepath: "_CRS"] + | | | | | +- [BytePrefix, table: 0, index: 2185, offset: 0x135f] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2186, offset: 0x1360] + | | | | | +- [CreateDWordField, table: 0, index: 2187, offset: 0x1360] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2188, offset: 0x1361] -> [resolved to "CRS_", table: 0, index: 2180, offset: 0x1342] + | | | | | | +- [BytePrefix, table: 0, index: 2189, offset: 0x1365] -> [num value; dec: 4, hex: 0x4] + | | | | | | +- [NamePath, table: 0, index: 2190, offset: 0x1367] -> [namepath: "BAS1"] + | | | | | +- [CreateDWordField, table: 0, index: 2191, offset: 0x136b] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2192, offset: 0x136c] -> [resolved to "CRS_", table: 0, index: 2180, offset: 0x1342] + | | | | | | +- [BytePrefix, table: 0, index: 2193, offset: 0x1370] -> [num value; dec: 8, hex: 0x8] + | | | | | | +- [NamePath, table: 0, index: 2194, offset: 0x1372] -> [namepath: "LEN1"] + | | | | | +- [Store, table: 0, index: 2195, offset: 0x1376] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2196, offset: 0x1377] -> [resolved to "PCIB", table: 0, index: 353, offset: 0x47e] + | | | | | | +- [NamePath, table: 0, index: 2197, offset: 0x137b] -> [namepath: "BAS1"] + | | | | | +- [Store, table: 0, index: 2198, offset: 0x137f] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2199, offset: 0x1380] -> [resolved to "PCIL", table: 0, index: 354, offset: 0x483] + | | | | | | +- [NamePath, table: 0, index: 2200, offset: 0x1384] -> [namepath: "LEN1"] + | | | | | +- [Return, table: 0, index: 2201, offset: 0x1388] + | | | | | +- [ResolvedNamePath, table: 0, index: 2202, offset: 0x1389] -> [resolved to "CRS_", table: 0, index: 2180, offset: 0x1342] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2203, offset: 0x138d] + | | | | +- [NamePath, table: 0, index: 2204, offset: 0x138f] -> [namepath: "_STA"] + | | | | +- [BytePrefix, table: 0, index: 2205, offset: 0x1393] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2206, offset: 0x1394] + | | | | +- [If, table: 0, index: 2207, offset: 0x1394] + | | | | | +- [LEqual, table: 0, index: 2208, offset: 0x1396] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2209, offset: 0x1397] -> [resolved to "PCIB", table: 0, index: 353, offset: 0x47e] + | | | | | | +- [Zero, table: 0, index: 2210, offset: 0x139b] + | | | | | +- [Return, table: 0, index: 2211, offset: 0x139c] + | | | | | +- [Zero, table: 0, index: 2212, offset: 0x139d] + | | | | +- [Else, table: 0, index: 2213, offset: 0x139e] + | | | | +- [ScopeBlock, table: 0, index: 2214, offset: 0x13a0] + | | | | +- [Return, table: 0, index: 2215, offset: 0x13a0] + | | | | +- [BytePrefix, table: 0, index: 2216, offset: 0x13a1] -> [num value; dec: 15, hex: 0xf] + | | | +- [Device, name: "LPT0", table: 0, index: 2274, offset: 0x149c] + | | | | +- [NamePath, table: 0, index: 2275, offset: 0x14a0] -> [namepath: "LPT0"] + | | | | +- [ScopeBlock, table: 0, index: 2276, offset: 0x14a5] + | | | | +- [Name, name: "_HID", table: 0, index: 2277, offset: 0x14a5] + | | | | | +- [NamePath, table: 0, index: 2278, offset: 0x14a6] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2279, offset: 0x14aa] -> [num value; dec: 315457, hex: 0x4d041] [EISA: "PNP0400"] + | | | | +- [Name, name: "_UID", table: 0, index: 2280, offset: 0x14af] + | | | | | +- [NamePath, table: 0, index: 2281, offset: 0x14b0] -> [namepath: "_UID"] + | | | | | +- [One, table: 0, index: 2282, offset: 0x14b4] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2283, offset: 0x14b5] + | | | | | +- [NamePath, table: 0, index: 2284, offset: 0x14b7] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2285, offset: 0x14bb] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2286, offset: 0x14bc] + | | | | | +- [If, table: 0, index: 2287, offset: 0x14bc] + | | | | | | +- [LEqual, table: 0, index: 2288, offset: 0x14be] + | | | | | | | +- [ResolvedNamePath, table: 0, index: 2289, offset: 0x14bf] -> [resolved to "PP0B", table: 0, index: 359, offset: 0x49c] + | | | | | | | +- [Zero, table: 0, index: 2290, offset: 0x14c3] + | | | | | | +- [Return, table: 0, index: 2291, offset: 0x14c4] + | | | | | | +- [Zero, table: 0, index: 2292, offset: 0x14c5] + | | | | | +- [Else, table: 0, index: 2293, offset: 0x14c6] + | | | | | +- [ScopeBlock, table: 0, index: 2294, offset: 0x14c8] + | | | | | +- [Return, table: 0, index: 2295, offset: 0x14c8] + | | | | | +- [BytePrefix, table: 0, index: 2296, offset: 0x14c9] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "CRS_", table: 0, index: 2297, offset: 0x14cb] + | | | | | +- [NamePath, table: 0, index: 2298, offset: 0x14cc] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2299, offset: 0x14d0] + | | | | | +- [BytePrefix, table: 0, index: 3503, offset: 0x14d2] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3504, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x8, 0x8, 0x22, 0x80, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2300, offset: 0x14e1] + | | | | +- [NamePath, table: 0, index: 2301, offset: 0x14e4] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2302, offset: 0x14e8] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2303, offset: 0x14e9] + | | | | +- [CreateWordField, table: 0, index: 2304, offset: 0x14e9] + | | | | | +- [ResolvedNamePath, table: 0, index: 2305, offset: 0x14ea] -> [resolved to "CRS_", table: 0, index: 2297, offset: 0x14cb] + | | | | | +- [BytePrefix, table: 0, index: 2306, offset: 0x14ee] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [NamePath, table: 0, index: 2307, offset: 0x14f0] -> [namepath: "PMI0"] + | | | | +- [CreateWordField, table: 0, index: 2308, offset: 0x14f4] + | | | | | +- [ResolvedNamePath, table: 0, index: 2309, offset: 0x14f5] -> [resolved to "CRS_", table: 0, index: 2297, offset: 0x14cb] + | | | | | +- [BytePrefix, table: 0, index: 2310, offset: 0x14f9] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [NamePath, table: 0, index: 2311, offset: 0x14fb] -> [namepath: "PMA0"] + | | | | +- [CreateWordField, table: 0, index: 2312, offset: 0x14ff] + | | | | | +- [ResolvedNamePath, table: 0, index: 2313, offset: 0x1500] -> [resolved to "CRS_", table: 0, index: 2297, offset: 0x14cb] + | | | | | +- [BytePrefix, table: 0, index: 2314, offset: 0x1504] -> [num value; dec: 9, hex: 0x9] + | | | | | +- [NamePath, table: 0, index: 2315, offset: 0x1506] -> [namepath: "PIQ0"] + | | | | +- [Store, table: 0, index: 2316, offset: 0x150a] + | | | | | +- [ResolvedNamePath, table: 0, index: 2317, offset: 0x150b] -> [resolved to "PP0B", table: 0, index: 359, offset: 0x49c] + | | | | | +- [NamePath, table: 0, index: 2318, offset: 0x150f] -> [namepath: "PMI0"] + | | | | +- [Store, table: 0, index: 2319, offset: 0x1513] + | | | | | +- [ResolvedNamePath, table: 0, index: 2320, offset: 0x1514] -> [resolved to "PP0B", table: 0, index: 359, offset: 0x49c] + | | | | | +- [NamePath, table: 0, index: 2321, offset: 0x1518] -> [namepath: "PMA0"] + | | | | +- [ShiftLeft, table: 0, index: 2322, offset: 0x151c] + | | | | | +- [One, table: 0, index: 2323, offset: 0x151d] + | | | | | +- [ResolvedNamePath, table: 0, index: 2324, offset: 0x151e] -> [resolved to "PP0I", table: 0, index: 360, offset: 0x4a1] + | | | | | +- [NamePath, table: 0, index: 2325, offset: 0x1522] -> [namepath: "PIQ0"] + | | | | +- [Return, table: 0, index: 2326, offset: 0x1526] + | | | | +- [ResolvedNamePath, table: 0, index: 2327, offset: 0x1527] -> [resolved to "CRS_", table: 0, index: 2297, offset: 0x14cb] + | | | +- [Device, name: "LPT1", table: 0, index: 2328, offset: 0x152b] + | | | | +- [NamePath, table: 0, index: 2329, offset: 0x152f] -> [namepath: "LPT1"] + | | | | +- [ScopeBlock, table: 0, index: 2330, offset: 0x1534] + | | | | +- [Name, name: "_HID", table: 0, index: 2331, offset: 0x1534] + | | | | | +- [NamePath, table: 0, index: 2332, offset: 0x1535] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2333, offset: 0x1539] -> [num value; dec: 315457, hex: 0x4d041] [EISA: "PNP0400"] + | | | | +- [Name, name: "_UID", table: 0, index: 2334, offset: 0x153e] + | | | | | +- [NamePath, table: 0, index: 2335, offset: 0x153f] -> [namepath: "_UID"] + | | | | | +- [BytePrefix, table: 0, index: 2336, offset: 0x1543] -> [num value; dec: 2, hex: 0x2] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2337, offset: 0x1545] + | | | | | +- [NamePath, table: 0, index: 2338, offset: 0x1547] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2339, offset: 0x154b] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2340, offset: 0x154c] + | | | | | +- [If, table: 0, index: 2341, offset: 0x154c] + | | | | | | +- [LEqual, table: 0, index: 2342, offset: 0x154e] + | | | | | | | +- [ResolvedNamePath, table: 0, index: 2343, offset: 0x154f] -> [resolved to "PP1B", table: 0, index: 361, offset: 0x4a6] + | | | | | | | +- [Zero, table: 0, index: 2344, offset: 0x1553] + | | | | | | +- [Return, table: 0, index: 2345, offset: 0x1554] + | | | | | | +- [Zero, table: 0, index: 2346, offset: 0x1555] + | | | | | +- [Else, table: 0, index: 2347, offset: 0x1556] + | | | | | +- [ScopeBlock, table: 0, index: 2348, offset: 0x1558] + | | | | | +- [Return, table: 0, index: 2349, offset: 0x1558] + | | | | | +- [BytePrefix, table: 0, index: 2350, offset: 0x1559] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "CRS_", table: 0, index: 2351, offset: 0x155b] + | | | | | +- [NamePath, table: 0, index: 2352, offset: 0x155c] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2353, offset: 0x1560] + | | | | | +- [BytePrefix, table: 0, index: 3505, offset: 0x1562] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3506, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x8, 0x8, 0x22, 0x20, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2354, offset: 0x1571] + | | | | +- [NamePath, table: 0, index: 2355, offset: 0x1574] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2356, offset: 0x1578] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2357, offset: 0x1579] + | | | | +- [CreateWordField, table: 0, index: 2358, offset: 0x1579] + | | | | | +- [ResolvedNamePath, table: 0, index: 2359, offset: 0x157a] -> [resolved to "CRS_", table: 0, index: 2351, offset: 0x155b] + | | | | | +- [BytePrefix, table: 0, index: 2360, offset: 0x157e] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [NamePath, table: 0, index: 2361, offset: 0x1580] -> [namepath: "PMI1"] + | | | | +- [CreateWordField, table: 0, index: 2362, offset: 0x1584] + | | | | | +- [ResolvedNamePath, table: 0, index: 2363, offset: 0x1585] -> [resolved to "CRS_", table: 0, index: 2351, offset: 0x155b] + | | | | | +- [BytePrefix, table: 0, index: 2364, offset: 0x1589] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [NamePath, table: 0, index: 2365, offset: 0x158b] -> [namepath: "PMA1"] + | | | | +- [CreateWordField, table: 0, index: 2366, offset: 0x158f] + | | | | | +- [ResolvedNamePath, table: 0, index: 2367, offset: 0x1590] -> [resolved to "CRS_", table: 0, index: 2351, offset: 0x155b] + | | | | | +- [BytePrefix, table: 0, index: 2368, offset: 0x1594] -> [num value; dec: 9, hex: 0x9] + | | | | | +- [NamePath, table: 0, index: 2369, offset: 0x1596] -> [namepath: "PIQ1"] + | | | | +- [Store, table: 0, index: 2370, offset: 0x159a] + | | | | | +- [ResolvedNamePath, table: 0, index: 2371, offset: 0x159b] -> [resolved to "PP1B", table: 0, index: 361, offset: 0x4a6] + | | | | | +- [NamePath, table: 0, index: 2372, offset: 0x159f] -> [namepath: "PMI1"] + | | | | +- [Store, table: 0, index: 2373, offset: 0x15a3] + | | | | | +- [ResolvedNamePath, table: 0, index: 2374, offset: 0x15a4] -> [resolved to "PP1B", table: 0, index: 361, offset: 0x4a6] + | | | | | +- [NamePath, table: 0, index: 2375, offset: 0x15a8] -> [namepath: "PMA1"] + | | | | +- [ShiftLeft, table: 0, index: 2376, offset: 0x15ac] + | | | | | +- [One, table: 0, index: 2377, offset: 0x15ad] + | | | | | +- [ResolvedNamePath, table: 0, index: 2378, offset: 0x15ae] -> [resolved to "PP1I", table: 0, index: 362, offset: 0x4ab] + | | | | | +- [NamePath, table: 0, index: 2379, offset: 0x15b2] -> [namepath: "PIQ1"] + | | | | +- [Return, table: 0, index: 2380, offset: 0x15b6] + | | | | +- [ResolvedNamePath, table: 0, index: 2381, offset: 0x15b7] -> [resolved to "CRS_", table: 0, index: 2351, offset: 0x155b] + | | | +- [Device, name: "SRL0", table: 0, index: 2382, offset: 0x15bb] + | | | | +- [NamePath, table: 0, index: 2383, offset: 0x15bf] -> [namepath: "SRL0"] + | | | | +- [ScopeBlock, table: 0, index: 2384, offset: 0x15c4] + | | | | +- [Name, name: "_HID", table: 0, index: 2385, offset: 0x15c4] + | | | | | +- [NamePath, table: 0, index: 2386, offset: 0x15c5] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2387, offset: 0x15c9] -> [num value; dec: 17158209, hex: 0x105d041] [EISA: "PNP0501"] + | | | | +- [Name, name: "_UID", table: 0, index: 2388, offset: 0x15ce] + | | | | | +- [NamePath, table: 0, index: 2389, offset: 0x15cf] -> [namepath: "_UID"] + | | | | | +- [One, table: 0, index: 2390, offset: 0x15d3] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2391, offset: 0x15d4] + | | | | | +- [NamePath, table: 0, index: 2392, offset: 0x15d6] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2393, offset: 0x15da] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2394, offset: 0x15db] + | | | | | +- [If, table: 0, index: 2395, offset: 0x15db] + | | | | | | +- [LEqual, table: 0, index: 2396, offset: 0x15dd] + | | | | | | | +- [ResolvedNamePath, table: 0, index: 2397, offset: 0x15de] -> [resolved to "SL0B", table: 0, index: 355, offset: 0x488] + | | | | | | | +- [Zero, table: 0, index: 2398, offset: 0x15e2] + | | | | | | +- [Return, table: 0, index: 2399, offset: 0x15e3] + | | | | | | +- [Zero, table: 0, index: 2400, offset: 0x15e4] + | | | | | +- [Else, table: 0, index: 2401, offset: 0x15e5] + | | | | | +- [ScopeBlock, table: 0, index: 2402, offset: 0x15e7] + | | | | | +- [Return, table: 0, index: 2403, offset: 0x15e7] + | | | | | +- [BytePrefix, table: 0, index: 2404, offset: 0x15e8] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "CRS_", table: 0, index: 2405, offset: 0x15ea] + | | | | | +- [NamePath, table: 0, index: 2406, offset: 0x15eb] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2407, offset: 0x15ef] + | | | | | +- [BytePrefix, table: 0, index: 3507, offset: 0x15f1] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3508, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x22, 0x10, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2408, offset: 0x1600] + | | | | +- [NamePath, table: 0, index: 2409, offset: 0x1603] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2410, offset: 0x1607] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2411, offset: 0x1608] + | | | | +- [CreateWordField, table: 0, index: 2412, offset: 0x1608] + | | | | | +- [ResolvedNamePath, table: 0, index: 2413, offset: 0x1609] -> [resolved to "CRS_", table: 0, index: 2405, offset: 0x15ea] + | | | | | +- [BytePrefix, table: 0, index: 2414, offset: 0x160d] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [NamePath, table: 0, index: 2415, offset: 0x160f] -> [namepath: "MIN0"] + | | | | +- [CreateWordField, table: 0, index: 2416, offset: 0x1613] + | | | | | +- [ResolvedNamePath, table: 0, index: 2417, offset: 0x1614] -> [resolved to "CRS_", table: 0, index: 2405, offset: 0x15ea] + | | | | | +- [BytePrefix, table: 0, index: 2418, offset: 0x1618] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [NamePath, table: 0, index: 2419, offset: 0x161a] -> [namepath: "MAX0"] + | | | | +- [CreateWordField, table: 0, index: 2420, offset: 0x161e] + | | | | | +- [ResolvedNamePath, table: 0, index: 2421, offset: 0x161f] -> [resolved to "CRS_", table: 0, index: 2405, offset: 0x15ea] + | | | | | +- [BytePrefix, table: 0, index: 2422, offset: 0x1623] -> [num value; dec: 9, hex: 0x9] + | | | | | +- [NamePath, table: 0, index: 2423, offset: 0x1625] -> [namepath: "IRQ0"] + | | | | +- [Store, table: 0, index: 2424, offset: 0x1629] + | | | | | +- [ResolvedNamePath, table: 0, index: 2425, offset: 0x162a] -> [resolved to "SL0B", table: 0, index: 355, offset: 0x488] + | | | | | +- [NamePath, table: 0, index: 2426, offset: 0x162e] -> [namepath: "MIN0"] + | | | | +- [Store, table: 0, index: 2427, offset: 0x1632] + | | | | | +- [ResolvedNamePath, table: 0, index: 2428, offset: 0x1633] -> [resolved to "SL0B", table: 0, index: 355, offset: 0x488] + | | | | | +- [NamePath, table: 0, index: 2429, offset: 0x1637] -> [namepath: "MAX0"] + | | | | +- [ShiftLeft, table: 0, index: 2430, offset: 0x163b] + | | | | | +- [One, table: 0, index: 2431, offset: 0x163c] + | | | | | +- [ResolvedNamePath, table: 0, index: 2432, offset: 0x163d] -> [resolved to "SL0I", table: 0, index: 356, offset: 0x48d] + | | | | | +- [NamePath, table: 0, index: 2433, offset: 0x1641] -> [namepath: "IRQ0"] + | | | | +- [Return, table: 0, index: 2434, offset: 0x1645] + | | | | +- [ResolvedNamePath, table: 0, index: 2435, offset: 0x1646] -> [resolved to "CRS_", table: 0, index: 2405, offset: 0x15ea] + | | | +- [Device, name: "SRL1", table: 0, index: 2436, offset: 0x164a] + | | | | +- [NamePath, table: 0, index: 2437, offset: 0x164e] -> [namepath: "SRL1"] + | | | | +- [ScopeBlock, table: 0, index: 2438, offset: 0x1653] + | | | | +- [Name, name: "_HID", table: 0, index: 2439, offset: 0x1653] + | | | | | +- [NamePath, table: 0, index: 2440, offset: 0x1654] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2441, offset: 0x1658] -> [num value; dec: 17158209, hex: 0x105d041] [EISA: "PNP0501"] + | | | | +- [Name, name: "_UID", table: 0, index: 2442, offset: 0x165d] + | | | | | +- [NamePath, table: 0, index: 2443, offset: 0x165e] -> [namepath: "_UID"] + | | | | | +- [BytePrefix, table: 0, index: 2444, offset: 0x1662] -> [num value; dec: 2, hex: 0x2] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2445, offset: 0x1664] + | | | | | +- [NamePath, table: 0, index: 2446, offset: 0x1666] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2447, offset: 0x166a] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2448, offset: 0x166b] + | | | | | +- [If, table: 0, index: 2449, offset: 0x166b] + | | | | | | +- [LEqual, table: 0, index: 2450, offset: 0x166d] + | | | | | | | +- [ResolvedNamePath, table: 0, index: 2451, offset: 0x166e] -> [resolved to "SL1B", table: 0, index: 357, offset: 0x492] + | | | | | | | +- [Zero, table: 0, index: 2452, offset: 0x1672] + | | | | | | +- [Return, table: 0, index: 2453, offset: 0x1673] + | | | | | | +- [Zero, table: 0, index: 2454, offset: 0x1674] + | | | | | +- [Else, table: 0, index: 2455, offset: 0x1675] + | | | | | +- [ScopeBlock, table: 0, index: 2456, offset: 0x1677] + | | | | | +- [Return, table: 0, index: 2457, offset: 0x1677] + | | | | | +- [BytePrefix, table: 0, index: 2458, offset: 0x1678] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "CRS_", table: 0, index: 2459, offset: 0x167a] + | | | | | +- [NamePath, table: 0, index: 2460, offset: 0x167b] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2461, offset: 0x167f] + | | | | | +- [BytePrefix, table: 0, index: 3509, offset: 0x1681] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3510, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x22, 0x8, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2462, offset: 0x1690] + | | | | +- [NamePath, table: 0, index: 2463, offset: 0x1693] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2464, offset: 0x1697] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2465, offset: 0x1698] + | | | | +- [CreateWordField, table: 0, index: 2466, offset: 0x1698] + | | | | | +- [ResolvedNamePath, table: 0, index: 2467, offset: 0x1699] -> [resolved to "CRS_", table: 0, index: 2459, offset: 0x167a] + | | | | | +- [BytePrefix, table: 0, index: 2468, offset: 0x169d] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [NamePath, table: 0, index: 2469, offset: 0x169f] -> [namepath: "MIN1"] + | | | | +- [CreateWordField, table: 0, index: 2470, offset: 0x16a3] + | | | | | +- [ResolvedNamePath, table: 0, index: 2471, offset: 0x16a4] -> [resolved to "CRS_", table: 0, index: 2459, offset: 0x167a] + | | | | | +- [BytePrefix, table: 0, index: 2472, offset: 0x16a8] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [NamePath, table: 0, index: 2473, offset: 0x16aa] -> [namepath: "MAX1"] + | | | | +- [CreateWordField, table: 0, index: 2474, offset: 0x16ae] + | | | | | +- [ResolvedNamePath, table: 0, index: 2475, offset: 0x16af] -> [resolved to "CRS_", table: 0, index: 2459, offset: 0x167a] + | | | | | +- [BytePrefix, table: 0, index: 2476, offset: 0x16b3] -> [num value; dec: 9, hex: 0x9] + | | | | | +- [NamePath, table: 0, index: 2477, offset: 0x16b5] -> [namepath: "IRQ1"] + | | | | +- [Store, table: 0, index: 2478, offset: 0x16b9] + | | | | | +- [ResolvedNamePath, table: 0, index: 2479, offset: 0x16ba] -> [resolved to "SL1B", table: 0, index: 357, offset: 0x492] + | | | | | +- [NamePath, table: 0, index: 2480, offset: 0x16be] -> [namepath: "MIN1"] + | | | | +- [Store, table: 0, index: 2481, offset: 0x16c2] + | | | | | +- [ResolvedNamePath, table: 0, index: 2482, offset: 0x16c3] -> [resolved to "SL1B", table: 0, index: 357, offset: 0x492] + | | | | | +- [NamePath, table: 0, index: 2483, offset: 0x16c7] -> [namepath: "MAX1"] + | | | | +- [ShiftLeft, table: 0, index: 2484, offset: 0x16cb] + | | | | | +- [One, table: 0, index: 2485, offset: 0x16cc] + | | | | | +- [ResolvedNamePath, table: 0, index: 2486, offset: 0x16cd] -> [resolved to "SL1I", table: 0, index: 358, offset: 0x497] + | | | | | +- [NamePath, table: 0, index: 2487, offset: 0x16d1] -> [namepath: "IRQ1"] + | | | | +- [Return, table: 0, index: 2488, offset: 0x16d5] + | | | | +- [ResolvedNamePath, table: 0, index: 2489, offset: 0x16d6] -> [resolved to "CRS_", table: 0, index: 2459, offset: 0x167a] + | | | +- [Device, name: "SRL2", table: 0, index: 2490, offset: 0x16da] + | | | | +- [NamePath, table: 0, index: 2491, offset: 0x16de] -> [namepath: "SRL2"] + | | | | +- [ScopeBlock, table: 0, index: 2492, offset: 0x16e3] + | | | | +- [Name, name: "_HID", table: 0, index: 2493, offset: 0x16e3] + | | | | | +- [NamePath, table: 0, index: 2494, offset: 0x16e4] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2495, offset: 0x16e8] -> [num value; dec: 17158209, hex: 0x105d041] [EISA: "PNP0501"] + | | | | +- [Name, name: "_UID", table: 0, index: 2496, offset: 0x16ed] + | | | | | +- [NamePath, table: 0, index: 2497, offset: 0x16ee] -> [namepath: "_UID"] + | | | | | +- [BytePrefix, table: 0, index: 2498, offset: 0x16f2] -> [num value; dec: 3, hex: 0x3] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2499, offset: 0x16f4] + | | | | | +- [NamePath, table: 0, index: 2500, offset: 0x16f6] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2501, offset: 0x16fa] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2502, offset: 0x16fb] + | | | | | +- [If, table: 0, index: 2503, offset: 0x16fb] + | | | | | | +- [LEqual, table: 0, index: 2504, offset: 0x16fd] + | | | | | | | +- [ResolvedNamePath, table: 0, index: 2505, offset: 0x16fe] -> [resolved to "SL2B", table: 0, index: 338, offset: 0x433] + | | | | | | | +- [Zero, table: 0, index: 2506, offset: 0x1702] + | | | | | | +- [Return, table: 0, index: 2507, offset: 0x1703] + | | | | | | +- [Zero, table: 0, index: 2508, offset: 0x1704] + | | | | | +- [Else, table: 0, index: 2509, offset: 0x1705] + | | | | | +- [ScopeBlock, table: 0, index: 2510, offset: 0x1707] + | | | | | +- [Return, table: 0, index: 2511, offset: 0x1707] + | | | | | +- [BytePrefix, table: 0, index: 2512, offset: 0x1708] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "CRS_", table: 0, index: 2513, offset: 0x170a] + | | | | | +- [NamePath, table: 0, index: 2514, offset: 0x170b] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2515, offset: 0x170f] + | | | | | +- [BytePrefix, table: 0, index: 3511, offset: 0x1711] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3512, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0x8, 0x22, 0x8, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2516, offset: 0x1720] + | | | | +- [NamePath, table: 0, index: 2517, offset: 0x1723] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2518, offset: 0x1727] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2519, offset: 0x1728] + | | | | +- [CreateWordField, table: 0, index: 2520, offset: 0x1728] + | | | | | +- [ResolvedNamePath, table: 0, index: 2521, offset: 0x1729] -> [resolved to "CRS_", table: 0, index: 2513, offset: 0x170a] + | | | | | +- [BytePrefix, table: 0, index: 2522, offset: 0x172d] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [NamePath, table: 0, index: 2523, offset: 0x172f] -> [namepath: "MIN1"] + | | | | +- [CreateWordField, table: 0, index: 2524, offset: 0x1733] + | | | | | +- [ResolvedNamePath, table: 0, index: 2525, offset: 0x1734] -> [resolved to "CRS_", table: 0, index: 2513, offset: 0x170a] + | | | | | +- [BytePrefix, table: 0, index: 2526, offset: 0x1738] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [NamePath, table: 0, index: 2527, offset: 0x173a] -> [namepath: "MAX1"] + | | | | +- [CreateWordField, table: 0, index: 2528, offset: 0x173e] + | | | | | +- [ResolvedNamePath, table: 0, index: 2529, offset: 0x173f] -> [resolved to "CRS_", table: 0, index: 2513, offset: 0x170a] + | | | | | +- [BytePrefix, table: 0, index: 2530, offset: 0x1743] -> [num value; dec: 9, hex: 0x9] + | | | | | +- [NamePath, table: 0, index: 2531, offset: 0x1745] -> [namepath: "IRQ1"] + | | | | +- [Store, table: 0, index: 2532, offset: 0x1749] + | | | | | +- [ResolvedNamePath, table: 0, index: 2533, offset: 0x174a] -> [resolved to "SL2B", table: 0, index: 338, offset: 0x433] + | | | | | +- [NamePath, table: 0, index: 2534, offset: 0x174e] -> [namepath: "MIN1"] + | | | | +- [Store, table: 0, index: 2535, offset: 0x1752] + | | | | | +- [ResolvedNamePath, table: 0, index: 2536, offset: 0x1753] -> [resolved to "SL2B", table: 0, index: 338, offset: 0x433] + | | | | | +- [NamePath, table: 0, index: 2537, offset: 0x1757] -> [namepath: "MAX1"] + | | | | +- [ShiftLeft, table: 0, index: 2538, offset: 0x175b] + | | | | | +- [One, table: 0, index: 2539, offset: 0x175c] + | | | | | +- [ResolvedNamePath, table: 0, index: 2540, offset: 0x175d] -> [resolved to "SL2I", table: 0, index: 339, offset: 0x438] + | | | | | +- [NamePath, table: 0, index: 2541, offset: 0x1761] -> [namepath: "IRQ1"] + | | | | +- [Return, table: 0, index: 2542, offset: 0x1765] + | | | | +- [ResolvedNamePath, table: 0, index: 2543, offset: 0x1766] -> [resolved to "CRS_", table: 0, index: 2513, offset: 0x170a] + | | | +- [Device, name: "SRL3", table: 0, index: 2544, offset: 0x176a] + | | | +- [NamePath, table: 0, index: 2545, offset: 0x176e] -> [namepath: "SRL3"] + | | | +- [ScopeBlock, table: 0, index: 2546, offset: 0x1773] + | | | +- [Name, name: "_HID", table: 0, index: 2547, offset: 0x1773] + | | | | +- [NamePath, table: 0, index: 2548, offset: 0x1774] -> [namepath: "_HID"] + | | | | +- [DwordPrefix, table: 0, index: 2549, offset: 0x1778] -> [num value; dec: 17158209, hex: 0x105d041] [EISA: "PNP0501"] + | | | +- [Name, name: "_UID", table: 0, index: 2550, offset: 0x177d] + | | | | +- [NamePath, table: 0, index: 2551, offset: 0x177e] -> [namepath: "_UID"] + | | | | +- [BytePrefix, table: 0, index: 2552, offset: 0x1782] -> [num value; dec: 4, hex: 0x4] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2553, offset: 0x1784] + | | | | +- [NamePath, table: 0, index: 2554, offset: 0x1786] -> [namepath: "_STA"] + | | | | +- [BytePrefix, table: 0, index: 2555, offset: 0x178a] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2556, offset: 0x178b] + | | | | +- [If, table: 0, index: 2557, offset: 0x178b] + | | | | | +- [LEqual, table: 0, index: 2558, offset: 0x178d] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2559, offset: 0x178e] -> [resolved to "SL3B", table: 0, index: 340, offset: 0x43d] + | | | | | | +- [Zero, table: 0, index: 2560, offset: 0x1792] + | | | | | +- [Return, table: 0, index: 2561, offset: 0x1793] + | | | | | +- [Zero, table: 0, index: 2562, offset: 0x1794] + | | | | +- [Else, table: 0, index: 2563, offset: 0x1795] + | | | | +- [ScopeBlock, table: 0, index: 2564, offset: 0x1797] + | | | | +- [Return, table: 0, index: 2565, offset: 0x1797] + | | | | +- [BytePrefix, table: 0, index: 2566, offset: 0x1798] -> [num value; dec: 15, hex: 0xf] + | | | +- [Name, name: "CRS_", table: 0, index: 2567, offset: 0x179a] + | | | | +- [NamePath, table: 0, index: 2568, offset: 0x179b] -> [namepath: "CRS_"] + | | | | +- [Buffer, table: 0, index: 2569, offset: 0x179f] + | | | | +- [BytePrefix, table: 0, index: 3513, offset: 0x17a1] -> [num value; dec: 13, hex: 0xd] + | | | | +- [ByteList, table: 0, index: 3514, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x22, 0x8, 0x0, 0x79, 0x0]] + | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2570, offset: 0x17b0] + | | | +- [NamePath, table: 0, index: 2571, offset: 0x17b3] -> [namepath: "_CRS"] + | | | +- [BytePrefix, table: 0, index: 2572, offset: 0x17b7] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 2573, offset: 0x17b8] + | | | +- [CreateWordField, table: 0, index: 2574, offset: 0x17b8] + | | | | +- [ResolvedNamePath, table: 0, index: 2575, offset: 0x17b9] -> [resolved to "CRS_", table: 0, index: 2567, offset: 0x179a] + | | | | +- [BytePrefix, table: 0, index: 2576, offset: 0x17bd] -> [num value; dec: 2, hex: 0x2] + | | | | +- [NamePath, table: 0, index: 2577, offset: 0x17bf] -> [namepath: "MIN1"] + | | | +- [CreateWordField, table: 0, index: 2578, offset: 0x17c3] + | | | | +- [ResolvedNamePath, table: 0, index: 2579, offset: 0x17c4] -> [resolved to "CRS_", table: 0, index: 2567, offset: 0x179a] + | | | | +- [BytePrefix, table: 0, index: 2580, offset: 0x17c8] -> [num value; dec: 4, hex: 0x4] + | | | | +- [NamePath, table: 0, index: 2581, offset: 0x17ca] -> [namepath: "MAX1"] + | | | +- [CreateWordField, table: 0, index: 2582, offset: 0x17ce] + | | | | +- [ResolvedNamePath, table: 0, index: 2583, offset: 0x17cf] -> [resolved to "CRS_", table: 0, index: 2567, offset: 0x179a] + | | | | +- [BytePrefix, table: 0, index: 2584, offset: 0x17d3] -> [num value; dec: 9, hex: 0x9] + | | | | +- [NamePath, table: 0, index: 2585, offset: 0x17d5] -> [namepath: "IRQ1"] + | | | +- [Store, table: 0, index: 2586, offset: 0x17d9] + | | | | +- [ResolvedNamePath, table: 0, index: 2587, offset: 0x17da] -> [resolved to "SL3B", table: 0, index: 340, offset: 0x43d] + | | | | +- [NamePath, table: 0, index: 2588, offset: 0x17de] -> [namepath: "MIN1"] + | | | +- [Store, table: 0, index: 2589, offset: 0x17e2] + | | | | +- [ResolvedNamePath, table: 0, index: 2590, offset: 0x17e3] -> [resolved to "SL3B", table: 0, index: 340, offset: 0x43d] + | | | | +- [NamePath, table: 0, index: 2591, offset: 0x17e7] -> [namepath: "MAX1"] + | | | +- [ShiftLeft, table: 0, index: 2592, offset: 0x17eb] + | | | | +- [One, table: 0, index: 2593, offset: 0x17ec] + | | | | +- [ResolvedNamePath, table: 0, index: 2594, offset: 0x17ed] -> [resolved to "SL3I", table: 0, index: 341, offset: 0x442] + | | | | +- [NamePath, table: 0, index: 2595, offset: 0x17f1] -> [namepath: "IRQ1"] + | | | +- [Return, table: 0, index: 2596, offset: 0x17f5] + | | | +- [ResolvedNamePath, table: 0, index: 2597, offset: 0x17f6] -> [resolved to "CRS_", table: 0, index: 2567, offset: 0x179a] + | | +- [Device, name: "GIGE", table: 0, index: 2682, offset: 0x1929] + | | | +- [NamePath, table: 0, index: 2683, offset: 0x192c] -> [namepath: "GIGE"] + | | | +- [ScopeBlock, table: 0, index: 2684, offset: 0x1930] + | | | +- [Name, name: "_HID", table: 0, index: 2685, offset: 0x1930] + | | | | +- [NamePath, table: 0, index: 2686, offset: 0x1931] -> [namepath: "_HID"] + | | | | +- [DwordPrefix, table: 0, index: 2687, offset: 0x1935] -> [num value; dec: 2424557633, hex: 0x9083d041] [EISA: "PNP8390"] + | | | +- [Method, name: "_ADR", argCount: 0, table: 0, index: 2688, offset: 0x193a] + | | | | +- [NamePath, table: 0, index: 2689, offset: 0x193c] -> [namepath: "_ADR"] + | | | | +- [BytePrefix, table: 0, index: 2690, offset: 0x1940] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2691, offset: 0x1941] + | | | | +- [Return, table: 0, index: 2692, offset: 0x1941] + | | | | +- [ResolvedNamePath, table: 0, index: 2693, offset: 0x1942] -> [resolved to "NICA", table: 0, index: 348, offset: 0x465] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2694, offset: 0x1946] + | | | +- [NamePath, table: 0, index: 2695, offset: 0x1948] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 2696, offset: 0x194c] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 2697, offset: 0x194d] + | | | +- [If, table: 0, index: 2698, offset: 0x194d] + | | | | +- [LEqual, table: 0, index: 2699, offset: 0x194f] + | | | | | +- [ResolvedNamePath, table: 0, index: 2700, offset: 0x1950] -> [resolved to "NICA", table: 0, index: 348, offset: 0x465] + | | | | | +- [Zero, table: 0, index: 2701, offset: 0x1954] + | | | | +- [Return, table: 0, index: 2702, offset: 0x1955] + | | | | +- [Zero, table: 0, index: 2703, offset: 0x1956] + | | | +- [Else, table: 0, index: 2704, offset: 0x1957] + | | | +- [ScopeBlock, table: 0, index: 2705, offset: 0x1959] + | | | +- [Return, table: 0, index: 2706, offset: 0x1959] + | | | +- [BytePrefix, table: 0, index: 2707, offset: 0x195a] -> [num value; dec: 15, hex: 0xf] + | | +- [Device, name: "GFX0", table: 0, index: 2708, offset: 0x195c] + | | | +- [NamePath, table: 0, index: 2709, offset: 0x1960] -> [namepath: "GFX0"] + | | | +- [ScopeBlock, table: 0, index: 2710, offset: 0x1964] + | | | +- [Name, name: "_ADR", table: 0, index: 2711, offset: 0x1964] + | | | | +- [NamePath, table: 0, index: 2712, offset: 0x1965] -> [namepath: "_ADR"] + | | | | +- [DwordPrefix, table: 0, index: 2713, offset: 0x1969] -> [num value; dec: 131072, hex: 0x20000] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2714, offset: 0x196e] + | | | | +- [NamePath, table: 0, index: 2715, offset: 0x1970] -> [namepath: "_STA"] + | | | | +- [BytePrefix, table: 0, index: 2716, offset: 0x1974] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2717, offset: 0x1975] + | | | | +- [If, table: 0, index: 2718, offset: 0x1975] + | | | | | +- [Land, table: 0, index: 2719, offset: 0x1977] + | | | | | | +- [LGreater, table: 0, index: 2720, offset: 0x1978] + | | | | | | | +- [MethodCall, table: 0, index: 2721, offset: 0x1979] -> [call to "MSWN", argCount: 0, table: 0, index: 184, offset: 0x185] + | | | | | | | +- [Zero, table: 0, index: 2722, offset: 0x197d] + | | | | | | +- [LLess, table: 0, index: 2723, offset: 0x197e] + | | | | | | +- [MethodCall, table: 0, index: 2724, offset: 0x197f] -> [call to "MSWN", argCount: 0, table: 0, index: 184, offset: 0x185] + | | | | | | +- [BytePrefix, table: 0, index: 2725, offset: 0x1983] -> [num value; dec: 8, hex: 0x8] + | | | | | +- [Return, table: 0, index: 2726, offset: 0x1985] + | | | | | +- [Zero, table: 0, index: 2727, offset: 0x1986] + | | | | +- [Else, table: 0, index: 2728, offset: 0x1987] + | | | | +- [ScopeBlock, table: 0, index: 2729, offset: 0x1989] + | | | | +- [Return, table: 0, index: 2730, offset: 0x1989] + | | | | +- [BytePrefix, table: 0, index: 2731, offset: 0x198a] -> [num value; dec: 15, hex: 0xf] + | | | +- [Method, name: "_DOS", argCount: 1, table: 0, index: 2742, offset: 0x19ac] + | | | | +- [NamePath, table: 0, index: 2743, offset: 0x19ae] -> [namepath: "_DOS"] + | | | | +- [BytePrefix, table: 0, index: 2744, offset: 0x19b2] -> [num value; dec: 1, hex: 0x1] + | | | | +- [ScopeBlock, table: 0, index: 2745, offset: 0x19b3] + | | | +- [Method, name: "_DOD", argCount: 0, table: 0, index: 2746, offset: 0x19b3] + | | | | +- [NamePath, table: 0, index: 2747, offset: 0x19b5] -> [namepath: "_DOD"] + | | | | +- [BytePrefix, table: 0, index: 2748, offset: 0x19b9] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2749, offset: 0x19ba] + | | | | +- [Return, table: 0, index: 2750, offset: 0x19ba] + | | | | +- [Package, table: 0, index: 2751, offset: 0x19bb] + | | | | +- [BytePrefix, table: 0, index: 2752, offset: 0x19bd] -> [num value; dec: 1, hex: 0x1] + | | | | +- [ScopeBlock, table: 0, index: 2753, offset: 0x19be] + | | | | +- [DwordPrefix, table: 0, index: 2754, offset: 0x19be] -> [num value; dec: 2147483904, hex: 0x80000100] + | | | +- [Device, name: "VGA_", table: 0, index: 2755, offset: 0x19c3] + | | | +- [NamePath, table: 0, index: 2756, offset: 0x19c6] -> [namepath: "VGA_"] + | | | +- [ScopeBlock, table: 0, index: 2757, offset: 0x19ca] + | | | +- [Method, name: "_ADR", argCount: 0, table: 0, index: 2758, offset: 0x19ca] + | | | +- [NamePath, table: 0, index: 2759, offset: 0x19cc] -> [namepath: "_ADR"] + | | | +- [BytePrefix, table: 0, index: 2760, offset: 0x19d0] -> [num value; dec: 8, hex: 0x8] + | | | +- [ScopeBlock, table: 0, index: 2761, offset: 0x19d1] + | | | +- [Return, table: 0, index: 2762, offset: 0x19d1] + | | | +- [WordPrefix, table: 0, index: 2763, offset: 0x19d2] -> [num value; dec: 256, hex: 0x100] + | | +- [Device, name: "HDEF", table: 0, index: 2764, offset: 0x19d5] + | | | +- [NamePath, table: 0, index: 2765, offset: 0x19d9] -> [namepath: "HDEF"] + | | | +- [ScopeBlock, table: 0, index: 2766, offset: 0x19dd] + | | | +- [Method, name: "_DSM", argCount: 4, table: 0, index: 2767, offset: 0x19dd] + | | | | +- [NamePath, table: 0, index: 2768, offset: 0x19e0] -> [namepath: "_DSM"] + | | | | +- [BytePrefix, table: 0, index: 2769, offset: 0x19e4] -> [num value; dec: 4, hex: 0x4] + | | | | +- [ScopeBlock, table: 0, index: 2770, offset: 0x19e5] + | | | | +- [Store, table: 0, index: 2771, offset: 0x19e5] + | | | | | +- [Package, table: 0, index: 2772, offset: 0x19e6] + | | | | | | +- [BytePrefix, table: 0, index: 2773, offset: 0x19e8] -> [num value; dec: 4, hex: 0x4] + | | | | | | +- [ScopeBlock, table: 0, index: 2774, offset: 0x19e9] + | | | | | | +- [StringPrefix, table: 0, index: 2775, offset: 0x19e9] -> [string value: "layout-id"] + | | | | | | +- [Buffer, table: 0, index: 2776, offset: 0x19f4] + | | | | | | | +- [BytePrefix, table: 0, index: 3515, offset: 0x19f6] -> [num value; dec: 4, hex: 0x4] + | | | | | | | +- [ByteList, table: 0, index: 3516, offset: 0x0] -> [bytelist value; len: 4; data: [0x4, 0x0, 0x0, 0x0]] + | | | | | | +- [StringPrefix, table: 0, index: 2777, offset: 0x19fc] -> [string value: "PinConfigurations"] + | | | | | | +- [Buffer, table: 0, index: 2778, offset: 0x1a0f] + | | | | | | +- [Zero, table: 0, index: 3517, offset: 0x1a11] + | | | | | | +- [ByteList, table: 0, index: 3518, offset: 0x0] -> [bytelist value; len: 0; data: []] + | | | | | +- [Local0, table: 0, index: 2779, offset: 0x1a12] + | | | | +- [If, table: 0, index: 2780, offset: 0x1a13] + | | | | | +- [LEqual, table: 0, index: 2781, offset: 0x1a15] + | | | | | | +- [Arg0, table: 0, index: 2782, offset: 0x1a16] + | | | | | | +- [Buffer, table: 0, index: 2783, offset: 0x1a17] + | | | | | | +- [BytePrefix, table: 0, index: 3519, offset: 0x1a19] -> [num value; dec: 16, hex: 0x10] + | | | | | | +- [ByteList, table: 0, index: 3520, offset: 0x0] -> [bytelist value; len: 16; data: [0xc6, 0xb7, 0xb5, 0xa0, 0x18, 0x13, 0x1c, 0x44, 0xb0, 0xc9, 0xfe, 0x69, 0x5e, 0xaf, 0x94, 0x9b]] + | | | | | +- [If, table: 0, index: 2784, offset: 0x1a2b] + | | | | | +- [LEqual, table: 0, index: 2785, offset: 0x1a2d] + | | | | | | +- [Arg1, table: 0, index: 2786, offset: 0x1a2e] + | | | | | | +- [One, table: 0, index: 2787, offset: 0x1a2f] + | | | | | +- [If, table: 0, index: 2788, offset: 0x1a30] + | | | | | +- [LEqual, table: 0, index: 2789, offset: 0x1a32] + | | | | | | +- [Arg2, table: 0, index: 2790, offset: 0x1a33] + | | | | | | +- [Zero, table: 0, index: 2791, offset: 0x1a34] + | | | | | +- [Store, table: 0, index: 2792, offset: 0x1a35] + | | | | | +- [Buffer, table: 0, index: 2793, offset: 0x1a36] + | | | | | | +- [One, table: 0, index: 3521, offset: 0x1a38] + | | | | | | +- [ByteList, table: 0, index: 3522, offset: 0x0] -> [bytelist value; len: 1; data: [0x3]] + | | | | | +- [Local0, table: 0, index: 2794, offset: 0x1a3a] + | | | | +- [Return, table: 0, index: 2795, offset: 0x1a3b] + | | | | | +- [Local0, table: 0, index: 2796, offset: 0x1a3c] + | | | | +- [If, table: 0, index: 2797, offset: 0x1a3d] + | | | | | +- [LEqual, table: 0, index: 2798, offset: 0x1a3f] + | | | | | | +- [Arg2, table: 0, index: 2799, offset: 0x1a40] + | | | | | | +- [One, table: 0, index: 2800, offset: 0x1a41] + | | | | | +- [Return, table: 0, index: 2801, offset: 0x1a42] + | | | | | +- [Local0, table: 0, index: 2802, offset: 0x1a43] + | | | | +- [Store, table: 0, index: 2803, offset: 0x1a44] + | | | | | +- [Buffer, table: 0, index: 2804, offset: 0x1a45] + | | | | | | +- [One, table: 0, index: 3523, offset: 0x1a47] + | | | | | | +- [ByteList, table: 0, index: 3524, offset: 0x0] -> [bytelist value; len: 1; data: [0x0]] + | | | | | +- [Local0, table: 0, index: 2805, offset: 0x1a49] + | | | | +- [Return, table: 0, index: 2806, offset: 0x1a4a] + | | | | +- [Local0, table: 0, index: 2807, offset: 0x1a4b] + | | | +- [Method, name: "_ADR", argCount: 0, table: 0, index: 2808, offset: 0x1a4c] + | | | | +- [NamePath, table: 0, index: 2809, offset: 0x1a4e] -> [namepath: "_ADR"] + | | | | +- [BytePrefix, table: 0, index: 2810, offset: 0x1a52] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2811, offset: 0x1a53] + | | | | +- [Return, table: 0, index: 2812, offset: 0x1a53] + | | | | +- [ResolvedNamePath, table: 0, index: 2813, offset: 0x1a54] -> [resolved to "HDAA", table: 0, index: 349, offset: 0x46a] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2814, offset: 0x1a58] + | | | +- [NamePath, table: 0, index: 2815, offset: 0x1a5a] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 2816, offset: 0x1a5e] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 2817, offset: 0x1a5f] + | | | +- [If, table: 0, index: 2818, offset: 0x1a5f] + | | | | +- [LEqual, table: 0, index: 2819, offset: 0x1a61] + | | | | | +- [ResolvedNamePath, table: 0, index: 2820, offset: 0x1a62] -> [resolved to "HDAA", table: 0, index: 349, offset: 0x46a] + | | | | | +- [Zero, table: 0, index: 2821, offset: 0x1a66] + | | | | +- [Return, table: 0, index: 2822, offset: 0x1a67] + | | | | +- [Zero, table: 0, index: 2823, offset: 0x1a68] + | | | +- [Else, table: 0, index: 2824, offset: 0x1a69] + | | | +- [ScopeBlock, table: 0, index: 2825, offset: 0x1a6b] + | | | +- [Return, table: 0, index: 2826, offset: 0x1a6b] + | | | +- [BytePrefix, table: 0, index: 2827, offset: 0x1a6c] -> [num value; dec: 15, hex: 0xf] + | | +- [Device, name: "BAT0", table: 0, index: 2828, offset: 0x1a6e] + | | | +- [NamePath, table: 0, index: 2829, offset: 0x1a72] -> [namepath: "BAT0"] + | | | +- [ScopeBlock, table: 0, index: 2830, offset: 0x1a76] + | | | +- [Name, name: "_HID", table: 0, index: 2831, offset: 0x1a76] + | | | | +- [NamePath, table: 0, index: 2832, offset: 0x1a77] -> [namepath: "_HID"] + | | | | +- [DwordPrefix, table: 0, index: 2833, offset: 0x1a7b] -> [num value; dec: 168611905, hex: 0xa0cd041] [EISA: "PNP0C0A"] + | | | +- [Name, name: "_UID", table: 0, index: 2834, offset: 0x1a80] + | | | | +- [NamePath, table: 0, index: 2835, offset: 0x1a81] -> [namepath: "_UID"] + | | | | +- [Zero, table: 0, index: 2836, offset: 0x1a85] + | | | +- [OpRegion, name: "CBAT", table: 0, index: 2850, offset: 0x1ab8] + | | | | +- [NamePath, table: 0, index: 2851, offset: 0x1aba] -> [namepath: "CBAT"] + | | | | +- [BytePrefix, table: 0, index: 2852, offset: 0x1abe] -> [num value; dec: 1, hex: 0x1] + | | | | +- [WordPrefix, table: 0, index: 2853, offset: 0x1abf] -> [num value; dec: 16448, hex: 0x4040] + | | | | +- [BytePrefix, table: 0, index: 2854, offset: 0x1ac2] -> [num value; dec: 8, hex: 0x8] + | | | +- [Field, table: 0, index: 2855, offset: 0x1ac4] + | | | | +- [NamePath, table: 0, index: 2856, offset: 0x1ac7] -> [namepath: "CBAT"] + | | | | +- [BytePrefix, table: 0, index: 2857, offset: 0x1acb] -> [num value; dec: 3, hex: 0x3] + | | | +- [NamedField, name: "IDX0", table: 0, index: 2858, offset: 0x1acc] -> [field index: 2855, offset(bytes): 0x0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "DAT0", table: 0, index: 2859, offset: 0x1ad1] -> [field index: 2855, offset(bytes): 0x20, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [IndexField, name: "IDX0", table: 0, index: 2860, offset: 0x1ad6] + | | | | +- [NamePath, table: 0, index: 2861, offset: 0x1ada] -> [namepath: "IDX0"] + | | | | +- [NamePath, table: 0, index: 2862, offset: 0x1ade] -> [namepath: "DAT0"] + | | | | +- [BytePrefix, table: 0, index: 2863, offset: 0x1ae2] -> [num value; dec: 3, hex: 0x3] + | | | +- [NamedField, name: "STAT", table: 0, index: 2864, offset: 0x1ae3] -> [field index: 2860, offset(bytes): 0x0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "PRAT", table: 0, index: 2865, offset: 0x1ae8] -> [field index: 2860, offset(bytes): 0x20, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "RCAP", table: 0, index: 2866, offset: 0x1aed] -> [field index: 2860, offset(bytes): 0x40, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "PVOL", table: 0, index: 2867, offset: 0x1af2] -> [field index: 2860, offset(bytes): 0x60, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "UNIT", table: 0, index: 2868, offset: 0x1af7] -> [field index: 2860, offset(bytes): 0x80, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "DCAP", table: 0, index: 2869, offset: 0x1afc] -> [field index: 2860, offset(bytes): 0xa0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "LFCP", table: 0, index: 2870, offset: 0x1b01] -> [field index: 2860, offset(bytes): 0xc0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "BTEC", table: 0, index: 2871, offset: 0x1b06] -> [field index: 2860, offset(bytes): 0xe0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "DVOL", table: 0, index: 2872, offset: 0x1b0b] -> [field index: 2860, offset(bytes): 0x100, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "DWRN", table: 0, index: 2873, offset: 0x1b10] -> [field index: 2860, offset(bytes): 0x120, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "DLOW", table: 0, index: 2874, offset: 0x1b15] -> [field index: 2860, offset(bytes): 0x140, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "GRN1", table: 0, index: 2875, offset: 0x1b1a] -> [field index: 2860, offset(bytes): 0x160, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "GRN2", table: 0, index: 2876, offset: 0x1b1f] -> [field index: 2860, offset(bytes): 0x180, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "BSTA", table: 0, index: 2877, offset: 0x1b24] -> [field index: 2860, offset(bytes): 0x1a0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "APSR", table: 0, index: 2878, offset: 0x1b29] -> [field index: 2860, offset(bytes): 0x1c0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2879, offset: 0x1b2e] + | | | | +- [NamePath, table: 0, index: 2880, offset: 0x1b30] -> [namepath: "_STA"] + | | | | +- [BytePrefix, table: 0, index: 2881, offset: 0x1b34] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2882, offset: 0x1b35] + | | | | +- [Return, table: 0, index: 2883, offset: 0x1b35] + | | | | +- [ResolvedNamePath, table: 0, index: 2884, offset: 0x1b36] -> [resolved to "BSTA", table: 0, index: 2877, offset: 0x1b24] + | | | +- [Name, name: "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | +- [NamePath, table: 0, index: 2886, offset: 0x1b3b] -> [namepath: "PBIF"] + | | | | +- [Package, table: 0, index: 2887, offset: 0x1b3f] + | | | | +- [BytePrefix, table: 0, index: 2888, offset: 0x1b41] -> [num value; dec: 13, hex: 0xd] + | | | | +- [ScopeBlock, table: 0, index: 2889, offset: 0x1b42] + | | | | +- [One, table: 0, index: 2890, offset: 0x1b42] + | | | | +- [DwordPrefix, table: 0, index: 2891, offset: 0x1b43] -> [num value; dec: 2147483647, hex: 0x7fffffff] + | | | | +- [DwordPrefix, table: 0, index: 2892, offset: 0x1b48] -> [num value; dec: 2147483647, hex: 0x7fffffff] + | | | | +- [Zero, table: 0, index: 2893, offset: 0x1b4d] + | | | | +- [DwordPrefix, table: 0, index: 2894, offset: 0x1b4e] -> [num value; dec: 4294967295, hex: 0xffffffff] + | | | | +- [Zero, table: 0, index: 2895, offset: 0x1b53] + | | | | +- [Zero, table: 0, index: 2896, offset: 0x1b54] + | | | | +- [BytePrefix, table: 0, index: 2897, offset: 0x1b55] -> [num value; dec: 4, hex: 0x4] + | | | | +- [BytePrefix, table: 0, index: 2898, offset: 0x1b57] -> [num value; dec: 4, hex: 0x4] + | | | | +- [StringPrefix, table: 0, index: 2899, offset: 0x1b59] -> [string value: "1"] + | | | | +- [StringPrefix, table: 0, index: 2900, offset: 0x1b5c] -> [string value: "0"] + | | | | +- [StringPrefix, table: 0, index: 2901, offset: 0x1b5f] -> [string value: "VBOX"] + | | | | +- [StringPrefix, table: 0, index: 2902, offset: 0x1b65] -> [string value: "innotek"] + | | | +- [Name, name: "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | | | +- [NamePath, table: 0, index: 2904, offset: 0x1b6f] -> [namepath: "PBST"] + | | | | +- [Package, table: 0, index: 2905, offset: 0x1b73] + | | | | +- [BytePrefix, table: 0, index: 2906, offset: 0x1b75] -> [num value; dec: 4, hex: 0x4] + | | | | +- [ScopeBlock, table: 0, index: 2907, offset: 0x1b76] + | | | | +- [Zero, table: 0, index: 2908, offset: 0x1b76] + | | | | +- [DwordPrefix, table: 0, index: 2909, offset: 0x1b77] -> [num value; dec: 2147483647, hex: 0x7fffffff] + | | | | +- [DwordPrefix, table: 0, index: 2910, offset: 0x1b7c] -> [num value; dec: 2147483647, hex: 0x7fffffff] + | | | | +- [DwordPrefix, table: 0, index: 2911, offset: 0x1b81] -> [num value; dec: 2147483647, hex: 0x7fffffff] + | | | +- [Method, name: "_BIF", argCount: 0, table: 0, index: 2912, offset: 0x1b86] + | | | | +- [NamePath, table: 0, index: 2913, offset: 0x1b89] -> [namepath: "_BIF"] + | | | | +- [BytePrefix, table: 0, index: 2914, offset: 0x1b8d] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2915, offset: 0x1b8e] + | | | | +- [Store, table: 0, index: 2916, offset: 0x1b8e] + | | | | | +- [ResolvedNamePath, table: 0, index: 2917, offset: 0x1b8f] -> [resolved to "UNIT", table: 0, index: 2868, offset: 0x1af7] + | | | | | +- [Index, table: 0, index: 2918, offset: 0x1b93] + | | | | | +- [ResolvedNamePath, table: 0, index: 2919, offset: 0x1b94] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [Zero, table: 0, index: 2920, offset: 0x1b98] + | | | | | +- [Zero, table: 0, index: 2921, offset: 0x1b99] + | | | | +- [Store, table: 0, index: 2922, offset: 0x1b9a] + | | | | | +- [ResolvedNamePath, table: 0, index: 2923, offset: 0x1b9b] -> [resolved to "DCAP", table: 0, index: 2869, offset: 0x1afc] + | | | | | +- [Index, table: 0, index: 2924, offset: 0x1b9f] + | | | | | +- [ResolvedNamePath, table: 0, index: 2925, offset: 0x1ba0] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [One, table: 0, index: 2926, offset: 0x1ba4] + | | | | | +- [Zero, table: 0, index: 2927, offset: 0x1ba5] + | | | | +- [Store, table: 0, index: 2928, offset: 0x1ba6] + | | | | | +- [ResolvedNamePath, table: 0, index: 2929, offset: 0x1ba7] -> [resolved to "LFCP", table: 0, index: 2870, offset: 0x1b01] + | | | | | +- [Index, table: 0, index: 2930, offset: 0x1bab] + | | | | | +- [ResolvedNamePath, table: 0, index: 2931, offset: 0x1bac] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2932, offset: 0x1bb0] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [Zero, table: 0, index: 2933, offset: 0x1bb2] + | | | | +- [Store, table: 0, index: 2934, offset: 0x1bb3] + | | | | | +- [ResolvedNamePath, table: 0, index: 2935, offset: 0x1bb4] -> [resolved to "BTEC", table: 0, index: 2871, offset: 0x1b06] + | | | | | +- [Index, table: 0, index: 2936, offset: 0x1bb8] + | | | | | +- [ResolvedNamePath, table: 0, index: 2937, offset: 0x1bb9] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2938, offset: 0x1bbd] -> [num value; dec: 3, hex: 0x3] + | | | | | +- [Zero, table: 0, index: 2939, offset: 0x1bbf] + | | | | +- [Store, table: 0, index: 2940, offset: 0x1bc0] + | | | | | +- [ResolvedNamePath, table: 0, index: 2941, offset: 0x1bc1] -> [resolved to "DVOL", table: 0, index: 2872, offset: 0x1b0b] + | | | | | +- [Index, table: 0, index: 2942, offset: 0x1bc5] + | | | | | +- [ResolvedNamePath, table: 0, index: 2943, offset: 0x1bc6] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2944, offset: 0x1bca] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [Zero, table: 0, index: 2945, offset: 0x1bcc] + | | | | +- [Store, table: 0, index: 2946, offset: 0x1bcd] + | | | | | +- [ResolvedNamePath, table: 0, index: 2947, offset: 0x1bce] -> [resolved to "DWRN", table: 0, index: 2873, offset: 0x1b10] + | | | | | +- [Index, table: 0, index: 2948, offset: 0x1bd2] + | | | | | +- [ResolvedNamePath, table: 0, index: 2949, offset: 0x1bd3] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2950, offset: 0x1bd7] -> [num value; dec: 5, hex: 0x5] + | | | | | +- [Zero, table: 0, index: 2951, offset: 0x1bd9] + | | | | +- [Store, table: 0, index: 2952, offset: 0x1bda] + | | | | | +- [ResolvedNamePath, table: 0, index: 2953, offset: 0x1bdb] -> [resolved to "DLOW", table: 0, index: 2874, offset: 0x1b15] + | | | | | +- [Index, table: 0, index: 2954, offset: 0x1bdf] + | | | | | +- [ResolvedNamePath, table: 0, index: 2955, offset: 0x1be0] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2956, offset: 0x1be4] -> [num value; dec: 6, hex: 0x6] + | | | | | +- [Zero, table: 0, index: 2957, offset: 0x1be6] + | | | | +- [Store, table: 0, index: 2958, offset: 0x1be7] + | | | | | +- [ResolvedNamePath, table: 0, index: 2959, offset: 0x1be8] -> [resolved to "GRN1", table: 0, index: 2875, offset: 0x1b1a] + | | | | | +- [Index, table: 0, index: 2960, offset: 0x1bec] + | | | | | +- [ResolvedNamePath, table: 0, index: 2961, offset: 0x1bed] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2962, offset: 0x1bf1] -> [num value; dec: 7, hex: 0x7] + | | | | | +- [Zero, table: 0, index: 2963, offset: 0x1bf3] + | | | | +- [Store, table: 0, index: 2964, offset: 0x1bf4] + | | | | | +- [ResolvedNamePath, table: 0, index: 2965, offset: 0x1bf5] -> [resolved to "GRN2", table: 0, index: 2876, offset: 0x1b1f] + | | | | | +- [Index, table: 0, index: 2966, offset: 0x1bf9] + | | | | | +- [ResolvedNamePath, table: 0, index: 2967, offset: 0x1bfa] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2968, offset: 0x1bfe] -> [num value; dec: 8, hex: 0x8] + | | | | | +- [Zero, table: 0, index: 2969, offset: 0x1c00] + | | | | +- [MethodCall, table: 0, index: 2970, offset: 0x1c01] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | | +- [StringPrefix, table: 0, index: 2971, offset: 0x1c05] -> [string value: "_BIF: +"] + | | | | +- [MethodCall, table: 0, index: 2972, offset: 0x1c0d] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 2973, offset: 0x1c11] + | | | | | +- [Index, table: 0, index: 2974, offset: 0x1c12] + | | | | | +- [ResolvedNamePath, table: 0, index: 2975, offset: 0x1c13] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [Zero, table: 0, index: 2976, offset: 0x1c17] + | | | | | +- [Zero, table: 0, index: 2977, offset: 0x1c18] + | | | | +- [MethodCall, table: 0, index: 2978, offset: 0x1c19] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 2979, offset: 0x1c1d] + | | | | | +- [Index, table: 0, index: 2980, offset: 0x1c1e] + | | | | | +- [ResolvedNamePath, table: 0, index: 2981, offset: 0x1c1f] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [One, table: 0, index: 2982, offset: 0x1c23] + | | | | | +- [Zero, table: 0, index: 2983, offset: 0x1c24] + | | | | +- [MethodCall, table: 0, index: 2984, offset: 0x1c25] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 2985, offset: 0x1c29] + | | | | | +- [Index, table: 0, index: 2986, offset: 0x1c2a] + | | | | | +- [ResolvedNamePath, table: 0, index: 2987, offset: 0x1c2b] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2988, offset: 0x1c2f] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [Zero, table: 0, index: 2989, offset: 0x1c31] + | | | | +- [MethodCall, table: 0, index: 2990, offset: 0x1c32] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 2991, offset: 0x1c36] + | | | | | +- [Index, table: 0, index: 2992, offset: 0x1c37] + | | | | | +- [ResolvedNamePath, table: 0, index: 2993, offset: 0x1c38] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2994, offset: 0x1c3c] -> [num value; dec: 3, hex: 0x3] + | | | | | +- [Zero, table: 0, index: 2995, offset: 0x1c3e] + | | | | +- [MethodCall, table: 0, index: 2996, offset: 0x1c3f] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 2997, offset: 0x1c43] + | | | | | +- [Index, table: 0, index: 2998, offset: 0x1c44] + | | | | | +- [ResolvedNamePath, table: 0, index: 2999, offset: 0x1c45] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 3000, offset: 0x1c49] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [Zero, table: 0, index: 3001, offset: 0x1c4b] + | | | | +- [MethodCall, table: 0, index: 3002, offset: 0x1c4c] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 3003, offset: 0x1c50] + | | | | | +- [Index, table: 0, index: 3004, offset: 0x1c51] + | | | | | +- [ResolvedNamePath, table: 0, index: 3005, offset: 0x1c52] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 3006, offset: 0x1c56] -> [num value; dec: 5, hex: 0x5] + | | | | | +- [Zero, table: 0, index: 3007, offset: 0x1c58] + | | | | +- [MethodCall, table: 0, index: 3008, offset: 0x1c59] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 3009, offset: 0x1c5d] + | | | | | +- [Index, table: 0, index: 3010, offset: 0x1c5e] + | | | | | +- [ResolvedNamePath, table: 0, index: 3011, offset: 0x1c5f] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 3012, offset: 0x1c63] -> [num value; dec: 6, hex: 0x6] + | | | | | +- [Zero, table: 0, index: 3013, offset: 0x1c65] + | | | | +- [MethodCall, table: 0, index: 3014, offset: 0x1c66] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 3015, offset: 0x1c6a] + | | | | | +- [Index, table: 0, index: 3016, offset: 0x1c6b] + | | | | | +- [ResolvedNamePath, table: 0, index: 3017, offset: 0x1c6c] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 3018, offset: 0x1c70] -> [num value; dec: 7, hex: 0x7] + | | | | | +- [Zero, table: 0, index: 3019, offset: 0x1c72] + | | | | +- [MethodCall, table: 0, index: 3020, offset: 0x1c73] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 3021, offset: 0x1c77] + | | | | | +- [Index, table: 0, index: 3022, offset: 0x1c78] + | | | | | +- [ResolvedNamePath, table: 0, index: 3023, offset: 0x1c79] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 3024, offset: 0x1c7d] -> [num value; dec: 8, hex: 0x8] + | | | | | +- [Zero, table: 0, index: 3025, offset: 0x1c7f] + | | | | +- [Return, table: 0, index: 3026, offset: 0x1c80] + | | | | +- [ResolvedNamePath, table: 0, index: 3027, offset: 0x1c81] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | +- [Method, name: "_BST", argCount: 0, table: 0, index: 3028, offset: 0x1c85] + | | | +- [NamePath, table: 0, index: 3029, offset: 0x1c87] -> [namepath: "_BST"] + | | | +- [BytePrefix, table: 0, index: 3030, offset: 0x1c8b] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3031, offset: 0x1c8c] + | | | +- [Store, table: 0, index: 3032, offset: 0x1c8c] + | | | | +- [ResolvedNamePath, table: 0, index: 3033, offset: 0x1c8d] -> [resolved to "STAT", table: 0, index: 2864, offset: 0x1ae3] + | | | | +- [Index, table: 0, index: 3034, offset: 0x1c91] + | | | | +- [ResolvedNamePath, table: 0, index: 3035, offset: 0x1c92] -> [resolved to "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | | | +- [Zero, table: 0, index: 3036, offset: 0x1c96] + | | | | +- [Zero, table: 0, index: 3037, offset: 0x1c97] + | | | +- [Store, table: 0, index: 3038, offset: 0x1c98] + | | | | +- [ResolvedNamePath, table: 0, index: 3039, offset: 0x1c99] -> [resolved to "PRAT", table: 0, index: 2865, offset: 0x1ae8] + | | | | +- [Index, table: 0, index: 3040, offset: 0x1c9d] + | | | | +- [ResolvedNamePath, table: 0, index: 3041, offset: 0x1c9e] -> [resolved to "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | | | +- [One, table: 0, index: 3042, offset: 0x1ca2] + | | | | +- [Zero, table: 0, index: 3043, offset: 0x1ca3] + | | | +- [Store, table: 0, index: 3044, offset: 0x1ca4] + | | | | +- [ResolvedNamePath, table: 0, index: 3045, offset: 0x1ca5] -> [resolved to "RCAP", table: 0, index: 2866, offset: 0x1aed] + | | | | +- [Index, table: 0, index: 3046, offset: 0x1ca9] + | | | | +- [ResolvedNamePath, table: 0, index: 3047, offset: 0x1caa] -> [resolved to "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | | | +- [BytePrefix, table: 0, index: 3048, offset: 0x1cae] -> [num value; dec: 2, hex: 0x2] + | | | | +- [Zero, table: 0, index: 3049, offset: 0x1cb0] + | | | +- [Store, table: 0, index: 3050, offset: 0x1cb1] + | | | | +- [ResolvedNamePath, table: 0, index: 3051, offset: 0x1cb2] -> [resolved to "PVOL", table: 0, index: 2867, offset: 0x1af2] + | | | | +- [Index, table: 0, index: 3052, offset: 0x1cb6] + | | | | +- [ResolvedNamePath, table: 0, index: 3053, offset: 0x1cb7] -> [resolved to "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | | | +- [BytePrefix, table: 0, index: 3054, offset: 0x1cbb] -> [num value; dec: 3, hex: 0x3] + | | | | +- [Zero, table: 0, index: 3055, offset: 0x1cbd] + | | | +- [Return, table: 0, index: 3056, offset: 0x1cbe] + | | | +- [ResolvedNamePath, table: 0, index: 3057, offset: 0x1cbf] -> [resolved to "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | +- [Device, name: "AC__", table: 0, index: 3058, offset: 0x1cc3] + | | | +- [NamePath, table: 0, index: 3059, offset: 0x1cc7] -> [namepath: "AC__"] + | | | +- [ScopeBlock, table: 0, index: 3060, offset: 0x1ccb] + | | | +- [Name, name: "_HID", table: 0, index: 3061, offset: 0x1ccb] + | | | | +- [NamePath, table: 0, index: 3062, offset: 0x1ccc] -> [namepath: "_HID"] + | | | | +- [StringPrefix, table: 0, index: 3063, offset: 0x1cd0] -> [string value: "ACPI0003"] + | | | +- [Name, name: "_UID", table: 0, index: 3064, offset: 0x1cda] + | | | | +- [NamePath, table: 0, index: 3065, offset: 0x1cdb] -> [namepath: "_UID"] + | | | | +- [Zero, table: 0, index: 3066, offset: 0x1cdf] + | | | +- [Name, name: "_PCL", table: 0, index: 3067, offset: 0x1ce0] + | | | | +- [NamePath, table: 0, index: 3068, offset: 0x1ce1] -> [namepath: "_PCL"] + | | | | +- [Package, table: 0, index: 3069, offset: 0x1ce5] + | | | | +- [BytePrefix, table: 0, index: 3070, offset: 0x1ce7] -> [num value; dec: 1, hex: 0x1] + | | | | +- [ScopeBlock, table: 0, index: 3071, offset: 0x1ce8] + | | | | +- [ResolvedNamePath, table: 0, index: 3072, offset: 0x1ce8] -> [resolved to "_SB_", table: 42, index: 3, offset: 0x0] + | | | +- [Method, name: "_PSR", argCount: 0, table: 0, index: 3073, offset: 0x1cec] + | | | | +- [NamePath, table: 0, index: 3074, offset: 0x1cee] -> [namepath: "_PSR"] + | | | | +- [BytePrefix, table: 0, index: 3075, offset: 0x1cf2] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 3076, offset: 0x1cf3] + | | | | +- [Return, table: 0, index: 3077, offset: 0x1cf3] + | | | | +- [NamePath, table: 0, index: 3078, offset: 0x1cf4] -> [namepath: "^^.BAT0APSR"] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 3079, offset: 0x1cff] + | | | +- [NamePath, table: 0, index: 3080, offset: 0x1d01] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 3081, offset: 0x1d05] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3082, offset: 0x1d06] + | | | +- [Return, table: 0, index: 3083, offset: 0x1d06] + | | | +- [BytePrefix, table: 0, index: 3084, offset: 0x1d07] -> [num value; dec: 15, hex: 0xf] + | | +- [Name, name: "CRS_", table: 0, index: 3091, offset: 0x1d17] + | | | +- [NamePath, table: 0, index: 3092, offset: 0x1d18] -> [namepath: "CRS_"] + | | | +- [Buffer, table: 0, index: 3093, offset: 0x1d1c] + | | | +- [BytePrefix, table: 0, index: 3525, offset: 0x1d1f] -> [num value; dec: 110, hex: 0x6e] + | | | +- [ByteList, table: 0, index: 3526, offset: 0x0] -> [bytelist value; len: 110; data: [0x88, 0xd, 0x0, 0x2, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0xf8, 0xc, 0xf8, 0xc, 0x1, 0x8, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x87, 0x17, 0x0, 0x0, 0x8, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0]] + | | +- [Name, name: "TOM_", table: 0, index: 3094, offset: 0x1d8f] + | | | +- [NamePath, table: 0, index: 3095, offset: 0x1d90] -> [namepath: "TOM_"] + | | | +- [Buffer, table: 0, index: 3096, offset: 0x1d94] + | | | +- [BytePrefix, table: 0, index: 3527, offset: 0x1d96] -> [num value; dec: 48, hex: 0x30] + | | | +- [ByteList, table: 0, index: 3528, offset: 0x0] -> [bytelist value; len: 48; data: [0x8a, 0x2b, 0x0, 0x0, 0xc, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x0, 0x0, 0x0, 0x79, 0x0]] + | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 3097, offset: 0x1dc8] + | | +- [NamePath, table: 0, index: 3098, offset: 0x1dcb] -> [namepath: "_CRS"] + | | +- [BytePrefix, table: 0, index: 3099, offset: 0x1dcf] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 3100, offset: 0x1dd0] + | | +- [CreateDWordField, table: 0, index: 3101, offset: 0x1dd0] + | | | +- [ResolvedNamePath, table: 0, index: 3102, offset: 0x1dd1] -> [resolved to "CRS_", table: 0, index: 3091, offset: 0x1d17] + | | | +- [BytePrefix, table: 0, index: 3103, offset: 0x1dd5] -> [num value; dec: 92, hex: 0x5c] + | | | +- [NamePath, table: 0, index: 3104, offset: 0x1dd7] -> [namepath: "RAMT"] + | | +- [CreateDWordField, table: 0, index: 3105, offset: 0x1ddb] + | | | +- [ResolvedNamePath, table: 0, index: 3106, offset: 0x1ddc] -> [resolved to "CRS_", table: 0, index: 3091, offset: 0x1d17] + | | | +- [BytePrefix, table: 0, index: 3107, offset: 0x1de0] -> [num value; dec: 104, hex: 0x68] + | | | +- [NamePath, table: 0, index: 3108, offset: 0x1de2] -> [namepath: "RAMR"] + | | +- [Store, table: 0, index: 3109, offset: 0x1de6] + | | | +- [ResolvedNamePath, table: 0, index: 3110, offset: 0x1de7] -> [resolved to "MEML", table: 0, index: 333, offset: 0x41a] + | | | +- [NamePath, table: 0, index: 3111, offset: 0x1deb] -> [namepath: "RAMT"] + | | +- [Subtract, table: 0, index: 3112, offset: 0x1def] + | | | +- [DwordPrefix, table: 0, index: 3113, offset: 0x1df0] -> [num value; dec: 4292870144, hex: 0xffe00000] + | | | +- [NamePath, table: 0, index: 3114, offset: 0x1df5] -> [namepath: "RAMT"] + | | | +- [NamePath, table: 0, index: 3115, offset: 0x1df9] -> [namepath: "RAMR"] + | | +- [If, table: 0, index: 3116, offset: 0x1dfd] + | | | +- [Lnot, table: 0, index: 3117, offset: 0x1e00] + | | | | +- [LEqual, table: 0, index: 3118, offset: 0x1e01] + | | | | +- [ResolvedNamePath, table: 0, index: 3119, offset: 0x1e02] -> [resolved to "PMNN", table: 0, index: 342, offset: 0x447] + | | | | +- [Zero, table: 0, index: 3120, offset: 0x1e06] + | | | +- [If, table: 0, index: 3121, offset: 0x1e07] + | | | +- [Lor, table: 0, index: 3122, offset: 0x1e0a] + | | | | +- [LLess, table: 0, index: 3123, offset: 0x1e0b] + | | | | | +- [MethodCall, table: 0, index: 3124, offset: 0x1e0c] -> [call to "MSWN", argCount: 0, table: 0, index: 184, offset: 0x185] + | | | | | +- [One, table: 0, index: 3125, offset: 0x1e10] + | | | | +- [LGreater, table: 0, index: 3126, offset: 0x1e11] + | | | | +- [MethodCall, table: 0, index: 3127, offset: 0x1e12] -> [call to "MSWN", argCount: 0, table: 0, index: 184, offset: 0x185] + | | | | +- [BytePrefix, table: 0, index: 3128, offset: 0x1e16] -> [num value; dec: 6, hex: 0x6] + | | | +- [CreateQWordField, table: 0, index: 3129, offset: 0x1e18] + | | | +- [ResolvedNamePath, table: 0, index: 3130, offset: 0x1e19] -> [resolved to "TOM_", table: 0, index: 3094, offset: 0x1d8f] + | | | +- [BytePrefix, table: 0, index: 3131, offset: 0x1e1d] -> [num value; dec: 14, hex: 0xe] + | | | +- [NamePath, table: 0, index: 3132, offset: 0x1e1f] -> [namepath: "TM4N"] + | | +- [CreateQWordField, table: 0, index: 3133, offset: 0x1e23] + | | | +- [ResolvedNamePath, table: 0, index: 3134, offset: 0x1e24] -> [resolved to "TOM_", table: 0, index: 3094, offset: 0x1d8f] + | | | +- [BytePrefix, table: 0, index: 3135, offset: 0x1e28] -> [num value; dec: 22, hex: 0x16] + | | | +- [NamePath, table: 0, index: 3136, offset: 0x1e2a] -> [namepath: "TM4X"] + | | +- [CreateQWordField, table: 0, index: 3137, offset: 0x1e2e] + | | | +- [ResolvedNamePath, table: 0, index: 3138, offset: 0x1e2f] -> [resolved to "TOM_", table: 0, index: 3094, offset: 0x1d8f] + | | | +- [BytePrefix, table: 0, index: 3139, offset: 0x1e33] -> [num value; dec: 38, hex: 0x26] + | | | +- [NamePath, table: 0, index: 3140, offset: 0x1e35] -> [namepath: "TM4L"] + | | +- [Multiply, table: 0, index: 3141, offset: 0x1e39] + | | | +- [ResolvedNamePath, table: 0, index: 3142, offset: 0x1e3a] -> [resolved to "PMNN", table: 0, index: 342, offset: 0x447] + | | | +- [DwordPrefix, table: 0, index: 3143, offset: 0x1e3e] -> [num value; dec: 65536, hex: 0x10000] + | | | +- [NamePath, table: 0, index: 3144, offset: 0x1e43] -> [namepath: "TM4N"] + | | +- [Subtract, table: 0, index: 3145, offset: 0x1e47] + | | | +- [Multiply, table: 0, index: 3146, offset: 0x1e48] + | | | | +- [ResolvedNamePath, table: 0, index: 3147, offset: 0x1e49] -> [resolved to "PMNX", table: 0, index: 363, offset: 0x4b0] + | | | | +- [DwordPrefix, table: 0, index: 3148, offset: 0x1e4d] -> [num value; dec: 65536, hex: 0x10000] + | | | | +- [Zero, table: 0, index: 3149, offset: 0x1e52] + | | | +- [One, table: 0, index: 3150, offset: 0x1e53] + | | | +- [NamePath, table: 0, index: 3151, offset: 0x1e54] -> [namepath: "TM4X"] + | | +- [Add, table: 0, index: 3152, offset: 0x1e58] + | | | +- [Subtract, table: 0, index: 3153, offset: 0x1e59] + | | | | +- [NamePath, table: 0, index: 3154, offset: 0x1e5a] -> [namepath: "TM4X"] + | | | | +- [NamePath, table: 0, index: 3155, offset: 0x1e5e] -> [namepath: "TM4N"] + | | | | +- [Zero, table: 0, index: 3156, offset: 0x1e62] + | | | +- [One, table: 0, index: 3157, offset: 0x1e63] + | | | +- [NamePath, table: 0, index: 3158, offset: 0x1e64] -> [namepath: "TM4L"] + | | +- [ConcatRes, table: 0, index: 3159, offset: 0x1e68] + | | | +- [ResolvedNamePath, table: 0, index: 3160, offset: 0x1e69] -> [resolved to "CRS_", table: 0, index: 3091, offset: 0x1d17] + | | | +- [ResolvedNamePath, table: 0, index: 3161, offset: 0x1e6d] -> [resolved to "TOM_", table: 0, index: 3094, offset: 0x1d8f] + | | | +- [Local2, table: 0, index: 3162, offset: 0x1e71] + | | +- [Return, table: 0, index: 3163, offset: 0x1e72] + | | | +- [Local2, table: 0, index: 3164, offset: 0x1e73] + | | +- [Return, table: 0, index: 3165, offset: 0x1e74] + | | +- [ResolvedNamePath, table: 0, index: 3166, offset: 0x1e75] -> [resolved to "CRS_", table: 0, index: 3091, offset: 0x1d17] + | +- [Field, table: 0, index: 3170, offset: 0x1e80] + | | +- [NamePath, table: 0, index: 3171, offset: 0x1e83] -> [namepath: "/PCI0SBRGPCIC"] + | | +- [BytePrefix, table: 0, index: 3172, offset: 0x1e91] -> [num value; dec: 1, hex: 0x1] + | +- [NamedField, name: "PIRA", table: 0, index: 3173, offset: 0x1e95] -> [field index: 3170, offset(bytes): 0x300, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | +- [NamedField, name: "PIRB", table: 0, index: 3174, offset: 0x1e9a] -> [field index: 3170, offset(bytes): 0x308, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | +- [NamedField, name: "PIRC", table: 0, index: 3175, offset: 0x1e9f] -> [field index: 3170, offset(bytes): 0x310, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | +- [NamedField, name: "PIRD", table: 0, index: 3176, offset: 0x1ea4] -> [field index: 3170, offset(bytes): 0x318, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | +- [Name, name: "BUFA", table: 0, index: 3177, offset: 0x1ea9] + | | +- [NamePath, table: 0, index: 3178, offset: 0x1eaa] -> [namepath: "BUFA"] + | | +- [Buffer, table: 0, index: 3179, offset: 0x1eae] + | | +- [BytePrefix, table: 0, index: 3529, offset: 0x1eb0] -> [num value; dec: 6, hex: 0x6] + | | +- [ByteList, table: 0, index: 3530, offset: 0x0] -> [bytelist value; len: 6; data: [0x23, 0x0, 0x80, 0x18, 0x79, 0x0]] + | +- [CreateWordField, table: 0, index: 3180, offset: 0x1eb8] + | | +- [ResolvedNamePath, table: 0, index: 3181, offset: 0x1eb9] -> [resolved to "BUFA", table: 0, index: 3177, offset: 0x1ea9] + | | +- [One, table: 0, index: 3182, offset: 0x1ebd] + | | +- [NamePath, table: 0, index: 3183, offset: 0x1ebe] -> [namepath: "ICRS"] + | +- [Method, name: "LSTA", argCount: 1, table: 0, index: 3184, offset: 0x1ec2] + | | +- [NamePath, table: 0, index: 3185, offset: 0x1ec4] -> [namepath: "LSTA"] + | | +- [BytePrefix, table: 0, index: 3186, offset: 0x1ec8] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3187, offset: 0x1ec9] + | | +- [And, table: 0, index: 3188, offset: 0x1ec9] + | | | +- [Arg0, table: 0, index: 3189, offset: 0x1eca] + | | | +- [BytePrefix, table: 0, index: 3190, offset: 0x1ecb] -> [num value; dec: 128, hex: 0x80] + | | | +- [Local0, table: 0, index: 3191, offset: 0x1ecd] + | | +- [If, table: 0, index: 3192, offset: 0x1ece] + | | | +- [Local0, table: 0, index: 3193, offset: 0x1ed0] + | | | +- [Return, table: 0, index: 3194, offset: 0x1ed1] + | | | +- [BytePrefix, table: 0, index: 3195, offset: 0x1ed2] -> [num value; dec: 9, hex: 0x9] + | | +- [Else, table: 0, index: 3196, offset: 0x1ed4] + | | +- [ScopeBlock, table: 0, index: 3197, offset: 0x1ed6] + | | +- [Return, table: 0, index: 3198, offset: 0x1ed6] + | | +- [BytePrefix, table: 0, index: 3199, offset: 0x1ed7] -> [num value; dec: 11, hex: 0xb] + | +- [Method, name: "LCRS", argCount: 1, table: 0, index: 3200, offset: 0x1ed9] + | | +- [NamePath, table: 0, index: 3201, offset: 0x1edb] -> [namepath: "LCRS"] + | | +- [BytePrefix, table: 0, index: 3202, offset: 0x1edf] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3203, offset: 0x1ee0] + | | +- [And, table: 0, index: 3204, offset: 0x1ee0] + | | | +- [Arg0, table: 0, index: 3205, offset: 0x1ee1] + | | | +- [BytePrefix, table: 0, index: 3206, offset: 0x1ee2] -> [num value; dec: 15, hex: 0xf] + | | | +- [Local0, table: 0, index: 3207, offset: 0x1ee4] + | | +- [ShiftLeft, table: 0, index: 3208, offset: 0x1ee5] + | | | +- [One, table: 0, index: 3209, offset: 0x1ee6] + | | | +- [Local0, table: 0, index: 3210, offset: 0x1ee7] + | | | +- [NamePath, table: 0, index: 3211, offset: 0x1ee8] -> [namepath: "ICRS"] + | | +- [Return, table: 0, index: 3212, offset: 0x1eec] + | | +- [ResolvedNamePath, table: 0, index: 3213, offset: 0x1eed] -> [resolved to "BUFA", table: 0, index: 3177, offset: 0x1ea9] + | +- [Method, name: "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | +- [NamePath, table: 0, index: 3215, offset: 0x1ef3] -> [namepath: "LSRS"] + | | +- [BytePrefix, table: 0, index: 3216, offset: 0x1ef7] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3217, offset: 0x1ef8] + | | +- [CreateWordField, table: 0, index: 3218, offset: 0x1ef8] + | | | +- [Arg0, table: 0, index: 3219, offset: 0x1ef9] + | | | +- [One, table: 0, index: 3220, offset: 0x1efa] + | | | +- [NamePath, table: 0, index: 3221, offset: 0x1efb] -> [namepath: "ISRS"] + | | +- [FindSetRightBit, table: 0, index: 3222, offset: 0x1eff] + | | | +- [NamePath, table: 0, index: 3223, offset: 0x1f00] -> [namepath: "ISRS"] + | | | +- [Local0, table: 0, index: 3224, offset: 0x1f04] + | | +- [Return, table: 0, index: 3225, offset: 0x1f05] + | | +- [Decrement, table: 0, index: 3226, offset: 0x1f06] + | | +- [Local0, table: 0, index: 3227, offset: 0x1f07] + | +- [Method, name: "LDIS", argCount: 1, table: 0, index: 3228, offset: 0x1f08] + | | +- [NamePath, table: 0, index: 3229, offset: 0x1f0a] -> [namepath: "LDIS"] + | | +- [BytePrefix, table: 0, index: 3230, offset: 0x1f0e] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3231, offset: 0x1f0f] + | | +- [Return, table: 0, index: 3232, offset: 0x1f0f] + | | +- [Or, table: 0, index: 3233, offset: 0x1f10] + | | +- [Arg0, table: 0, index: 3234, offset: 0x1f11] + | | +- [BytePrefix, table: 0, index: 3235, offset: 0x1f12] -> [num value; dec: 128, hex: 0x80] + | | +- [Zero, table: 0, index: 3236, offset: 0x1f14] + | +- [Device, name: "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | +- [NamePath, table: 0, index: 3238, offset: 0x1f19] -> [namepath: "LNKA"] + | | +- [ScopeBlock, table: 0, index: 3239, offset: 0x1f1d] + | | +- [Name, name: "_HID", table: 0, index: 3240, offset: 0x1f1d] + | | | +- [NamePath, table: 0, index: 3241, offset: 0x1f1e] -> [namepath: "_HID"] + | | | +- [DwordPrefix, table: 0, index: 3242, offset: 0x1f22] -> [num value; dec: 252497985, hex: 0xf0cd041] [EISA: "PNP0C0F"] + | | +- [Name, name: "_UID", table: 0, index: 3243, offset: 0x1f27] + | | | +- [NamePath, table: 0, index: 3244, offset: 0x1f28] -> [namepath: "_UID"] + | | | +- [One, table: 0, index: 3245, offset: 0x1f2c] + | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 3246, offset: 0x1f2d] + | | | +- [NamePath, table: 0, index: 3247, offset: 0x1f2f] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 3248, offset: 0x1f33] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3249, offset: 0x1f34] + | | | +- [MethodCall, table: 0, index: 3250, offset: 0x1f34] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 3251, offset: 0x1f38] -> [string value: "LNKA._STA +"] + | | | +- [Return, table: 0, index: 3252, offset: 0x1f44] + | | | +- [MethodCall, table: 0, index: 3253, offset: 0x1f45] -> [call to "LSTA", argCount: 1, table: 0, index: 3184, offset: 0x1ec2] + | | | +- [ResolvedNamePath, table: 0, index: 3254, offset: 0x1f49] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | | +- [Method, name: "_PRS", argCount: 0, table: 0, index: 3255, offset: 0x1f4d] + | | | +- [NamePath, table: 0, index: 3256, offset: 0x1f4f] -> [namepath: "_PRS"] + | | | +- [BytePrefix, table: 0, index: 3257, offset: 0x1f53] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3258, offset: 0x1f54] + | | | +- [MethodCall, table: 0, index: 3259, offset: 0x1f54] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 3260, offset: 0x1f58] -> [string value: "LNKA._PRS +"] + | | | +- [Return, table: 0, index: 3261, offset: 0x1f64] + | | | +- [ResolvedNamePath, table: 0, index: 3262, offset: 0x1f65] -> [resolved to "PRSA", table: 0, index: 2090, offset: 0x1210] + | | +- [Method, name: "_DIS", argCount: 0, table: 0, index: 3263, offset: 0x1f69] + | | | +- [NamePath, table: 0, index: 3264, offset: 0x1f6b] -> [namepath: "_DIS"] + | | | +- [BytePrefix, table: 0, index: 3265, offset: 0x1f6f] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3266, offset: 0x1f70] + | | | +- [MethodCall, table: 0, index: 3267, offset: 0x1f70] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 3268, offset: 0x1f74] -> [string value: "LNKA._DIS +"] + | | | +- [Store, table: 0, index: 3269, offset: 0x1f80] + | | | +- [MethodCall, table: 0, index: 3270, offset: 0x1f81] -> [call to "LDIS", argCount: 1, table: 0, index: 3228, offset: 0x1f08] + | | | | +- [ResolvedNamePath, table: 0, index: 3271, offset: 0x1f85] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | | | +- [ResolvedNamePath, table: 0, index: 3272, offset: 0x1f89] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 3273, offset: 0x1f8d] + | | | +- [NamePath, table: 0, index: 3274, offset: 0x1f8f] -> [namepath: "_CRS"] + | | | +- [BytePrefix, table: 0, index: 3275, offset: 0x1f93] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3276, offset: 0x1f94] + | | | +- [MethodCall, table: 0, index: 3277, offset: 0x1f94] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 3278, offset: 0x1f98] -> [string value: "LNKA._CRS +"] + | | | +- [Return, table: 0, index: 3279, offset: 0x1fa4] + | | | +- [MethodCall, table: 0, index: 3280, offset: 0x1fa5] -> [call to "LCRS", argCount: 1, table: 0, index: 3200, offset: 0x1ed9] + | | | +- [ResolvedNamePath, table: 0, index: 3281, offset: 0x1fa9] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | | +- [Method, name: "_SRS", argCount: 1, table: 0, index: 3282, offset: 0x1fad] + | | +- [NamePath, table: 0, index: 3283, offset: 0x1faf] -> [namepath: "_SRS"] + | | +- [BytePrefix, table: 0, index: 3284, offset: 0x1fb3] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3285, offset: 0x1fb4] + | | +- [MethodCall, table: 0, index: 3286, offset: 0x1fb4] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 3287, offset: 0x1fb8] -> [string value: "LNKA._SRS: "] + | | +- [MethodCall, table: 0, index: 3288, offset: 0x1fc5] -> [call to "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + | | | +- [MethodCall, table: 0, index: 3289, offset: 0x1fc9] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3290, offset: 0x1fcd] + | | +- [Store, table: 0, index: 3291, offset: 0x1fce] + | | +- [MethodCall, table: 0, index: 3292, offset: 0x1fcf] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3293, offset: 0x1fd3] + | | +- [ResolvedNamePath, table: 0, index: 3294, offset: 0x1fd4] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | +- [Device, name: "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | +- [NamePath, table: 0, index: 3296, offset: 0x1fdc] -> [namepath: "LNKB"] + | | +- [ScopeBlock, table: 0, index: 3297, offset: 0x1fe0] + | | +- [Name, name: "_HID", table: 0, index: 3298, offset: 0x1fe0] + | | | +- [NamePath, table: 0, index: 3299, offset: 0x1fe1] -> [namepath: "_HID"] + | | | +- [DwordPrefix, table: 0, index: 3300, offset: 0x1fe5] -> [num value; dec: 252497985, hex: 0xf0cd041] [EISA: "PNP0C0F"] + | | +- [Name, name: "_UID", table: 0, index: 3301, offset: 0x1fea] + | | | +- [NamePath, table: 0, index: 3302, offset: 0x1feb] -> [namepath: "_UID"] + | | | +- [BytePrefix, table: 0, index: 3303, offset: 0x1fef] -> [num value; dec: 2, hex: 0x2] + | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 3304, offset: 0x1ff1] + | | | +- [NamePath, table: 0, index: 3305, offset: 0x1ff3] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 3306, offset: 0x1ff7] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3307, offset: 0x1ff8] + | | | +- [Return, table: 0, index: 3308, offset: 0x1ff8] + | | | +- [MethodCall, table: 0, index: 3309, offset: 0x1ff9] -> [call to "LSTA", argCount: 1, table: 0, index: 3184, offset: 0x1ec2] + | | | +- [ResolvedNamePath, table: 0, index: 3310, offset: 0x1ffd] -> [resolved to "PIRB", table: 0, index: 3174, offset: 0x1e9a] + | | +- [Method, name: "_PRS", argCount: 0, table: 0, index: 3311, offset: 0x2001] + | | | +- [NamePath, table: 0, index: 3312, offset: 0x2003] -> [namepath: "_PRS"] + | | | +- [BytePrefix, table: 0, index: 3313, offset: 0x2007] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3314, offset: 0x2008] + | | | +- [Return, table: 0, index: 3315, offset: 0x2008] + | | | +- [ResolvedNamePath, table: 0, index: 3316, offset: 0x2009] -> [resolved to "PRSB", table: 0, index: 2093, offset: 0x121f] + | | +- [Method, name: "_DIS", argCount: 0, table: 0, index: 3317, offset: 0x200d] + | | | +- [NamePath, table: 0, index: 3318, offset: 0x200f] -> [namepath: "_DIS"] + | | | +- [BytePrefix, table: 0, index: 3319, offset: 0x2013] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3320, offset: 0x2014] + | | | +- [Store, table: 0, index: 3321, offset: 0x2014] + | | | +- [MethodCall, table: 0, index: 3322, offset: 0x2015] -> [call to "LDIS", argCount: 1, table: 0, index: 3228, offset: 0x1f08] + | | | | +- [ResolvedNamePath, table: 0, index: 3323, offset: 0x2019] -> [resolved to "PIRB", table: 0, index: 3174, offset: 0x1e9a] + | | | +- [ResolvedNamePath, table: 0, index: 3324, offset: 0x201d] -> [resolved to "PIRB", table: 0, index: 3174, offset: 0x1e9a] + | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 3325, offset: 0x2021] + | | | +- [NamePath, table: 0, index: 3326, offset: 0x2023] -> [namepath: "_CRS"] + | | | +- [BytePrefix, table: 0, index: 3327, offset: 0x2027] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3328, offset: 0x2028] + | | | +- [Return, table: 0, index: 3329, offset: 0x2028] + | | | +- [MethodCall, table: 0, index: 3330, offset: 0x2029] -> [call to "LCRS", argCount: 1, table: 0, index: 3200, offset: 0x1ed9] + | | | +- [ResolvedNamePath, table: 0, index: 3331, offset: 0x202d] -> [resolved to "PIRB", table: 0, index: 3174, offset: 0x1e9a] + | | +- [Method, name: "_SRS", argCount: 1, table: 0, index: 3332, offset: 0x2031] + | | +- [NamePath, table: 0, index: 3333, offset: 0x2033] -> [namepath: "_SRS"] + | | +- [BytePrefix, table: 0, index: 3334, offset: 0x2037] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3335, offset: 0x2038] + | | +- [MethodCall, table: 0, index: 3336, offset: 0x2038] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 3337, offset: 0x203c] -> [string value: "LNKB._SRS: "] + | | +- [MethodCall, table: 0, index: 3338, offset: 0x2049] -> [call to "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + | | | +- [MethodCall, table: 0, index: 3339, offset: 0x204d] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3340, offset: 0x2051] + | | +- [Store, table: 0, index: 3341, offset: 0x2052] + | | +- [MethodCall, table: 0, index: 3342, offset: 0x2053] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3343, offset: 0x2057] + | | +- [ResolvedNamePath, table: 0, index: 3344, offset: 0x2058] -> [resolved to "PIRB", table: 0, index: 3174, offset: 0x1e9a] + | +- [Device, name: "LNKC", table: 0, index: 3345, offset: 0x205c] + | | +- [NamePath, table: 0, index: 3346, offset: 0x2060] -> [namepath: "LNKC"] + | | +- [ScopeBlock, table: 0, index: 3347, offset: 0x2064] + | | +- [Name, name: "_HID", table: 0, index: 3348, offset: 0x2064] + | | | +- [NamePath, table: 0, index: 3349, offset: 0x2065] -> [namepath: "_HID"] + | | | +- [DwordPrefix, table: 0, index: 3350, offset: 0x2069] -> [num value; dec: 252497985, hex: 0xf0cd041] [EISA: "PNP0C0F"] + | | +- [Name, name: "_UID", table: 0, index: 3351, offset: 0x206e] + | | | +- [NamePath, table: 0, index: 3352, offset: 0x206f] -> [namepath: "_UID"] + | | | +- [BytePrefix, table: 0, index: 3353, offset: 0x2073] -> [num value; dec: 3, hex: 0x3] + | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 3354, offset: 0x2075] + | | | +- [NamePath, table: 0, index: 3355, offset: 0x2077] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 3356, offset: 0x207b] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3357, offset: 0x207c] + | | | +- [Return, table: 0, index: 3358, offset: 0x207c] + | | | +- [MethodCall, table: 0, index: 3359, offset: 0x207d] -> [call to "LSTA", argCount: 1, table: 0, index: 3184, offset: 0x1ec2] + | | | +- [ResolvedNamePath, table: 0, index: 3360, offset: 0x2081] -> [resolved to "PIRC", table: 0, index: 3175, offset: 0x1e9f] + | | +- [Method, name: "_PRS", argCount: 0, table: 0, index: 3361, offset: 0x2085] + | | | +- [NamePath, table: 0, index: 3362, offset: 0x2087] -> [namepath: "_PRS"] + | | | +- [BytePrefix, table: 0, index: 3363, offset: 0x208b] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3364, offset: 0x208c] + | | | +- [Return, table: 0, index: 3365, offset: 0x208c] + | | | +- [ResolvedNamePath, table: 0, index: 3366, offset: 0x208d] -> [resolved to "PRSC", table: 0, index: 2096, offset: 0x122e] + | | +- [Method, name: "_DIS", argCount: 0, table: 0, index: 3367, offset: 0x2091] + | | | +- [NamePath, table: 0, index: 3368, offset: 0x2093] -> [namepath: "_DIS"] + | | | +- [BytePrefix, table: 0, index: 3369, offset: 0x2097] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3370, offset: 0x2098] + | | | +- [Store, table: 0, index: 3371, offset: 0x2098] + | | | +- [MethodCall, table: 0, index: 3372, offset: 0x2099] -> [call to "LDIS", argCount: 1, table: 0, index: 3228, offset: 0x1f08] + | | | | +- [ResolvedNamePath, table: 0, index: 3373, offset: 0x209d] -> [resolved to "PIRC", table: 0, index: 3175, offset: 0x1e9f] + | | | +- [ResolvedNamePath, table: 0, index: 3374, offset: 0x20a1] -> [resolved to "PIRC", table: 0, index: 3175, offset: 0x1e9f] + | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 3375, offset: 0x20a5] + | | | +- [NamePath, table: 0, index: 3376, offset: 0x20a7] -> [namepath: "_CRS"] + | | | +- [BytePrefix, table: 0, index: 3377, offset: 0x20ab] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3378, offset: 0x20ac] + | | | +- [Return, table: 0, index: 3379, offset: 0x20ac] + | | | +- [MethodCall, table: 0, index: 3380, offset: 0x20ad] -> [call to "LCRS", argCount: 1, table: 0, index: 3200, offset: 0x1ed9] + | | | +- [ResolvedNamePath, table: 0, index: 3381, offset: 0x20b1] -> [resolved to "PIRC", table: 0, index: 3175, offset: 0x1e9f] + | | +- [Method, name: "_SRS", argCount: 1, table: 0, index: 3382, offset: 0x20b5] + | | +- [NamePath, table: 0, index: 3383, offset: 0x20b7] -> [namepath: "_SRS"] + | | +- [BytePrefix, table: 0, index: 3384, offset: 0x20bb] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3385, offset: 0x20bc] + | | +- [MethodCall, table: 0, index: 3386, offset: 0x20bc] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 3387, offset: 0x20c0] -> [string value: "LNKC._SRS: "] + | | +- [MethodCall, table: 0, index: 3388, offset: 0x20cd] -> [call to "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + | | | +- [MethodCall, table: 0, index: 3389, offset: 0x20d1] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3390, offset: 0x20d5] + | | +- [Store, table: 0, index: 3391, offset: 0x20d6] + | | +- [MethodCall, table: 0, index: 3392, offset: 0x20d7] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3393, offset: 0x20db] + | | +- [ResolvedNamePath, table: 0, index: 3394, offset: 0x20dc] -> [resolved to "PIRC", table: 0, index: 3175, offset: 0x1e9f] + | +- [Device, name: "LNKD", table: 0, index: 3395, offset: 0x20e0] + | +- [NamePath, table: 0, index: 3396, offset: 0x20e4] -> [namepath: "LNKD"] + | +- [ScopeBlock, table: 0, index: 3397, offset: 0x20e8] + | +- [Name, name: "_HID", table: 0, index: 3398, offset: 0x20e8] + | | +- [NamePath, table: 0, index: 3399, offset: 0x20e9] -> [namepath: "_HID"] + | | +- [DwordPrefix, table: 0, index: 3400, offset: 0x20ed] -> [num value; dec: 252497985, hex: 0xf0cd041] [EISA: "PNP0C0F"] + | +- [Name, name: "_UID", table: 0, index: 3401, offset: 0x20f2] + | | +- [NamePath, table: 0, index: 3402, offset: 0x20f3] -> [namepath: "_UID"] + | | +- [BytePrefix, table: 0, index: 3403, offset: 0x20f7] -> [num value; dec: 4, hex: 0x4] + | +- [Method, name: "_STA", argCount: 0, table: 0, index: 3404, offset: 0x20f9] + | | +- [NamePath, table: 0, index: 3405, offset: 0x20fb] -> [namepath: "_STA"] + | | +- [BytePrefix, table: 0, index: 3406, offset: 0x20ff] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 3407, offset: 0x2100] + | | +- [Return, table: 0, index: 3408, offset: 0x2100] + | | +- [MethodCall, table: 0, index: 3409, offset: 0x2101] -> [call to "LSTA", argCount: 1, table: 0, index: 3184, offset: 0x1ec2] + | | +- [ResolvedNamePath, table: 0, index: 3410, offset: 0x2105] -> [resolved to "PIRD", table: 0, index: 3176, offset: 0x1ea4] + | +- [Method, name: "_PRS", argCount: 0, table: 0, index: 3411, offset: 0x2109] + | | +- [NamePath, table: 0, index: 3412, offset: 0x210b] -> [namepath: "_PRS"] + | | +- [BytePrefix, table: 0, index: 3413, offset: 0x210f] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 3414, offset: 0x2110] + | | +- [Return, table: 0, index: 3415, offset: 0x2110] + | | +- [ResolvedNamePath, table: 0, index: 3416, offset: 0x2111] -> [resolved to "PRSD", table: 0, index: 2099, offset: 0x123d] + | +- [Method, name: "_DIS", argCount: 0, table: 0, index: 3417, offset: 0x2115] + | | +- [NamePath, table: 0, index: 3418, offset: 0x2117] -> [namepath: "_DIS"] + | | +- [BytePrefix, table: 0, index: 3419, offset: 0x211b] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 3420, offset: 0x211c] + | | +- [Store, table: 0, index: 3421, offset: 0x211c] + | | +- [MethodCall, table: 0, index: 3422, offset: 0x211d] -> [call to "LDIS", argCount: 1, table: 0, index: 3228, offset: 0x1f08] + | | | +- [ResolvedNamePath, table: 0, index: 3423, offset: 0x2121] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | | +- [ResolvedNamePath, table: 0, index: 3424, offset: 0x2125] -> [resolved to "PIRD", table: 0, index: 3176, offset: 0x1ea4] + | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 3425, offset: 0x2129] + | | +- [NamePath, table: 0, index: 3426, offset: 0x212b] -> [namepath: "_CRS"] + | | +- [BytePrefix, table: 0, index: 3427, offset: 0x212f] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 3428, offset: 0x2130] + | | +- [Return, table: 0, index: 3429, offset: 0x2130] + | | +- [MethodCall, table: 0, index: 3430, offset: 0x2131] -> [call to "LCRS", argCount: 1, table: 0, index: 3200, offset: 0x1ed9] + | | +- [ResolvedNamePath, table: 0, index: 3431, offset: 0x2135] -> [resolved to "PIRD", table: 0, index: 3176, offset: 0x1ea4] + | +- [Method, name: "_SRS", argCount: 1, table: 0, index: 3432, offset: 0x2139] + | +- [NamePath, table: 0, index: 3433, offset: 0x213b] -> [namepath: "_SRS"] + | +- [BytePrefix, table: 0, index: 3434, offset: 0x213f] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 3435, offset: 0x2140] + | +- [MethodCall, table: 0, index: 3436, offset: 0x2140] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 3437, offset: 0x2144] -> [string value: "LNKD._SRS: "] + | +- [MethodCall, table: 0, index: 3438, offset: 0x2151] -> [call to "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + | | +- [MethodCall, table: 0, index: 3439, offset: 0x2155] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | +- [Arg0, table: 0, index: 3440, offset: 0x2159] + | +- [Store, table: 0, index: 3441, offset: 0x215a] + | +- [MethodCall, table: 0, index: 3442, offset: 0x215b] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | +- [Arg0, table: 0, index: 3443, offset: 0x215f] + | +- [ResolvedNamePath, table: 0, index: 3444, offset: 0x2160] -> [resolved to "PIRD", table: 0, index: 3176, offset: 0x1ea4] + +- [ScopeBlock, name: "_SI_", table: 42, index: 4, offset: 0x0] + +- [ScopeBlock, name: "_TZ_", table: 42, index: 5, offset: 0x0] + +- [OpRegion, name: "DBG0", table: 0, index: 6, offset: 0x24] + | +- [NamePath, table: 0, index: 7, offset: 0x26] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 8, offset: 0x2a] -> [num value; dec: 1, hex: 0x1] + | +- [WordPrefix, table: 0, index: 9, offset: 0x2b] -> [num value; dec: 12288, hex: 0x3000] + | +- [BytePrefix, table: 0, index: 10, offset: 0x2e] -> [num value; dec: 4, hex: 0x4] + +- [Field, table: 0, index: 11, offset: 0x30] + | +- [NamePath, table: 0, index: 12, offset: 0x33] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 13, offset: 0x37] -> [num value; dec: 1, hex: 0x1] + +- [NamedField, name: "DHE1", table: 0, index: 14, offset: 0x38] -> [field index: 11, offset(bytes): 0x0, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [Field, table: 0, index: 15, offset: 0x3d] + | +- [NamePath, table: 0, index: 16, offset: 0x40] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 17, offset: 0x44] -> [num value; dec: 2, hex: 0x2] + +- [NamedField, name: "DHE2", table: 0, index: 18, offset: 0x45] -> [field index: 15, offset(bytes): 0x0, width(bits): 0x10, accType: Word, lockType: NoLock, updateType: Preserve, connection: -] + +- [Field, table: 0, index: 19, offset: 0x4a] + | +- [NamePath, table: 0, index: 20, offset: 0x4d] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 21, offset: 0x51] -> [num value; dec: 3, hex: 0x3] + +- [NamedField, name: "DHE4", table: 0, index: 22, offset: 0x52] -> [field index: 19, offset(bytes): 0x0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [Field, table: 0, index: 23, offset: 0x57] + | +- [NamePath, table: 0, index: 24, offset: 0x5a] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 25, offset: 0x5e] -> [num value; dec: 1, hex: 0x1] + +- [NamedField, name: "DCHR", table: 0, index: 26, offset: 0x61] -> [field index: 23, offset(bytes): 0x8, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [Method, name: "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + | +- [NamePath, table: 0, index: 28, offset: 0x68] -> [namepath: "HEX_"] + | +- [BytePrefix, table: 0, index: 29, offset: 0x6c] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 30, offset: 0x6d] + | +- [Store, table: 0, index: 31, offset: 0x6d] + | +- [Arg0, table: 0, index: 32, offset: 0x6e] + | +- [ResolvedNamePath, table: 0, index: 33, offset: 0x6f] -> [resolved to "DHE1", table: 0, index: 14, offset: 0x38] + +- [Method, name: "HEX2", argCount: 1, table: 0, index: 34, offset: 0x73] + | +- [NamePath, table: 0, index: 35, offset: 0x75] -> [namepath: "HEX2"] + | +- [BytePrefix, table: 0, index: 36, offset: 0x79] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 37, offset: 0x7a] + | +- [Store, table: 0, index: 38, offset: 0x7a] + | +- [Arg0, table: 0, index: 39, offset: 0x7b] + | +- [ResolvedNamePath, table: 0, index: 40, offset: 0x7c] -> [resolved to "DHE2", table: 0, index: 18, offset: 0x45] + +- [Method, name: "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | +- [NamePath, table: 0, index: 42, offset: 0x82] -> [namepath: "HEX4"] + | +- [BytePrefix, table: 0, index: 43, offset: 0x86] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 44, offset: 0x87] + | +- [Store, table: 0, index: 45, offset: 0x87] + | +- [Arg0, table: 0, index: 46, offset: 0x88] + | +- [ResolvedNamePath, table: 0, index: 47, offset: 0x89] -> [resolved to "DHE4", table: 0, index: 22, offset: 0x52] + +- [Method, name: "SLEN", argCount: 1, table: 0, index: 48, offset: 0x8d] + | +- [NamePath, table: 0, index: 49, offset: 0x8f] -> [namepath: "SLEN"] + | +- [BytePrefix, table: 0, index: 50, offset: 0x93] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 51, offset: 0x94] + | +- [Store, table: 0, index: 52, offset: 0x94] + | | +- [Arg0, table: 0, index: 53, offset: 0x95] + | | +- [Local0, table: 0, index: 54, offset: 0x96] + | +- [Return, table: 0, index: 55, offset: 0x97] + | +- [SizeOf, table: 0, index: 56, offset: 0x98] + | +- [Local0, table: 0, index: 57, offset: 0x99] + +- [Method, name: "S2BF", argCount: 1, table: 0, index: 58, offset: 0x9a] + | +- [NamePath, table: 0, index: 59, offset: 0x9c] -> [namepath: "S2BF"] + | +- [BytePrefix, table: 0, index: 60, offset: 0xa0] -> [num value; dec: 9, hex: 0x9] + | +- [ScopeBlock, table: 0, index: 61, offset: 0xa1] + | +- [Store, table: 0, index: 62, offset: 0xa1] + | | +- [Arg0, table: 0, index: 63, offset: 0xa2] + | | +- [Local0, table: 0, index: 64, offset: 0xa3] + | +- [Add, table: 0, index: 65, offset: 0xa4] + | | +- [MethodCall, table: 0, index: 66, offset: 0xa5] -> [call to "SLEN", argCount: 1, table: 0, index: 48, offset: 0x8d] + | | | +- [Local0, table: 0, index: 67, offset: 0xa9] + | | +- [One, table: 0, index: 68, offset: 0xaa] + | | +- [Local0, table: 0, index: 69, offset: 0xab] + | +- [Name, name: "BUFF", table: 0, index: 70, offset: 0xac] + | | +- [NamePath, table: 0, index: 71, offset: 0xad] -> [namepath: "BUFF"] + | | +- [Buffer, table: 0, index: 72, offset: 0xb1] + | | +- [Local0, table: 0, index: 3531, offset: 0xb3] + | | +- [ByteList, table: 0, index: 3532, offset: 0x0] -> [bytelist value; len: 0; data: []] + | +- [Store, table: 0, index: 73, offset: 0xb4] + | | +- [Arg0, table: 0, index: 74, offset: 0xb5] + | | +- [ResolvedNamePath, table: 0, index: 75, offset: 0xb6] -> [resolved to "BUFF", table: 0, index: 70, offset: 0xac] + | +- [Return, table: 0, index: 76, offset: 0xba] + | +- [ResolvedNamePath, table: 0, index: 77, offset: 0xbb] -> [resolved to "BUFF", table: 0, index: 70, offset: 0xac] + +- [Method, name: "MIN_", argCount: 2, table: 0, index: 78, offset: 0xbf] + | +- [NamePath, table: 0, index: 79, offset: 0xc1] -> [namepath: "MIN_"] + | +- [BytePrefix, table: 0, index: 80, offset: 0xc5] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 81, offset: 0xc6] + | +- [If, table: 0, index: 82, offset: 0xc6] + | | +- [LLess, table: 0, index: 83, offset: 0xc8] + | | | +- [Arg0, table: 0, index: 84, offset: 0xc9] + | | | +- [Arg1, table: 0, index: 85, offset: 0xca] + | | +- [Return, table: 0, index: 86, offset: 0xcb] + | | +- [Arg0, table: 0, index: 87, offset: 0xcc] + | +- [Else, table: 0, index: 88, offset: 0xcd] + | +- [ScopeBlock, table: 0, index: 89, offset: 0xcf] + | +- [Return, table: 0, index: 90, offset: 0xcf] + | +- [Arg1, table: 0, index: 91, offset: 0xd0] + +- [Method, name: "SCMP", argCount: 2, table: 0, index: 92, offset: 0xd1] + | +- [NamePath, table: 0, index: 93, offset: 0xd4] -> [namepath: "SCMP"] + | +- [BytePrefix, table: 0, index: 94, offset: 0xd8] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 95, offset: 0xd9] + | +- [Store, table: 0, index: 96, offset: 0xd9] + | | +- [Arg0, table: 0, index: 97, offset: 0xda] + | | +- [Local0, table: 0, index: 98, offset: 0xdb] + | +- [Store, table: 0, index: 99, offset: 0xdc] + | | +- [MethodCall, table: 0, index: 100, offset: 0xdd] -> [call to "S2BF", argCount: 1, table: 0, index: 58, offset: 0x9a] + | | | +- [Local0, table: 0, index: 101, offset: 0xe1] + | | +- [Local0, table: 0, index: 102, offset: 0xe2] + | +- [Store, table: 0, index: 103, offset: 0xe3] + | | +- [MethodCall, table: 0, index: 104, offset: 0xe4] -> [call to "S2BF", argCount: 1, table: 0, index: 58, offset: 0x9a] + | | | +- [Arg1, table: 0, index: 105, offset: 0xe8] + | | +- [Local1, table: 0, index: 106, offset: 0xe9] + | +- [Store, table: 0, index: 107, offset: 0xea] + | | +- [Zero, table: 0, index: 108, offset: 0xeb] + | | +- [Local4, table: 0, index: 109, offset: 0xec] + | +- [Store, table: 0, index: 110, offset: 0xed] + | | +- [MethodCall, table: 0, index: 111, offset: 0xee] -> [call to "SLEN", argCount: 1, table: 0, index: 48, offset: 0x8d] + | | | +- [Arg0, table: 0, index: 112, offset: 0xf2] + | | +- [Local5, table: 0, index: 113, offset: 0xf3] + | +- [Store, table: 0, index: 114, offset: 0xf4] + | | +- [MethodCall, table: 0, index: 115, offset: 0xf5] -> [call to "SLEN", argCount: 1, table: 0, index: 48, offset: 0x8d] + | | | +- [Arg1, table: 0, index: 116, offset: 0xf9] + | | +- [Local6, table: 0, index: 117, offset: 0xfa] + | +- [Store, table: 0, index: 118, offset: 0xfb] + | | +- [MethodCall, table: 0, index: 119, offset: 0xfc] -> [call to "MIN_", argCount: 2, table: 0, index: 78, offset: 0xbf] + | | | +- [Local5, table: 0, index: 120, offset: 0x100] + | | | +- [Local6, table: 0, index: 121, offset: 0x101] + | | +- [Local7, table: 0, index: 122, offset: 0x102] + | +- [While, table: 0, index: 123, offset: 0x103] + | | +- [LLess, table: 0, index: 3533, offset: 0x105] + | | | +- [Local4, table: 0, index: 3534, offset: 0x106] + | | | +- [Local7, table: 0, index: 3535, offset: 0x107] + | | +- [ScopeBlock, table: 0, index: 3536, offset: 0x108] + | | +- [Store, table: 0, index: 3537, offset: 0x108] + | | | +- [DerefOf, table: 0, index: 3538, offset: 0x109] + | | | | +- [Index, table: 0, index: 3539, offset: 0x10a] + | | | | +- [Local0, table: 0, index: 3540, offset: 0x10b] + | | | | +- [Local4, table: 0, index: 3541, offset: 0x10c] + | | | +- [Local2, table: 0, index: 3542, offset: 0x10e] + | | +- [Store, table: 0, index: 3543, offset: 0x10f] + | | | +- [DerefOf, table: 0, index: 3544, offset: 0x110] + | | | | +- [Index, table: 0, index: 3545, offset: 0x111] + | | | | +- [Local1, table: 0, index: 3546, offset: 0x112] + | | | | +- [Local4, table: 0, index: 3547, offset: 0x113] + | | | +- [Local3, table: 0, index: 3548, offset: 0x115] + | | +- [If, table: 0, index: 3549, offset: 0x116] + | | +- [LGreater, table: 0, index: 3550, offset: 0x118] + | | | +- [Local2, table: 0, index: 3551, offset: 0x119] + | | | +- [Local3, table: 0, index: 3552, offset: 0x11a] + | | +- [ScopeBlock, table: 0, index: 3553, offset: 0x11b] + | | +- [Return, table: 0, index: 3554, offset: 0x11b] + | | | +- [One, table: 0, index: 3555, offset: 0x11c] + | | +- [Else, table: 0, index: 3556, offset: 0x11d] + | | +- [ScopeBlock, table: 0, index: 3557, offset: 0x11f] + | | +- [If, table: 0, index: 3558, offset: 0x11f] + | | +- [LLess, table: 0, index: 3559, offset: 0x121] + | | | +- [Local2, table: 0, index: 3560, offset: 0x122] + | | | +- [Local3, table: 0, index: 3561, offset: 0x123] + | | +- [ScopeBlock, table: 0, index: 3562, offset: 0x124] + | | +- [Return, table: 0, index: 3563, offset: 0x124] + | | +- [Ones, table: 0, index: 3564, offset: 0x125] + | +- [If, table: 0, index: 124, offset: 0x128] + | | +- [LLess, table: 0, index: 125, offset: 0x12a] + | | | +- [Local4, table: 0, index: 126, offset: 0x12b] + | | | +- [Local5, table: 0, index: 127, offset: 0x12c] + | | +- [Return, table: 0, index: 128, offset: 0x12d] + | | +- [One, table: 0, index: 129, offset: 0x12e] + | +- [Else, table: 0, index: 130, offset: 0x12f] + | +- [ScopeBlock, table: 0, index: 131, offset: 0x131] + | +- [If, table: 0, index: 132, offset: 0x131] + | | +- [LLess, table: 0, index: 133, offset: 0x133] + | | | +- [Local4, table: 0, index: 134, offset: 0x134] + | | | +- [Local6, table: 0, index: 135, offset: 0x135] + | | +- [Return, table: 0, index: 136, offset: 0x136] + | | +- [Ones, table: 0, index: 137, offset: 0x137] + | +- [Else, table: 0, index: 138, offset: 0x138] + | +- [ScopeBlock, table: 0, index: 139, offset: 0x13a] + | +- [Return, table: 0, index: 140, offset: 0x13a] + | +- [Zero, table: 0, index: 141, offset: 0x13b] + +- [Method, name: "MTCH", argCount: 2, table: 0, index: 142, offset: 0x13c] + | +- [NamePath, table: 0, index: 143, offset: 0x13e] -> [namepath: "MTCH"] + | +- [BytePrefix, table: 0, index: 144, offset: 0x142] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 145, offset: 0x143] + | +- [Store, table: 0, index: 146, offset: 0x143] + | | +- [Arg0, table: 0, index: 147, offset: 0x144] + | | +- [Local0, table: 0, index: 148, offset: 0x145] + | +- [Store, table: 0, index: 149, offset: 0x146] + | | +- [Arg1, table: 0, index: 150, offset: 0x147] + | | +- [Local1, table: 0, index: 151, offset: 0x148] + | +- [Store, table: 0, index: 152, offset: 0x149] + | | +- [MethodCall, table: 0, index: 153, offset: 0x14a] -> [call to "SCMP", argCount: 2, table: 0, index: 92, offset: 0xd1] + | | | +- [Local0, table: 0, index: 154, offset: 0x14e] + | | | +- [Local1, table: 0, index: 155, offset: 0x14f] + | | +- [Local2, table: 0, index: 156, offset: 0x150] + | +- [Return, table: 0, index: 157, offset: 0x151] + | +- [Lnot, table: 0, index: 158, offset: 0x152] + | +- [Local2, table: 0, index: 159, offset: 0x153] + +- [Method, name: "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | +- [NamePath, table: 0, index: 161, offset: 0x156] -> [namepath: "DBG_"] + | +- [BytePrefix, table: 0, index: 162, offset: 0x15a] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 163, offset: 0x15b] + | +- [Store, table: 0, index: 164, offset: 0x15b] + | | +- [Arg0, table: 0, index: 165, offset: 0x15c] + | | +- [Local0, table: 0, index: 166, offset: 0x15d] + | +- [Store, table: 0, index: 167, offset: 0x15e] + | | +- [MethodCall, table: 0, index: 168, offset: 0x15f] -> [call to "S2BF", argCount: 1, table: 0, index: 58, offset: 0x9a] + | | | +- [Local0, table: 0, index: 169, offset: 0x163] + | | +- [Local1, table: 0, index: 170, offset: 0x164] + | +- [Store, table: 0, index: 171, offset: 0x165] + | | +- [SizeOf, table: 0, index: 172, offset: 0x166] + | | | +- [Local1, table: 0, index: 173, offset: 0x167] + | | +- [Local0, table: 0, index: 174, offset: 0x168] + | +- [Decrement, table: 0, index: 175, offset: 0x169] + | | +- [Local0, table: 0, index: 176, offset: 0x16a] + | +- [Store, table: 0, index: 177, offset: 0x16b] + | | +- [Zero, table: 0, index: 178, offset: 0x16c] + | | +- [Local2, table: 0, index: 179, offset: 0x16d] + | +- [While, table: 0, index: 180, offset: 0x16e] + | +- [Local0, table: 0, index: 3565, offset: 0x170] + | +- [ScopeBlock, table: 0, index: 3566, offset: 0x171] + | +- [Decrement, table: 0, index: 3567, offset: 0x171] + | | +- [Local0, table: 0, index: 3568, offset: 0x172] + | +- [Store, table: 0, index: 3569, offset: 0x173] + | | +- [DerefOf, table: 0, index: 3570, offset: 0x174] + | | | +- [Index, table: 0, index: 3571, offset: 0x175] + | | | +- [Local1, table: 0, index: 3572, offset: 0x176] + | | | +- [Local2, table: 0, index: 3573, offset: 0x177] + | | +- [NamePath, table: 0, index: 3574, offset: 0x179] -> [namepath: "DCHR"] + | +- [Increment, table: 0, index: 3575, offset: 0x17d] + | +- [Local2, table: 0, index: 3576, offset: 0x17e] + +- [Name, name: "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [NamePath, table: 0, index: 182, offset: 0x180] -> [namepath: "MSWV"] + | +- [Ones, table: 0, index: 183, offset: 0x184] + +- [Method, name: "MSWN", argCount: 0, table: 0, index: 184, offset: 0x185] + | +- [NamePath, table: 0, index: 185, offset: 0x188] -> [namepath: "MSWN"] + | +- [BytePrefix, table: 0, index: 186, offset: 0x18c] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 0, index: 187, offset: 0x18d] + | +- [If, table: 0, index: 188, offset: 0x18d] + | | +- [Lnot, table: 0, index: 189, offset: 0x18f] + | | | +- [LEqual, table: 0, index: 190, offset: 0x190] + | | | +- [ResolvedNamePath, table: 0, index: 191, offset: 0x191] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | | | +- [Ones, table: 0, index: 192, offset: 0x195] + | | +- [Return, table: 0, index: 193, offset: 0x196] + | | +- [ResolvedNamePath, table: 0, index: 194, offset: 0x197] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [Store, table: 0, index: 195, offset: 0x19b] + | | +- [Zero, table: 0, index: 196, offset: 0x19c] + | | +- [ResolvedNamePath, table: 0, index: 197, offset: 0x19d] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [MethodCall, table: 0, index: 198, offset: 0x1a1] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 199, offset: 0x1a5] -> [string value: "_OS: "] + | +- [MethodCall, table: 0, index: 200, offset: 0x1ac] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [NamePath, table: 0, index: 201, offset: 0x1b0] -> [namepath: "_OS_"] + | +- [MethodCall, table: 0, index: 202, offset: 0x1b4] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 203, offset: 0x1b8] -> [string value: " +"] + | +- [If, table: 0, index: 204, offset: 0x1bb] + | | +- [CondRefOf, table: 0, index: 205, offset: 0x1be] + | | | +- [NamePath, table: 0, index: 206, offset: 0x1c0] -> [namepath: "_OSI"] + | | +- [MethodCall, table: 0, index: 207, offset: 0x1c5] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 208, offset: 0x1c9] -> [string value: "_OSI exists +"] + | +- [If, table: 0, index: 209, offset: 0x1d7] + | | +- [NamePath, table: 0, index: 210, offset: 0x1d9] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 211, offset: 0x1dd] -> [string value: "Windows 2001"] + | +- [Store, table: 0, index: 212, offset: 0x1eb] + | | +- [BytePrefix, table: 0, index: 213, offset: 0x1ec] -> [num value; dec: 4, hex: 0x4] + | | +- [ResolvedNamePath, table: 0, index: 214, offset: 0x1ee] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 215, offset: 0x1f2] + | | +- [NamePath, table: 0, index: 216, offset: 0x1f4] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 217, offset: 0x1f8] -> [string value: "Windows 2001.1"] + | +- [Store, table: 0, index: 218, offset: 0x208] + | | +- [BytePrefix, table: 0, index: 219, offset: 0x209] -> [num value; dec: 5, hex: 0x5] + | | +- [ResolvedNamePath, table: 0, index: 220, offset: 0x20b] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 221, offset: 0x20f] + | | +- [NamePath, table: 0, index: 222, offset: 0x211] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 223, offset: 0x215] -> [string value: "Windows 2006"] + | +- [Store, table: 0, index: 224, offset: 0x223] + | | +- [BytePrefix, table: 0, index: 225, offset: 0x224] -> [num value; dec: 6, hex: 0x6] + | | +- [ResolvedNamePath, table: 0, index: 226, offset: 0x226] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 227, offset: 0x22a] + | | +- [NamePath, table: 0, index: 228, offset: 0x22c] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 229, offset: 0x230] -> [string value: "Windows 2009"] + | +- [Store, table: 0, index: 230, offset: 0x23e] + | | +- [BytePrefix, table: 0, index: 231, offset: 0x23f] -> [num value; dec: 7, hex: 0x7] + | | +- [ResolvedNamePath, table: 0, index: 232, offset: 0x241] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 233, offset: 0x245] + | | +- [NamePath, table: 0, index: 234, offset: 0x247] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 235, offset: 0x24b] -> [string value: "Windows 2012"] + | +- [Store, table: 0, index: 236, offset: 0x259] + | | +- [BytePrefix, table: 0, index: 237, offset: 0x25a] -> [num value; dec: 8, hex: 0x8] + | | +- [ResolvedNamePath, table: 0, index: 238, offset: 0x25c] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 239, offset: 0x260] + | | +- [NamePath, table: 0, index: 240, offset: 0x262] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 241, offset: 0x266] -> [string value: "Windows 2013"] + | +- [Store, table: 0, index: 242, offset: 0x274] + | | +- [BytePrefix, table: 0, index: 243, offset: 0x275] -> [num value; dec: 9, hex: 0x9] + | | +- [ResolvedNamePath, table: 0, index: 244, offset: 0x277] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 245, offset: 0x27b] + | | +- [NamePath, table: 0, index: 246, offset: 0x27d] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 247, offset: 0x281] -> [string value: "Windows 2015"] + | +- [Store, table: 0, index: 248, offset: 0x28f] + | | +- [BytePrefix, table: 0, index: 249, offset: 0x290] -> [num value; dec: 10, hex: 0xa] + | | +- [ResolvedNamePath, table: 0, index: 250, offset: 0x292] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 251, offset: 0x296] + | | +- [NamePath, table: 0, index: 252, offset: 0x298] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 253, offset: 0x29c] -> [string value: "Windows 2006 SP2"] + | +- [MethodCall, table: 0, index: 254, offset: 0x2ae] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 255, offset: 0x2b2] -> [string value: "Windows 2006 SP2 supported +"] + | +- [Store, table: 0, index: 256, offset: 0x2cf] + | | +- [Zero, table: 0, index: 257, offset: 0x2d0] + | | +- [ResolvedNamePath, table: 0, index: 258, offset: 0x2d1] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [Else, table: 0, index: 259, offset: 0x2d5] + | | +- [ScopeBlock, table: 0, index: 260, offset: 0x2d8] + | | +- [If, table: 0, index: 261, offset: 0x2d8] + | | | +- [MethodCall, table: 0, index: 262, offset: 0x2da] -> [call to "MTCH", argCount: 2, table: 0, index: 142, offset: 0x13c] + | | | | +- [NamePath, table: 0, index: 263, offset: 0x2de] -> [namepath: "_OS_"] + | | | | +- [StringPrefix, table: 0, index: 264, offset: 0x2e2] -> [string value: "Microsoft Windows NT"] + | | | +- [Store, table: 0, index: 265, offset: 0x2f8] + | | | +- [BytePrefix, table: 0, index: 266, offset: 0x2f9] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 267, offset: 0x2fb] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | | +- [If, table: 0, index: 268, offset: 0x2ff] + | | +- [MethodCall, table: 0, index: 269, offset: 0x301] -> [call to "MTCH", argCount: 2, table: 0, index: 142, offset: 0x13c] + | | | +- [NamePath, table: 0, index: 270, offset: 0x305] -> [namepath: "_OS_"] + | | | +- [StringPrefix, table: 0, index: 271, offset: 0x309] -> [string value: "Microsoft WindowsME: Millennium Edition"] + | | +- [Store, table: 0, index: 272, offset: 0x332] + | | +- [BytePrefix, table: 0, index: 273, offset: 0x333] -> [num value; dec: 2, hex: 0x2] + | | +- [ResolvedNamePath, table: 0, index: 274, offset: 0x335] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 275, offset: 0x339] + | | +- [CondRefOf, table: 0, index: 276, offset: 0x33c] + | | | +- [NamePath, table: 0, index: 277, offset: 0x33e] -> [namepath: "_REV"] + | | +- [MethodCall, table: 0, index: 278, offset: 0x343] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 279, offset: 0x347] -> [string value: "_REV: "] + | +- [MethodCall, table: 0, index: 280, offset: 0x34f] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | +- [NamePath, table: 0, index: 281, offset: 0x353] -> [namepath: "_REV"] + | +- [If, table: 0, index: 282, offset: 0x357] + | | +- [Land, table: 0, index: 283, offset: 0x35a] + | | | +- [LGreater, table: 0, index: 284, offset: 0x35b] + | | | | +- [ResolvedNamePath, table: 0, index: 285, offset: 0x35c] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | | | | +- [Zero, table: 0, index: 286, offset: 0x360] + | | | +- [LGreater, table: 0, index: 287, offset: 0x361] + | | | +- [NamePath, table: 0, index: 288, offset: 0x362] -> [namepath: "_REV"] + | | | +- [BytePrefix, table: 0, index: 289, offset: 0x366] -> [num value; dec: 2, hex: 0x2] + | | +- [If, table: 0, index: 290, offset: 0x368] + | | +- [LLess, table: 0, index: 291, offset: 0x36a] + | | | +- [ResolvedNamePath, table: 0, index: 292, offset: 0x36b] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | | | +- [BytePrefix, table: 0, index: 293, offset: 0x36f] -> [num value; dec: 8, hex: 0x8] + | | +- [MethodCall, table: 0, index: 294, offset: 0x371] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 295, offset: 0x375] -> [string value: "ACPI rev mismatch, not a Microsoft OS +"] + | +- [Store, table: 0, index: 296, offset: 0x39d] + | | +- [Zero, table: 0, index: 297, offset: 0x39e] + | | +- [ResolvedNamePath, table: 0, index: 298, offset: 0x39f] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [MethodCall, table: 0, index: 299, offset: 0x3a3] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 300, offset: 0x3a7] -> [string value: "Determined MSWV: "] + | +- [MethodCall, table: 0, index: 301, offset: 0x3ba] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | +- [ResolvedNamePath, table: 0, index: 302, offset: 0x3be] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [Return, table: 0, index: 303, offset: 0x3c2] + | +- [ResolvedNamePath, table: 0, index: 304, offset: 0x3c3] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + +- [Name, name: "PICM", table: 0, index: 305, offset: 0x3c7] + | +- [NamePath, table: 0, index: 306, offset: 0x3c8] -> [namepath: "PICM"] + | +- [Zero, table: 0, index: 307, offset: 0x3cc] + +- [Method, name: "_PIC", argCount: 1, table: 0, index: 308, offset: 0x3cd] + | +- [NamePath, table: 0, index: 309, offset: 0x3cf] -> [namepath: "_PIC"] + | +- [BytePrefix, table: 0, index: 310, offset: 0x3d3] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 311, offset: 0x3d4] + | +- [MethodCall, table: 0, index: 312, offset: 0x3d4] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 313, offset: 0x3d8] -> [string value: "Pic mode: "] + | +- [MethodCall, table: 0, index: 314, offset: 0x3e4] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | +- [Arg0, table: 0, index: 315, offset: 0x3e8] + | +- [Store, table: 0, index: 316, offset: 0x3e9] + | +- [Arg0, table: 0, index: 317, offset: 0x3ea] + | +- [ResolvedNamePath, table: 0, index: 318, offset: 0x3eb] -> [resolved to "PICM", table: 0, index: 305, offset: 0x3c7] + +- [OpRegion, name: "SYSI", table: 0, index: 319, offset: 0x3ef] + | +- [NamePath, table: 0, index: 320, offset: 0x3f1] -> [namepath: "SYSI"] + | +- [BytePrefix, table: 0, index: 321, offset: 0x3f5] -> [num value; dec: 1, hex: 0x1] + | +- [WordPrefix, table: 0, index: 322, offset: 0x3f6] -> [num value; dec: 16456, hex: 0x4048] + | +- [BytePrefix, table: 0, index: 323, offset: 0x3f9] -> [num value; dec: 8, hex: 0x8] + +- [Field, table: 0, index: 324, offset: 0x3fb] + | +- [NamePath, table: 0, index: 325, offset: 0x3fe] -> [namepath: "SYSI"] + | +- [BytePrefix, table: 0, index: 326, offset: 0x402] -> [num value; dec: 3, hex: 0x3] + +- [NamedField, name: "IDX0", table: 0, index: 327, offset: 0x403] -> [field index: 324, offset(bytes): 0x0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "DAT0", table: 0, index: 328, offset: 0x408] -> [field index: 324, offset(bytes): 0x20, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [IndexField, name: "IDX0", table: 0, index: 329, offset: 0x40d] + | +- [NamePath, table: 0, index: 330, offset: 0x411] -> [namepath: "IDX0"] + | +- [NamePath, table: 0, index: 331, offset: 0x415] -> [namepath: "DAT0"] + | +- [BytePrefix, table: 0, index: 332, offset: 0x419] -> [num value; dec: 3, hex: 0x3] + +- [NamedField, name: "MEML", table: 0, index: 333, offset: 0x41a] -> [field index: 329, offset(bytes): 0x0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "UIOA", table: 0, index: 334, offset: 0x41f] -> [field index: 329, offset(bytes): 0x20, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "UHPT", table: 0, index: 335, offset: 0x424] -> [field index: 329, offset(bytes): 0x40, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "USMC", table: 0, index: 336, offset: 0x429] -> [field index: 329, offset(bytes): 0x60, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "UFDC", table: 0, index: 337, offset: 0x42e] -> [field index: 329, offset(bytes): 0x80, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL2B", table: 0, index: 338, offset: 0x433] -> [field index: 329, offset(bytes): 0xa0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL2I", table: 0, index: 339, offset: 0x438] -> [field index: 329, offset(bytes): 0xc0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL3B", table: 0, index: 340, offset: 0x43d] -> [field index: 329, offset(bytes): 0xe0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL3I", table: 0, index: 341, offset: 0x442] -> [field index: 329, offset(bytes): 0x100, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PMNN", table: 0, index: 342, offset: 0x447] -> [field index: 329, offset(bytes): 0x120, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "URTC", table: 0, index: 343, offset: 0x44c] -> [field index: 329, offset(bytes): 0x140, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "CPUL", table: 0, index: 344, offset: 0x451] -> [field index: 329, offset(bytes): 0x160, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "CPUC", table: 0, index: 345, offset: 0x456] -> [field index: 329, offset(bytes): 0x180, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "CPET", table: 0, index: 346, offset: 0x45b] -> [field index: 329, offset(bytes): 0x1a0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "CPEV", table: 0, index: 347, offset: 0x460] -> [field index: 329, offset(bytes): 0x1c0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "NICA", table: 0, index: 348, offset: 0x465] -> [field index: 329, offset(bytes): 0x1e0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "HDAA", table: 0, index: 349, offset: 0x46a] -> [field index: 329, offset(bytes): 0x200, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PWRS", table: 0, index: 350, offset: 0x46f] -> [field index: 329, offset(bytes): 0x220, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "IOCA", table: 0, index: 351, offset: 0x474] -> [field index: 329, offset(bytes): 0x240, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "HBCA", table: 0, index: 352, offset: 0x479] -> [field index: 329, offset(bytes): 0x260, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PCIB", table: 0, index: 353, offset: 0x47e] -> [field index: 329, offset(bytes): 0x280, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PCIL", table: 0, index: 354, offset: 0x483] -> [field index: 329, offset(bytes): 0x2a0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL0B", table: 0, index: 355, offset: 0x488] -> [field index: 329, offset(bytes): 0x2c0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL0I", table: 0, index: 356, offset: 0x48d] -> [field index: 329, offset(bytes): 0x2e0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL1B", table: 0, index: 357, offset: 0x492] -> [field index: 329, offset(bytes): 0x300, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL1I", table: 0, index: 358, offset: 0x497] -> [field index: 329, offset(bytes): 0x320, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PP0B", table: 0, index: 359, offset: 0x49c] -> [field index: 329, offset(bytes): 0x340, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PP0I", table: 0, index: 360, offset: 0x4a1] -> [field index: 329, offset(bytes): 0x360, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PP1B", table: 0, index: 361, offset: 0x4a6] -> [field index: 329, offset(bytes): 0x380, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PP1I", table: 0, index: 362, offset: 0x4ab] -> [field index: 329, offset(bytes): 0x3a0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PMNX", table: 0, index: 363, offset: 0x4b0] -> [field index: 329, offset(bytes): 0x3c0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "ININ", table: 0, index: 364, offset: 0x4b7] -> [field index: 329, offset(bytes): 0x400, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "VAIN", table: 0, index: 365, offset: 0x4bf] -> [field index: 329, offset(bytes): 0x1000, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [Name, name: "_S0_", table: 0, index: 3445, offset: 0x2164] + | +- [NamePath, table: 0, index: 3446, offset: 0x2165] -> [namepath: "_S0_"] + | +- [Package, table: 0, index: 3447, offset: 0x2169] + | +- [BytePrefix, table: 0, index: 3448, offset: 0x216b] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 3449, offset: 0x216c] + | +- [Zero, table: 0, index: 3450, offset: 0x216c] + | +- [Zero, table: 0, index: 3451, offset: 0x216d] + +- [If, table: 0, index: 3452, offset: 0x216e] + | +- [And, table: 0, index: 3453, offset: 0x2170] + | | +- [ResolvedNamePath, table: 0, index: 3454, offset: 0x2171] -> [resolved to "PWRS", table: 0, index: 350, offset: 0x46f] + | | +- [BytePrefix, table: 0, index: 3455, offset: 0x2175] -> [num value; dec: 2, hex: 0x2] + | | +- [Zero, table: 0, index: 3456, offset: 0x2177] + | +- [Name, name: "_S1_", table: 0, index: 3457, offset: 0x2178] + | +- [NamePath, table: 0, index: 3458, offset: 0x2179] -> [namepath: "_S1_"] + | +- [Package, table: 0, index: 3459, offset: 0x217d] + | +- [BytePrefix, table: 0, index: 3460, offset: 0x217f] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 3461, offset: 0x2180] + | +- [One, table: 0, index: 3462, offset: 0x2180] + | +- [One, table: 0, index: 3463, offset: 0x2181] + +- [If, table: 0, index: 3464, offset: 0x2182] + | +- [And, table: 0, index: 3465, offset: 0x2184] + | | +- [ResolvedNamePath, table: 0, index: 3466, offset: 0x2185] -> [resolved to "PWRS", table: 0, index: 350, offset: 0x46f] + | | +- [BytePrefix, table: 0, index: 3467, offset: 0x2189] -> [num value; dec: 16, hex: 0x10] + | | +- [Zero, table: 0, index: 3468, offset: 0x218b] + | +- [Name, name: "_S4_", table: 0, index: 3469, offset: 0x218c] + | +- [NamePath, table: 0, index: 3470, offset: 0x218d] -> [namepath: "_S4_"] + | +- [Package, table: 0, index: 3471, offset: 0x2191] + | +- [BytePrefix, table: 0, index: 3472, offset: 0x2193] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 3473, offset: 0x2194] + | +- [BytePrefix, table: 0, index: 3474, offset: 0x2194] -> [num value; dec: 5, hex: 0x5] + | +- [BytePrefix, table: 0, index: 3475, offset: 0x2196] -> [num value; dec: 5, hex: 0x5] + +- [Name, name: "_S5_", table: 0, index: 3476, offset: 0x2198] + | +- [NamePath, table: 0, index: 3477, offset: 0x2199] -> [namepath: "_S5_"] + | +- [Package, table: 0, index: 3478, offset: 0x219d] + | +- [BytePrefix, table: 0, index: 3479, offset: 0x219f] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 3480, offset: 0x21a0] + | +- [BytePrefix, table: 0, index: 3481, offset: 0x21a0] -> [num value; dec: 5, hex: 0x5] + | +- [BytePrefix, table: 0, index: 3482, offset: 0x21a2] -> [num value; dec: 5, hex: 0x5] + +- [Method, name: "_PTS", argCount: 1, table: 0, index: 3483, offset: 0x21a4] + +- [NamePath, table: 0, index: 3484, offset: 0x21a6] -> [namepath: "_PTS"] + +- [BytePrefix, table: 0, index: 3485, offset: 0x21aa] -> [num value; dec: 1, hex: 0x1] + +- [ScopeBlock, table: 0, index: 3486, offset: 0x21ab] + +- [MethodCall, table: 0, index: 3487, offset: 0x21ab] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | +- [StringPrefix, table: 0, index: 3488, offset: 0x21af] -> [string value: "Prepare to sleep: "] + +- [MethodCall, table: 0, index: 3489, offset: 0x21c3] -> [call to "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + +- [Arg0, table: 0, index: 3490, offset: 0x21c7] diff --git a/src/gopheros/device/acpi/table/tabletest/DSDT.dsl b/src/gopheros/device/acpi/table/tabletest/DSDT.dsl new file mode 100644 index 0000000..14c7c23 --- /dev/null +++ b/src/gopheros/device/acpi/table/tabletest/DSDT.dsl @@ -0,0 +1,3332 @@ +/* + * Intel ACPI Component Architecture + * AML/ASL+ Disassembler version 20160108-64 + * Copyright (c) 2000 - 2016 Intel Corporation + * + * Disassembling to symbolic ASL+ operators + * + * Disassembly of DSDT.aml, Thu Jan 4 07:55:57 2018 + * + * Original Table Header: + * Signature "DSDT" + * Length 0x000021C8 (8648) + * Revision 0x02 + * Checksum 0xEE + * OEM ID "VBOX " + * OEM Table ID "VBOXBIOS" + * OEM Revision 0x00000002 (2) + * Compiler ID "INTL" + * Compiler Version 0x20100528 (537920808) + */ +DefinitionBlock ("DSDT.aml", "DSDT", 2, "VBOX ", "VBOXBIOS", 0x00000002) +{ + OperationRegion (DBG0, SystemIO, 0x3000, 0x04) + Field (DBG0, ByteAcc, NoLock, Preserve) + { + DHE1, 8 + } + + Field (DBG0, WordAcc, NoLock, Preserve) + { + DHE2, 16 + } + + Field (DBG0, DWordAcc, NoLock, Preserve) + { + DHE4, 32 + } + + Field (DBG0, ByteAcc, NoLock, Preserve) + { + Offset (0x01), + DCHR, 8 + } + + Method (HEX, 1, NotSerialized) + { + DHE1 = Arg0 + } + + Method (HEX2, 1, NotSerialized) + { + DHE2 = Arg0 + } + + Method (HEX4, 1, NotSerialized) + { + DHE4 = Arg0 + } + + Method (SLEN, 1, NotSerialized) + { + Local0 = Arg0 + Return (SizeOf (Local0)) + } + + Method (S2BF, 1, Serialized) + { + Local0 = Arg0 + Local0 = (SLEN (Local0) + One) + Name (BUFF, Buffer (Local0) {}) + BUFF = Arg0 + Return (BUFF) /* \S2BF.BUFF */ + } + + Method (MIN, 2, NotSerialized) + { + If ((Arg0 < Arg1)) + { + Return (Arg0) + } + Else + { + Return (Arg1) + } + } + + Method (SCMP, 2, NotSerialized) + { + Local0 = Arg0 + Local0 = S2BF (Local0) + Local1 = S2BF (Arg1) + Local4 = Zero + Local5 = SLEN (Arg0) + Local6 = SLEN (Arg1) + Local7 = MIN (Local5, Local6) + While ((Local4 < Local7)) + { + Local2 = DerefOf (Local0 [Local4]) + Local3 = DerefOf (Local1 [Local4]) + If ((Local2 > Local3)) + { + Return (One) + } + ElseIf ((Local2 < Local3)) + { + Return (Ones) + } + + Local4++ + } + + If ((Local4 < Local5)) + { + Return (One) + } + ElseIf ((Local4 < Local6)) + { + Return (Ones) + } + Else + { + Return (Zero) + } + } + + Method (MTCH, 2, NotSerialized) + { + Local0 = Arg0 + Local1 = Arg1 + Local2 = SCMP (Local0, Local1) + Return (!Local2) + } + + Method (DBG, 1, NotSerialized) + { + Local0 = Arg0 + Local1 = S2BF (Local0) + Local0 = SizeOf (Local1) + Local0-- + Local2 = Zero + While (Local0) + { + Local0-- + DCHR = DerefOf (Local1 [Local2]) + Local2++ + } + } + + Name (MSWV, Ones) + Method (MSWN, 0, NotSerialized) + { + If ((MSWV != Ones)) + { + Return (MSWV) /* \MSWV */ + } + + MSWV = Zero + DBG ("_OS: ") + DBG (_OS) + DBG ("\n") + If (CondRefOf (_OSI)) + { + DBG ("_OSI exists\n") + If (_OSI ("Windows 2001")) + { + MSWV = 0x04 + } + + If (_OSI ("Windows 2001.1")) + { + MSWV = 0x05 + } + + If (_OSI ("Windows 2006")) + { + MSWV = 0x06 + } + + If (_OSI ("Windows 2009")) + { + MSWV = 0x07 + } + + If (_OSI ("Windows 2012")) + { + MSWV = 0x08 + } + + If (_OSI ("Windows 2013")) + { + MSWV = 0x09 + } + + If (_OSI ("Windows 2015")) + { + MSWV = 0x0A + } + + If (_OSI ("Windows 2006 SP2")) + { + DBG ("Windows 2006 SP2 supported\n") + MSWV = Zero + } + } + ElseIf (MTCH (_OS, "Microsoft Windows NT")) + { + MSWV = 0x03 + } + + If (CondRefOf (_REV)) + { + DBG ("_REV: ") + HEX4 (_REV) + If (((MSWV > Zero) && (_REV > 0x02))) + { + If ((MSWV < 0x08)) + { + DBG ("ACPI rev mismatch, not a Microsoft OS\n") + MSWV = Zero + } + } + } + + DBG ("Determined MSWV: ") + HEX4 (MSWV) + Return (MSWV) /* \MSWV */ + } + + Name (PICM, Zero) + Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model + { + DBG ("Pic mode: ") + HEX4 (Arg0) + PICM = Arg0 + } + + OperationRegion (SYSI, SystemIO, 0x4048, 0x08) + Field (SYSI, DWordAcc, NoLock, Preserve) + { + IDX0, 32, + DAT0, 32 + } + + IndexField (IDX0, DAT0, DWordAcc, NoLock, Preserve) + { + MEML, 32, + UIOA, 32, + UHPT, 32, + USMC, 32, + UFDC, 32, + SL2B, 32, + SL2I, 32, + SL3B, 32, + SL3I, 32, + PMNN, 32, + URTC, 32, + CPUL, 32, + CPUC, 32, + CPET, 32, + CPEV, 32, + NICA, 32, + HDAA, 32, + PWRS, 32, + IOCA, 32, + HBCA, 32, + PCIB, 32, + PCIL, 32, + SL0B, 32, + SL0I, 32, + SL1B, 32, + SL1I, 32, + PP0B, 32, + PP0I, 32, + PP1B, 32, + PP1I, 32, + PMNX, 32, + Offset (0x80), + ININ, 32, + Offset (0x200), + VAIN, 32 + } + + Scope (_SB) + { + Method (_INI, 0, NotSerialized) // _INI: Initialize + { + VAIN = 0x0BADC0DE + DBG ("MEML: ") + HEX4 (MEML) + DBG ("UIOA: ") + HEX4 (UIOA) + DBG ("UHPT: ") + HEX4 (UHPT) + DBG ("USMC: ") + HEX4 (USMC) + DBG ("UFDC: ") + HEX4 (UFDC) + DBG ("PMNN: ") + HEX4 (PMNN) + } + + Name (PR00, Package (0x78) + { + Package (0x04) + { + 0x0002FFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0002FFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0002FFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0002FFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0003FFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0003FFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0003FFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0003FFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0004FFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0004FFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0004FFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0004FFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0005FFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0005FFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0005FFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0005FFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0006FFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0006FFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0006FFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0006FFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0007FFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0007FFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0007FFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0007FFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0008FFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0008FFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0008FFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0008FFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0009FFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0009FFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0009FFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0009FFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000AFFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x000AFFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000AFFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000AFFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000BFFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000BFFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000BFFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000BFFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x000CFFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000CFFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000CFFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x000CFFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000DFFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000DFFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x000DFFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000DFFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000EFFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x000EFFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000EFFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000EFFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000FFFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000FFFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000FFFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000FFFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0010FFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0010FFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0010FFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0010FFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0011FFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0011FFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0011FFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0011FFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0012FFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0012FFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0012FFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0012FFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0013FFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0013FFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0013FFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0013FFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0014FFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0014FFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0014FFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0014FFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0015FFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0015FFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0015FFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0015FFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0016FFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0016FFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0016FFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0016FFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0017FFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0017FFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0017FFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0017FFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0018FFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0018FFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0018FFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0018FFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0019FFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0019FFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0019FFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0019FFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001AFFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x001AFFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001AFFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001AFFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001BFFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001BFFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001BFFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001BFFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x001CFFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001CFFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001CFFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x001CFFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001DFFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001DFFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x001DFFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001DFFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001EFFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x001EFFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001EFFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001EFFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001FFFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001FFFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001FFFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001FFFFF, + 0x03, + LNKB, + Zero + } + }) + Name (PR01, Package (0x78) + { + Package (0x04) + { + 0x0002FFFF, + Zero, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0002FFFF, + One, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0002FFFF, + 0x02, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0002FFFF, + 0x03, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0003FFFF, + Zero, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0003FFFF, + One, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0003FFFF, + 0x02, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0003FFFF, + 0x03, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0004FFFF, + Zero, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0004FFFF, + One, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0004FFFF, + 0x02, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0004FFFF, + 0x03, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0005FFFF, + Zero, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0005FFFF, + One, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0005FFFF, + 0x02, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0005FFFF, + 0x03, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0006FFFF, + Zero, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0006FFFF, + One, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0006FFFF, + 0x02, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0006FFFF, + 0x03, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0007FFFF, + Zero, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0007FFFF, + One, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0007FFFF, + 0x02, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0007FFFF, + 0x03, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0008FFFF, + Zero, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0008FFFF, + One, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0008FFFF, + 0x02, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0008FFFF, + 0x03, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0009FFFF, + Zero, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0009FFFF, + One, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0009FFFF, + 0x02, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0009FFFF, + 0x03, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x000AFFFF, + Zero, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x000AFFFF, + One, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x000AFFFF, + 0x02, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x000AFFFF, + 0x03, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x000BFFFF, + Zero, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x000BFFFF, + One, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x000BFFFF, + 0x02, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x000BFFFF, + 0x03, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x000CFFFF, + Zero, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x000CFFFF, + One, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x000CFFFF, + 0x02, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x000CFFFF, + 0x03, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x000DFFFF, + Zero, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x000DFFFF, + One, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x000DFFFF, + 0x02, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x000DFFFF, + 0x03, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x000EFFFF, + Zero, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x000EFFFF, + One, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x000EFFFF, + 0x02, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x000EFFFF, + 0x03, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x000FFFFF, + Zero, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x000FFFFF, + One, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x000FFFFF, + 0x02, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x000FFFFF, + 0x03, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0010FFFF, + Zero, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0010FFFF, + One, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0010FFFF, + 0x02, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0010FFFF, + 0x03, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0011FFFF, + Zero, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0011FFFF, + One, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0011FFFF, + 0x02, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0011FFFF, + 0x03, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0012FFFF, + Zero, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0012FFFF, + One, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0012FFFF, + 0x02, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0012FFFF, + 0x03, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0013FFFF, + Zero, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0013FFFF, + One, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0013FFFF, + 0x02, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0013FFFF, + 0x03, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0014FFFF, + Zero, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0014FFFF, + One, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0014FFFF, + 0x02, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0014FFFF, + 0x03, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0015FFFF, + Zero, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0015FFFF, + One, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0015FFFF, + 0x02, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0015FFFF, + 0x03, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0016FFFF, + Zero, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0016FFFF, + One, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0016FFFF, + 0x02, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0016FFFF, + 0x03, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0017FFFF, + Zero, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0017FFFF, + One, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0017FFFF, + 0x02, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0017FFFF, + 0x03, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0018FFFF, + Zero, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0018FFFF, + One, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0018FFFF, + 0x02, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0018FFFF, + 0x03, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0019FFFF, + Zero, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0019FFFF, + One, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0019FFFF, + 0x02, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0019FFFF, + 0x03, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x001AFFFF, + Zero, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x001AFFFF, + One, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x001AFFFF, + 0x02, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x001AFFFF, + 0x03, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x001BFFFF, + Zero, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x001BFFFF, + One, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x001BFFFF, + 0x02, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x001BFFFF, + 0x03, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x001CFFFF, + Zero, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x001CFFFF, + One, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x001CFFFF, + 0x02, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x001CFFFF, + 0x03, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x001DFFFF, + Zero, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x001DFFFF, + One, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x001DFFFF, + 0x02, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x001DFFFF, + 0x03, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x001EFFFF, + Zero, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x001EFFFF, + One, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x001EFFFF, + 0x02, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x001EFFFF, + 0x03, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x001FFFFF, + Zero, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x001FFFFF, + One, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x001FFFFF, + 0x02, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x001FFFFF, + 0x03, + Zero, + 0x12 + } + }) + Name (PRSA, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared, ) + {5,9,10,11} + }) + Name (PRSB, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared, ) + {5,9,10,11} + }) + Name (PRSC, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared, ) + {5,9,10,11} + }) + Name (PRSD, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared, ) + {5,9,10,11} + }) + Device (PCI0) + { + Name (_HID, EisaId ("PNP0A03") /* PCI Bus */) // _HID: Hardware ID + Method (_ADR, 0, NotSerialized) // _ADR: Address + { + Return (HBCA) /* \HBCA */ + } + + Name (_BBN, Zero) // _BBN: BIOS Bus Number + Name (_UID, Zero) // _UID: Unique ID + Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table + { + If (((PICM && UIOA) == Zero)) + { + DBG ("RETURNING PIC\n") + ^SBRG.APDE = Zero + ^SBRG.APAD = Zero + Return (PR00) /* \_SB_.PR00 */ + } + Else + { + DBG ("RETURNING APIC\n") + ^SBRG.APDE = 0xBE + ^SBRG.APAD = 0xEF + Return (PR01) /* \_SB_.PR01 */ + } + } + + Device (SBRG) + { + Method (_ADR, 0, NotSerialized) // _ADR: Address + { + Return (IOCA) /* \IOCA */ + } + + OperationRegion (PCIC, PCI_Config, Zero, 0xFF) + Field (PCIC, ByteAcc, NoLock, Preserve) + { + Offset (0xAD), + APAD, 8, + Offset (0xDE), + APDE, 8 + } + + Device (^PCIE) + { + Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID + Name (_UID, 0x11) // _UID: Unique ID + Name (CRS, ResourceTemplate () + { + Memory32Fixed (ReadOnly, + 0xDC000000, // Address Base + 0x04000000, // Address Length + _Y00) + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateDWordField (CRS, \_SB.PCI0.PCIE._Y00._BAS, BAS1) // _BAS: Base Address + CreateDWordField (CRS, \_SB.PCI0.PCIE._Y00._LEN, LEN1) // _LEN: Length + BAS1 = PCIB /* \PCIB */ + LEN1 = PCIL /* \PCIL */ + Return (CRS) /* \_SB_.PCI0.PCIE.CRS_ */ + } + + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((PCIB == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + } + + Device (PS2K) + { + Name (_HID, EisaId ("PNP0303") /* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */) // _HID: Hardware ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } + + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0060, // Range Minimum + 0x0060, // Range Maximum + 0x00, // Alignment + 0x01, // Length + ) + IO (Decode16, + 0x0064, // Range Minimum + 0x0064, // Range Maximum + 0x00, // Alignment + 0x01, // Length + ) + IRQNoFlags () + {1} + }) + } + + Device (DMAC) + { + Name (_HID, EisaId ("PNP0200") /* PC-class DMA Controller */) // _HID: Hardware ID + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0000, // Range Minimum + 0x0000, // Range Maximum + 0x01, // Alignment + 0x10, // Length + ) + IO (Decode16, + 0x0080, // Range Minimum + 0x0080, // Range Maximum + 0x01, // Alignment + 0x10, // Length + ) + IO (Decode16, + 0x00C0, // Range Minimum + 0x00C0, // Range Maximum + 0x01, // Alignment + 0x20, // Length + ) + DMA (Compatibility, BusMaster, Transfer8_16, ) + {4} + }) + } + + Device (FDC0) + { + Name (_HID, EisaId ("PNP0700")) // _HID: Hardware ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (UFDC) /* \UFDC */ + } + + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x03F0, // Range Minimum + 0x03F0, // Range Maximum + 0x01, // Alignment + 0x06, // Length + ) + IO (Decode16, + 0x03F7, // Range Minimum + 0x03F7, // Range Maximum + 0x01, // Alignment + 0x01, // Length + ) + IRQNoFlags () + {6} + DMA (Compatibility, NotBusMaster, Transfer8, ) + {2} + }) + Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings + { + IO (Decode16, + 0x03F0, // Range Minimum + 0x03F0, // Range Maximum + 0x01, // Alignment + 0x06, // Length + ) + IO (Decode16, + 0x03F7, // Range Minimum + 0x03F7, // Range Maximum + 0x01, // Alignment + 0x01, // Length + ) + IRQNoFlags () + {6} + DMA (Compatibility, NotBusMaster, Transfer8, ) + {2} + }) + } + + Device (PS2M) + { + Name (_HID, EisaId ("PNP0F03") /* Microsoft PS/2-style Mouse */) // _HID: Hardware ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } + + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IRQNoFlags () + {12} + }) + } + + Device (^LPT0) + { + Name (_HID, EisaId ("PNP0400") /* Standard LPT Parallel Port */) // _HID: Hardware ID + Name (_UID, One) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((PP0B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x0378, // Range Minimum + 0x0378, // Range Maximum + 0x08, // Alignment + 0x08, // Length + _Y01) + IRQNoFlags (_Y02) + {7} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.LPT0._Y01._MIN, PMI0) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.LPT0._Y01._MAX, PMA0) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.LPT0._Y02._INT, PIQ0) // _INT: Interrupts + PMI0 = PP0B /* \PP0B */ + PMA0 = PP0B /* \PP0B */ + PIQ0 = (One << PP0I) /* \PP0I */ + Return (CRS) /* \_SB_.PCI0.LPT0.CRS_ */ + } + } + + Device (^LPT1) + { + Name (_HID, EisaId ("PNP0400") /* Standard LPT Parallel Port */) // _HID: Hardware ID + Name (_UID, 0x02) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((PP1B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x0278, // Range Minimum + 0x0278, // Range Maximum + 0x08, // Alignment + 0x08, // Length + _Y03) + IRQNoFlags (_Y04) + {5} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.LPT1._Y03._MIN, PMI1) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.LPT1._Y03._MAX, PMA1) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.LPT1._Y04._INT, PIQ1) // _INT: Interrupts + PMI1 = PP1B /* \PP1B */ + PMA1 = PP1B /* \PP1B */ + PIQ1 = (One << PP1I) /* \PP1I */ + Return (CRS) /* \_SB_.PCI0.LPT1.CRS_ */ + } + } + + Device (^SRL0) + { + Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */) // _HID: Hardware ID + Name (_UID, One) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((SL0B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x03F8, // Range Minimum + 0x03F8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + _Y05) + IRQNoFlags (_Y06) + {4} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.SRL0._Y05._MIN, MIN0) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL0._Y05._MAX, MAX0) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL0._Y06._INT, IRQ0) // _INT: Interrupts + MIN0 = SL0B /* \SL0B */ + MAX0 = SL0B /* \SL0B */ + IRQ0 = (One << SL0I) /* \SL0I */ + Return (CRS) /* \_SB_.PCI0.SRL0.CRS_ */ + } + } + + Device (^SRL1) + { + Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */) // _HID: Hardware ID + Name (_UID, 0x02) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((SL1B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x02F8, // Range Minimum + 0x02F8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + _Y07) + IRQNoFlags (_Y08) + {3} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.SRL1._Y07._MIN, MIN1) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL1._Y07._MAX, MAX1) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL1._Y08._INT, IRQ1) // _INT: Interrupts + MIN1 = SL1B /* \SL1B */ + MAX1 = SL1B /* \SL1B */ + IRQ1 = (One << SL1I) /* \SL1I */ + Return (CRS) /* \_SB_.PCI0.SRL1.CRS_ */ + } + } + + Device (^SRL2) + { + Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */) // _HID: Hardware ID + Name (_UID, 0x03) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((SL2B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x03E8, // Range Minimum + 0x03E8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + _Y09) + IRQNoFlags (_Y0A) + {3} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.SRL2._Y09._MIN, MIN1) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL2._Y09._MAX, MAX1) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL2._Y0A._INT, IRQ1) // _INT: Interrupts + MIN1 = SL2B /* \SL2B */ + MAX1 = SL2B /* \SL2B */ + IRQ1 = (One << SL2I) /* \SL2I */ + Return (CRS) /* \_SB_.PCI0.SRL2.CRS_ */ + } + } + + Device (^SRL3) + { + Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */) // _HID: Hardware ID + Name (_UID, 0x04) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((SL3B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x02E8, // Range Minimum + 0x02E8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + _Y0B) + IRQNoFlags (_Y0C) + {3} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.SRL3._Y0B._MIN, MIN1) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL3._Y0B._MAX, MAX1) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL3._Y0C._INT, IRQ1) // _INT: Interrupts + MIN1 = SL3B /* \SL3B */ + MAX1 = SL3B /* \SL3B */ + IRQ1 = (One << SL3I) /* \SL3I */ + Return (CRS) /* \_SB_.PCI0.SRL3.CRS_ */ + } + } + + Device (TIMR) + { + Name (_HID, EisaId ("PNP0100") /* PC-class System Timer */) // _HID: Hardware ID + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0040, // Range Minimum + 0x0040, // Range Maximum + 0x00, // Alignment + 0x04, // Length + ) + IO (Decode16, + 0x0050, // Range Minimum + 0x0050, // Range Maximum + 0x10, // Alignment + 0x04, // Length + ) + }) + } + + Device (PIC) + { + Name (_HID, EisaId ("PNP0000") /* 8259-compatible Programmable Interrupt Controller */) // _HID: Hardware ID + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0020, // Range Minimum + 0x0020, // Range Maximum + 0x00, // Alignment + 0x02, // Length + ) + IO (Decode16, + 0x00A0, // Range Minimum + 0x00A0, // Range Maximum + 0x00, // Alignment + 0x02, // Length + ) + IRQNoFlags () + {2} + }) + } + + Device (RTC) + { + Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */) // _HID: Hardware ID + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0070, // Range Minimum + 0x0070, // Range Maximum + 0x01, // Alignment + 0x02, // Length + ) + }) + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (URTC) /* \URTC */ + } + } + + Device (HPET) + { + Name (_HID, EisaId ("PNP0103") /* HPET System Timer */) // _HID: Hardware ID + Name (_CID, EisaId ("PNP0C01") /* System Board */) // _CID: Compatible ID + Name (_UID, Zero) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (UHPT) /* \UHPT */ + } + + Name (CRS, ResourceTemplate () + { + IRQNoFlags () + {0} + IRQNoFlags () + {8} + Memory32Fixed (ReadWrite, + 0xFED00000, // Address Base + 0x00000400, // Address Length + ) + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (CRS) /* \_SB_.PCI0.SBRG.HPET.CRS_ */ + } + } + + Device (SMC) + { + Name (_HID, EisaId ("APP0001")) // _HID: Hardware ID + Name (_CID, "smc-napa") // _CID: Compatible ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (USMC) /* \USMC */ + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x0300, // Range Minimum + 0x0300, // Range Maximum + 0x01, // Alignment + 0x20, // Length + ) + IRQNoFlags () + {6} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (CRS) /* \_SB_.PCI0.SBRG.SMC_.CRS_ */ + } + } + } + + Device (GIGE) + { + Name (_HID, EisaId ("PNP8390")) // _HID: Hardware ID + Method (_ADR, 0, NotSerialized) // _ADR: Address + { + Return (NICA) /* \NICA */ + } + + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((NICA == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + } + + Device (GFX0) + { + Name (_ADR, 0x00020000) // _ADR: Address + Method (_STA, 0, NotSerialized) // _STA: Status + { + If (((MSWN () > Zero) && (MSWN () < 0x08))) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Scope (\_GPE) + { + Method (_L02, 0, NotSerialized) // _Lxx: Level-Triggered GPE + { + Notify (\_SB.PCI0.GFX0, 0x81) // Information Change + } + } + + Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching + { + } + + Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices + { + Return (Package (0x01) + { + 0x80000100 + }) + } + + Device (VGA) + { + Method (_ADR, 0, Serialized) // _ADR: Address + { + Return (0x0100) + } + } + } + + Device (HDEF) + { + Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method + { + Local0 = Package (0x04) + { + "layout-id", + Unicode ("\x04"), + "PinConfigurations", + Buffer (Zero) {} + } + If ((Arg0 == ToUUID ("a0b5b7c6-1318-441c-b0c9-fe695eaf949b"))) + { + If ((Arg1 == One)) + { + If ((Arg2 == Zero)) + { + Local0 = Buffer (One) + { + 0x03 /* . */ + } + Return (Local0) + } + + If ((Arg2 == One)) + { + Return (Local0) + } + } + } + + Local0 = Buffer (One) + { + 0x00 /* . */ + } + Return (Local0) + } + + Method (_ADR, 0, NotSerialized) // _ADR: Address + { + Return (HDAA) /* \HDAA */ + } + + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((HDAA == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + } + + Device (BAT0) + { + Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID + Name (_UID, Zero) // _UID: Unique ID + Scope (\_GPE) + { + Method (_L00, 0, NotSerialized) // _Lxx: Level-Triggered GPE + { + Notify (\_SB.PCI0.BAT0, 0x80) // Status Change + Notify (\_SB.PCI0.AC, 0x80) // Status Change + } + } + + OperationRegion (CBAT, SystemIO, 0x4040, 0x08) + Field (CBAT, DWordAcc, NoLock, Preserve) + { + IDX0, 32, + DAT0, 32 + } + + IndexField (IDX0, DAT0, DWordAcc, NoLock, Preserve) + { + STAT, 32, + PRAT, 32, + RCAP, 32, + PVOL, 32, + UNIT, 32, + DCAP, 32, + LFCP, 32, + BTEC, 32, + DVOL, 32, + DWRN, 32, + DLOW, 32, + GRN1, 32, + GRN2, 32, + BSTA, 32, + APSR, 32 + } + + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (BSTA) /* \_SB_.PCI0.BAT0.BSTA */ + } + + Name (PBIF, Package (0x0D) + { + One, + 0x7FFFFFFF, + 0x7FFFFFFF, + Zero, + 0xFFFFFFFF, + Zero, + Zero, + 0x04, + 0x04, + "1", + "0", + "VBOX", + "innotek" + }) + Name (PBST, Package (0x04) + { + Zero, + 0x7FFFFFFF, + 0x7FFFFFFF, + 0x7FFFFFFF + }) + Method (_BIF, 0, NotSerialized) // _BIF: Battery Information + { + PBIF [Zero] = UNIT /* \_SB_.PCI0.BAT0.UNIT */ + PBIF [One] = DCAP /* \_SB_.PCI0.BAT0.DCAP */ + PBIF [0x02] = LFCP /* \_SB_.PCI0.BAT0.LFCP */ + PBIF [0x03] = BTEC /* \_SB_.PCI0.BAT0.BTEC */ + PBIF [0x04] = DVOL /* \_SB_.PCI0.BAT0.DVOL */ + PBIF [0x05] = DWRN /* \_SB_.PCI0.BAT0.DWRN */ + PBIF [0x06] = DLOW /* \_SB_.PCI0.BAT0.DLOW */ + PBIF [0x07] = GRN1 /* \_SB_.PCI0.BAT0.GRN1 */ + PBIF [0x08] = GRN2 /* \_SB_.PCI0.BAT0.GRN2 */ + DBG ("_BIF:\n") + HEX4 (DerefOf (PBIF [Zero])) + HEX4 (DerefOf (PBIF [One])) + HEX4 (DerefOf (PBIF [0x02])) + HEX4 (DerefOf (PBIF [0x03])) + HEX4 (DerefOf (PBIF [0x04])) + HEX4 (DerefOf (PBIF [0x05])) + HEX4 (DerefOf (PBIF [0x06])) + HEX4 (DerefOf (PBIF [0x07])) + HEX4 (DerefOf (PBIF [0x08])) + Return (PBIF) /* \_SB_.PCI0.BAT0.PBIF */ + } + + Method (_BST, 0, NotSerialized) // _BST: Battery Status + { + PBST [Zero] = STAT /* \_SB_.PCI0.BAT0.STAT */ + PBST [One] = PRAT /* \_SB_.PCI0.BAT0.PRAT */ + PBST [0x02] = RCAP /* \_SB_.PCI0.BAT0.RCAP */ + PBST [0x03] = PVOL /* \_SB_.PCI0.BAT0.PVOL */ + Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ + } + } + + Device (AC) + { + Name (_HID, "ACPI0003" /* Power Source Device */) // _HID: Hardware ID + Name (_UID, Zero) // _UID: Unique ID + Name (_PCL, Package (0x01) // _PCL: Power Consumer List + { + _SB + }) + Method (_PSR, 0, NotSerialized) // _PSR: Power Source + { + Return (^^BAT0.APSR) /* \_SB_.PCI0.BAT0.APSR */ + } + + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } + } + } + } + + Scope (_SB) + { + Scope (PCI0) + { + Name (CRS, ResourceTemplate () + { + WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, + 0x0000, // Granularity + 0x0000, // Range Minimum + 0x00FF, // Range Maximum + 0x0000, // Translation Offset + 0x0100, // Length + ,, ) + IO (Decode16, + 0x0CF8, // Range Minimum + 0x0CF8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + ) + WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000, // Granularity + 0x0000, // Range Minimum + 0x0CF7, // Range Maximum + 0x0000, // Translation Offset + 0x0CF8, // Length + ,, , TypeStatic) + WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000, // Granularity + 0x0D00, // Range Minimum + 0xFFFF, // Range Maximum + 0x0000, // Translation Offset + 0xF300, // Length + ,, , TypeStatic) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, // Granularity + 0x000A0000, // Range Minimum + 0x000BFFFF, // Range Maximum + 0x00000000, // Translation Offset + 0x00020000, // Length + ,, , AddressRangeMemory, TypeStatic) + DWordMemory (ResourceProducer, PosDecode, MinNotFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, // Granularity + 0x00000000, // Range Minimum + 0xFFDFFFFF, // Range Maximum + 0x00000000, // Translation Offset + 0x00000000, // Length + ,, _Y0D, AddressRangeMemory, TypeStatic) + }) + Name (TOM, ResourceTemplate () + { + QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Prefetchable, ReadWrite, + 0x0000000000000000, // Granularity + 0x0000000100000000, // Range Minimum + 0x0000000FFFFFFFFF, // Range Maximum + 0x0000000000000000, // Translation Offset + 0x0000000F00000000, // Length + ,, _Y0E, AddressRangeMemory, TypeStatic) + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateDWordField (CRS, \_SB.PCI0._Y0D._MIN, RAMT) // _MIN: Minimum Base Address + CreateDWordField (CRS, \_SB.PCI0._Y0D._LEN, RAMR) // _LEN: Length + RAMT = MEML /* \MEML */ + RAMR = (0xFFE00000 - RAMT) /* \_SB_.PCI0._CRS.RAMT */ + If ((PMNN != Zero)) + { + If (((MSWN () < One) || (MSWN () > 0x06))) + { + CreateQWordField (TOM, \_SB.PCI0._Y0E._MIN, TM4N) // _MIN: Minimum Base Address + CreateQWordField (TOM, \_SB.PCI0._Y0E._MAX, TM4X) // _MAX: Maximum Base Address + CreateQWordField (TOM, \_SB.PCI0._Y0E._LEN, TM4L) // _LEN: Length + TM4N = (PMNN * 0x00010000) + TM4X = ((PMNX * 0x00010000) - One) + TM4L = ((TM4X - TM4N) + One) + ConcatenateResTemplate (CRS, TOM, Local2) + Return (Local2) + } + } + + Return (CRS) /* \_SB_.PCI0.CRS_ */ + } + } + } + + Scope (_SB) + { + Field (PCI0.SBRG.PCIC, ByteAcc, NoLock, Preserve) + { + Offset (0x60), + PIRA, 8, + PIRB, 8, + PIRC, 8, + PIRD, 8 + } + + Name (BUFA, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared, ) + {15} + }) + CreateWordField (BUFA, One, ICRS) + Method (LSTA, 1, NotSerialized) + { + Local0 = (Arg0 & 0x80) + If (Local0) + { + Return (0x09) + } + Else + { + Return (0x0B) + } + } + + Method (LCRS, 1, NotSerialized) + { + Local0 = (Arg0 & 0x0F) + ICRS = (One << Local0) + Return (BUFA) /* \_SB_.BUFA */ + } + + Method (LSRS, 1, NotSerialized) + { + CreateWordField (Arg0, One, ISRS) + FindSetRightBit (ISRS, Local0) + Return (Local0--) + } + + Method (LDIS, 1, NotSerialized) + { + Return ((Arg0 | 0x80)) + } + + Device (LNKA) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID + Name (_UID, One) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + DBG ("LNKA._STA\n") + Return (LSTA (PIRA)) + } + + Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings + { + DBG ("LNKA._PRS\n") + Return (PRSA) /* \_SB_.PRSA */ + } + + Method (_DIS, 0, NotSerialized) // _DIS: Disable Device + { + DBG ("LNKA._DIS\n") + PIRA = LDIS (PIRA) + } + + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + DBG ("LNKA._CRS\n") + Return (LCRS (PIRA)) + } + + Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings + { + DBG ("LNKA._SRS: ") + HEX (LSRS (Arg0)) + PIRA = LSRS (Arg0) + } + } + + Device (LNKB) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID + Name (_UID, 0x02) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (LSTA (PIRB)) + } + + Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings + { + Return (PRSB) /* \_SB_.PRSB */ + } + + Method (_DIS, 0, NotSerialized) // _DIS: Disable Device + { + PIRB = LDIS (PIRB) + } + + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (LCRS (PIRB)) + } + + Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings + { + DBG ("LNKB._SRS: ") + HEX (LSRS (Arg0)) + PIRB = LSRS (Arg0) + } + } + + Device (LNKC) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID + Name (_UID, 0x03) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (LSTA (PIRC)) + } + + Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings + { + Return (PRSC) /* \_SB_.PRSC */ + } + + Method (_DIS, 0, NotSerialized) // _DIS: Disable Device + { + PIRC = LDIS (PIRC) + } + + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (LCRS (PIRC)) + } + + Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings + { + DBG ("LNKC._SRS: ") + HEX (LSRS (Arg0)) + PIRC = LSRS (Arg0) + } + } + + Device (LNKD) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID + Name (_UID, 0x04) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (LSTA (PIRD)) + } + + Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings + { + Return (PRSD) /* \_SB_.PRSD */ + } + + Method (_DIS, 0, NotSerialized) // _DIS: Disable Device + { + PIRD = LDIS (PIRA) + } + + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (LCRS (PIRD)) + } + + Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings + { + DBG ("LNKD._SRS: ") + HEX (LSRS (Arg0)) + PIRD = LSRS (Arg0) + } + } + } + + Name (_S0, Package (0x02) // _S0_: S0 System State + { + Zero, + Zero + }) + If ((PWRS & 0x02)) + { + Name (_S1, Package (0x02) // _S1_: S1 System State + { + One, + One + }) + } + + If ((PWRS & 0x10)) + { + Name (_S4, Package (0x02) // _S4_: S4 System State + { + 0x05, + 0x05 + }) + } + + Name (_S5, Package (0x02) // _S5_: S5 System State + { + 0x05, + 0x05 + }) + Method (_PTS, 1, NotSerialized) // _PTS: Prepare To Sleep + { + DBG ("Prepare to sleep: ") + HEX (Arg0) + } +} + diff --git a/src/gopheros/device/acpi/table/tabletest/SSDT.dsl b/src/gopheros/device/acpi/table/tabletest/SSDT.dsl new file mode 100644 index 0000000..3b29644 --- /dev/null +++ b/src/gopheros/device/acpi/table/tabletest/SSDT.dsl @@ -0,0 +1,431 @@ +/* + * Intel ACPI Component Architecture + * AML/ASL+ Disassembler version 20180105 (64-bit version) + * Copyright (c) 2000 - 2018 Intel Corporation + * + * Disassembling to symbolic ASL+ operators + * + * Disassembly of SSDT.aml, Tue Jan 30 08:22:57 2018 + * + * Original Table Header: + * Signature "SSDT" + * Length 0x000001CC (460) + * Revision 0x01 + * Checksum 0x9D + * OEM ID "VBOX " + * OEM Table ID "VBOXCPUT" + * OEM Revision 0x00000002 (2) + * Compiler ID "INTL" + * Compiler Version 0x20100528 (537920808) + */ +DefinitionBlock ("", "SSDT", 1, "VBOX ", "VBOXCPUT", 0x00000002) +{ + Scope (\_PR) + { + Processor (CPU0, 0x00, 0x00000000, 0x00){} + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + } +} + diff --git a/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.aml b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.aml new file mode 100644 index 0000000..c9f8617 Binary files /dev/null and b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.aml differ diff --git a/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.dsl b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.dsl new file mode 100644 index 0000000..f5a0ccf --- /dev/null +++ b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.dsl @@ -0,0 +1,255 @@ +// DSDT-parser-testsuite +// +// This file contains various ASL constructs to ensure that the AML parser +// properly handles all possible ASL opcodes it may encounter. This test file +// is used in addition to the DSDT.aml file obtained by running acpidump inside +// virtualbox. +DefinitionBlock ("parser-testsuite-DSDT.aml", "DSDT", 2, "GOPHER", "GOPHEROS", 0x00000002) +{ + OperationRegion (DBG0, SystemIO, 0x3000, 0x04) + Field (DBG0, ByteAcc, NoLock, Preserve) + { + DHE1, 8 + } + + Device (DRV0) + { + Name (_ADR, Ones) + + // named entity containing qword const + Name (H15F, 0xBADC0FEEDEADC0DE) + Method (_GTF, 0, NotSerialized) // _GTF: Get Task File + { + Return (H15F) + } + } + + // example from p. 268 of ACPI 6.2 spec + Scope(\_SB){ + OperationRegion(TOP1, GenericSerialBus, 0x00, 0x100) // GenericSerialBus device at command offset 0x00 + + Name (SDB0, ResourceTemplate() {}) + Field(TOP1, BufferAcc, NoLock, Preserve){ + Connection(SDB0), // Use the Resource Descriptor defined above + AccessAs(BufferAcc, AttribWord), + FLD0, 8, + FLD1, 8 + } + + Field(TOP1, BufferAcc, NoLock, Preserve){ + Connection(I2cSerialBus(0x5b,,100000,, "\\_SB",,,,RawDataBuffer(){3,9})), + AccessAs(BufferAcc, AttribBytes(4)), + FLD2, 8, + AccessAs(BufferAcc, AttribRawBytes(3)), + FLD3, 8, + AccessAs(BufferAcc, AttribRawProcessBytes(2)), + FLD4, 8 + } + } + + // Buffer whose size is given by a nested method invocation which is + // evaluated at load-time + Method(BLE1, 1, Serialized) + { + Return(Arg0 + 1) + } + + Name(BUFZ, Buffer(BLEN(BLE1(0xff), 0x0f)){0x48, 0x49, 0x21} ) + + Method(BLEN, 2, Serialized) + { + Return(Arg0 + Arg1 + 12) + } + + // Load time assignment + FET0 = 1 + + // A buffer whose length is given by a named object + Name(BUFL, One) + Name(BUFF, Buffer(BUFL){}) + + // Other entity types + Event(HLO0) + Mutex(MUT0,1) + Signal(HLO0) + + // Other executable bits + Method (EXE0, 1, Serialized) + { + // AML interpreter revision + Local0 = Revision + + // NameString target + Local1 = SizeOf(GLB1) + + Local0 = "my-handle" + Load(DBG0, Local0) + Unload(Local0) + + // CreateXXXField + CreateBitField(Arg0, 0, WFL0) + if(Arg0==0){ + Return(WFL0) + } + + CreateByteField(Arg0, 0, WFL1) + if(Arg0==1){ + Return(WFL1) + } + + CreateWordField(Arg0, 0, WFL2) + if(Arg0==2){ + Return(WFL2) + } + + CreateDwordField(Arg0, 0, WFL3) + if(Arg0==3){ + Return(WFL3) + } + + CreateQwordField(Arg0, 0, WFL4) + if(Arg0==4){ + Return(WFL4) + } + + CreateField(Arg0, 0, 13, WFL5) + if(Arg0==5){ + Return(WFL5) + } + + // Example from p. 951 of the spec + Store ( + LoadTable ("OEM1", "MYOEM", "TABLE1", "\\_SB.PCI0","MYD", Package () {0,"\\_SB.PCI0"}), + Local0 + ) + + // Various Assignments + Local0 = 0xff + Local0 = 0xffff + Local0 = 0xffffffff + Local0 = 0xffffffffffffffff + Local0 = Zero + Local0 = One + Local0 = Ones + Local0 = "FOO" + + // Conversions + FromBCD(9, Arg0) + ToBCD(Arg0, Local1) + + // Debugging and error handling + Breakpoint + Debug = "test" + Fatal(0xf0, 0xdeadc0de, 1) + + // Mutex support + Acquire(MUT0, 0xffff) // no timeout + Release(MUT0) + + // Signal/Wait + Reset(HLO0) + Wait(HLO0, 0xffff) + + // Get monotonic timer value + Local0 = Timer + + CopyObject(Local0, Local1) + Return(ObjectType(Local1)) + } + + // BankField example from p. 910 of the spec + // Define a 256-byte operational region in SystemIO space and name it GIO0 + OperationRegion (GIO0, SystemIO, 0x125, 0x100) + Field (GIO0, ByteAcc, NoLock, Preserve) { + GLB1, 1, + GLB2, 1, + Offset (1), // Move to offset for byte 1 + BNK1, 4 + } + + BankField (GIO0, BNK1, 0, ByteAcc, Lock, WriteAsOnes) { + Offset (0x30), + FET0, 1, + FET1, 1, + } + + // SMBus fields access types + OperationRegion(SMBD, SMBus, 0x4200, 0x100) + Field(SMBD, BufferAcc, NoLock, WriteAsZeros){ + AccessAs(BufferAcc, SMBByte), + SFL0, 8, + AccessAs(BufferAcc, SMBWord), + SFL1, 8, + AccessAs(BufferAcc, SMBBlock), + SFL2, 8, + AccessAs(BufferAcc, SMBQuick), + SFL3, 8, + AccessAs(BufferAcc, SMBSendReceive), + SFL4, 8, + AccessAs(BufferAcc, SMBProcessCall), + SFL5, 8, + AccessAs(BufferAcc, SMBBlockProcessCall), + SFL6, 8, + AccessAs(BufferAcc, AttribBytes(0x12)), + SFL7, 8, + AccessAs(BufferAcc, AttribRawBytes(0x13)), + SFL8, 8, + AccessAs(BufferAcc, AttribRawProcessBytes(0x14)), + SFL9, 8, + // + AccessAs(AnyAcc), + SF10, 8, + AccessAs(ByteAcc), + SF11, 8, + AccessAs(WordAcc), + SF12, 8, + AccessAs(DwordAcc), + SF13, 8, + AccessAs(QwordAcc), + SF14, 8, + } + + // Data Region + DataTableRegion (REG0, "FOOF", "BAR", "BAZ") + + // Other resources + Processor(CPU0, 1, 0x120, 6){} + PowerResource(PWR0, 0, 0){} + ThermalZone(TZ0){} + + // Method with various logic/flow changing opcodes + Method (FLOW, 2, NotSerialized) + { + While(Arg0 < Arg1) + { + Arg0++ + + If( Arg0 < 5 ) { + Continue + } Else { + If ( Arg1 == 0xff ) { + Break + } Else { + Arg0 = Arg0 + 1 + } + } + } + + Return(Arg0) + } + + // Forward declaration to SCP0 + Scope(\_SB) { + ThermalZone(^THRM){ + Name(DEF0, Ones) + } + } + + Scope(\THRM){ + Name(DEF1, Zero) + } + + Method(\THRM.MTH0, 0, NotSerialized){ + Return(1) + } +} diff --git a/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.exp b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.exp new file mode 100644 index 0000000..88e1cd7 --- /dev/null +++ b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.exp @@ -0,0 +1,346 @@ + +- [ScopeBlock, name: "\", table: 42, index: 0, offset: 0x0] + +- [ScopeBlock, name: "_GPE", table: 42, index: 1, offset: 0x0] + +- [ScopeBlock, name: "_PR_", table: 42, index: 2, offset: 0x0] + +- [ScopeBlock, name: "_SB_", table: 42, index: 3, offset: 0x0] + | +- [OpRegion, name: "TOP1", table: 0, index: 33, offset: 0x6c] + | | +- [NamePath, table: 0, index: 34, offset: 0x6e] -> [namepath: "TOP1"] + | | +- [BytePrefix, table: 0, index: 35, offset: 0x72] -> [num value; dec: 9, hex: 0x9] + | | +- [BytePrefix, table: 0, index: 36, offset: 0x73] -> [num value; dec: 0, hex: 0x0] + | | +- [WordPrefix, table: 0, index: 37, offset: 0x75] -> [num value; dec: 256, hex: 0x100] + | +- [Name, name: "SDB0", table: 0, index: 38, offset: 0x78] + | | +- [NamePath, table: 0, index: 39, offset: 0x79] -> [namepath: "SDB0"] + | | +- [Buffer, table: 0, index: 40, offset: 0x7d] + | | +- [BytePrefix, table: 0, index: 316, offset: 0x7f] -> [num value; dec: 2, hex: 0x2] + | | +- [ByteList, table: 0, index: 318, offset: 0x3cb] -> [bytelist value; len: 2; data: [0x79, 0x0]] + | +- [Field, table: 0, index: 41, offset: 0x83] + | | +- [NamePath, table: 0, index: 42, offset: 0x86] -> [namepath: "TOP1"] + | | +- [BytePrefix, table: 0, index: 43, offset: 0x8a] -> [num value; dec: 5, hex: 0x5] + | | +- [Connection, table: 0, index: 44, offset: 0x0] + | | +- [NamePath, table: 0, index: 45, offset: 0x8c] -> [namepath: "SDB0"] + | +- [NamedField, name: "FLD0", table: 0, index: 46, offset: 0x93] -> [field index: 41, offset(bytes): 0x0, width(bits): 0x8, accType: Buffer, accAttr: Word, lockType: NoLock, updateType: Preserve, connection: index 44] + | +- [NamedField, name: "FLD1", table: 0, index: 47, offset: 0x98] -> [field index: 41, offset(bytes): 0x8, width(bits): 0x8, accType: Buffer, accAttr: Word, lockType: NoLock, updateType: Preserve, connection: index 44] + | +- [Field, table: 0, index: 48, offset: 0x9d] + | | +- [NamePath, table: 0, index: 49, offset: 0xa0] -> [namepath: "TOP1"] + | | +- [BytePrefix, table: 0, index: 50, offset: 0xa4] -> [num value; dec: 5, hex: 0x5] + | | +- [Connection, table: 0, index: 51, offset: 0x0] + | | +- [ByteList, table: 0, index: 52, offset: 0xa7] -> [bytelist value; len: 25; data: [0x8e, 0x16, 0x0, 0x1, 0x0, 0x1, 0x2, 0x0, 0x0, 0x1, 0x8, 0x0, 0xa0, 0x86, 0x1, 0x0, 0x5b, 0x0, 0x3, 0x9, 0x5c, 0x5f, 0x53, 0x42, 0x0]] + | +- [NamedField, name: "FLD2", table: 0, index: 53, offset: 0xc7] -> [field index: 48, offset(bytes): 0x0, width(bits): 0x8, accType: Buffer, accAttr: Bytes(0x4), lockType: NoLock, updateType: Preserve, connection: index 51] + | +- [NamedField, name: "FLD3", table: 0, index: 54, offset: 0xd0] -> [field index: 48, offset(bytes): 0x8, width(bits): 0x8, accType: Buffer, accAttr: RawBytes(0x3), lockType: NoLock, updateType: Preserve, connection: index 51] + | +- [NamedField, name: "FLD4", table: 0, index: 55, offset: 0xd9] -> [field index: 48, offset(bytes): 0x10, width(bits): 0x8, accType: Buffer, accAttr: RawProcessBytes(0x2), lockType: NoLock, updateType: Preserve, connection: index 51] + +- [ScopeBlock, name: "_SI_", table: 42, index: 4, offset: 0x0] + +- [ScopeBlock, name: "_TZ_", table: 42, index: 5, offset: 0x0] + +- [OpRegion, name: "DBG0", table: 0, index: 6, offset: 0x24] + | +- [NamePath, table: 0, index: 7, offset: 0x26] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 8, offset: 0x2a] -> [num value; dec: 1, hex: 0x1] + | +- [WordPrefix, table: 0, index: 9, offset: 0x2b] -> [num value; dec: 12288, hex: 0x3000] + | +- [BytePrefix, table: 0, index: 10, offset: 0x2e] -> [num value; dec: 4, hex: 0x4] + +- [Field, table: 0, index: 11, offset: 0x30] + | +- [NamePath, table: 0, index: 12, offset: 0x33] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 13, offset: 0x37] -> [num value; dec: 1, hex: 0x1] + +- [NamedField, name: "DHE1", table: 0, index: 14, offset: 0x38] -> [field index: 11, offset(bytes): 0x0, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [Device, name: "DRV0", table: 0, index: 15, offset: 0x3d] + | +- [NamePath, table: 0, index: 16, offset: 0x40] -> [namepath: "DRV0"] + | +- [ScopeBlock, table: 0, index: 17, offset: 0x44] + | +- [Name, name: "_ADR", table: 0, index: 18, offset: 0x44] + | | +- [NamePath, table: 0, index: 19, offset: 0x45] -> [namepath: "_ADR"] + | | +- [Ones, table: 0, index: 20, offset: 0x49] + | +- [Name, name: "H15F", table: 0, index: 21, offset: 0x4a] + | | +- [NamePath, table: 0, index: 22, offset: 0x4b] -> [namepath: "H15F"] + | | +- [QwordPrefix, table: 0, index: 23, offset: 0x4f] -> [num value; dec: 13464654504543502558, hex: 0xbadc0feedeadc0de] + | +- [Method, name: "_GTF", argCount: 0, table: 0, index: 24, offset: 0x58] + | +- [NamePath, table: 0, index: 25, offset: 0x5a] -> [namepath: "_GTF"] + | +- [BytePrefix, table: 0, index: 26, offset: 0x5e] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 0, index: 27, offset: 0x5f] + | +- [Return, table: 0, index: 28, offset: 0x5f] + | +- [ResolvedNamePath, table: 0, index: 29, offset: 0x60] -> [resolved to "H15F", table: 0, index: 21, offset: 0x4a] + +- [Method, name: "BLE1", argCount: 1, table: 0, index: 56, offset: 0xde] + | +- [NamePath, table: 0, index: 57, offset: 0xe0] -> [namepath: "BLE1"] + | +- [BytePrefix, table: 0, index: 58, offset: 0xe4] -> [num value; dec: 9, hex: 0x9] + | +- [ScopeBlock, table: 0, index: 59, offset: 0xe5] + | +- [Return, table: 0, index: 60, offset: 0xe5] + | +- [Add, table: 0, index: 61, offset: 0xe6] + | +- [Arg0, table: 0, index: 62, offset: 0xe7] + | +- [BytePrefix, table: 0, index: 63, offset: 0xe8] -> [num value; dec: 1, hex: 0x1] + | +- [Zero, table: 0, index: 64, offset: 0xea] + +- [Name, name: "BUFZ", table: 0, index: 65, offset: 0xeb] + | +- [NamePath, table: 0, index: 66, offset: 0xec] -> [namepath: "BUFZ"] + | +- [Buffer, table: 0, index: 67, offset: 0xf0] + | +- [MethodCall, table: 0, index: 317, offset: 0xf2] -> [call to "BLEN", argCount: 2, table: 0, index: 68, offset: 0x101] + | | +- [MethodCall, table: 0, index: 307, offset: 0xf6] -> [call to "BLE1", argCount: 1, table: 0, index: 56, offset: 0xde] + | | | +- [BytePrefix, table: 0, index: 309, offset: 0xfa] -> [num value; dec: 255, hex: 0xff] + | | +- [BytePrefix, table: 0, index: 308, offset: 0xfc] -> [num value; dec: 15, hex: 0xf] + | +- [ByteList, table: 0, index: 30, offset: 0x64] -> [bytelist value; len: 3; data: [0x48, 0x49, 0x21]] + +- [Method, name: "BLEN", argCount: 2, table: 0, index: 68, offset: 0x101] + | +- [NamePath, table: 0, index: 69, offset: 0x103] -> [namepath: "BLEN"] + | +- [BytePrefix, table: 0, index: 70, offset: 0x107] -> [num value; dec: 10, hex: 0xa] + | +- [ScopeBlock, table: 0, index: 71, offset: 0x108] + | +- [Return, table: 0, index: 72, offset: 0x108] + | +- [Add, table: 0, index: 73, offset: 0x109] + | +- [Add, table: 0, index: 74, offset: 0x10a] + | | +- [Arg0, table: 0, index: 75, offset: 0x10b] + | | +- [Arg1, table: 0, index: 76, offset: 0x10c] + | | +- [Zero, table: 0, index: 77, offset: 0x10d] + | +- [BytePrefix, table: 0, index: 78, offset: 0x10e] -> [num value; dec: 12, hex: 0xc] + | +- [Zero, table: 0, index: 79, offset: 0x110] + +- [Store, table: 0, index: 80, offset: 0x111] + | +- [BytePrefix, table: 0, index: 81, offset: 0x112] -> [num value; dec: 1, hex: 0x1] + | +- [ResolvedNamePath, table: 0, index: 82, offset: 0x114] -> [resolved to "FET0", table: 0, index: 332, offset: 0x2b9] + +- [Name, name: "BUFL", table: 0, index: 83, offset: 0x118] + | +- [NamePath, table: 0, index: 84, offset: 0x119] -> [namepath: "BUFL"] + | +- [One, table: 0, index: 85, offset: 0x11d] + +- [Name, name: "BUFF", table: 0, index: 86, offset: 0x11e] + | +- [NamePath, table: 0, index: 87, offset: 0x11f] -> [namepath: "BUFF"] + | +- [Buffer, table: 0, index: 88, offset: 0x123] + | +- [ResolvedNamePath, table: 0, index: 32, offset: 0x125] -> [resolved to "BUFL", table: 0, index: 83, offset: 0x118] + | +- [ByteList, table: 0, index: 31, offset: 0x67] -> [bytelist value; len: 0; data: []] + +- [Event, name: "HLO0", table: 0, index: 89, offset: 0x129] + | +- [NamePath, table: 0, index: 90, offset: 0x12b] -> [namepath: "HLO0"] + +- [Mutex, name: "MUT0", table: 0, index: 91, offset: 0x12f] + | +- [NamePath, table: 0, index: 92, offset: 0x131] -> [namepath: "MUT0"] + | +- [BytePrefix, table: 0, index: 93, offset: 0x135] -> [num value; dec: 1, hex: 0x1] + +- [Signal, table: 0, index: 94, offset: 0x136] + | +- [ResolvedNamePath, table: 0, index: 95, offset: 0x138] -> [resolved to "HLO0", table: 0, index: 89, offset: 0x129] + +- [Method, name: "EXE0", argCount: 1, table: 0, index: 96, offset: 0x13c] + | +- [NamePath, table: 0, index: 97, offset: 0x13f] -> [namepath: "EXE0"] + | +- [BytePrefix, table: 0, index: 98, offset: 0x143] -> [num value; dec: 9, hex: 0x9] + | +- [ScopeBlock, table: 0, index: 99, offset: 0x144] + | +- [Store, table: 0, index: 100, offset: 0x144] + | | +- [Revision, table: 0, index: 101, offset: 0x145] + | | +- [Local0, table: 0, index: 102, offset: 0x147] + | +- [Store, table: 0, index: 103, offset: 0x148] + | | +- [SizeOf, table: 0, index: 104, offset: 0x149] + | | | +- [NamePath, table: 0, index: 105, offset: 0x14a] -> [namepath: "GLB1"] + | | +- [Local1, table: 0, index: 106, offset: 0x14e] + | +- [Store, table: 0, index: 107, offset: 0x14f] + | | +- [StringPrefix, table: 0, index: 108, offset: 0x150] -> [string value: "my-handle"] + | | +- [Local0, table: 0, index: 109, offset: 0x15b] + | +- [Load, table: 0, index: 110, offset: 0x15c] + | | +- [NamePath, table: 0, index: 111, offset: 0x15e] -> [namepath: "DBG0"] + | | +- [Local0, table: 0, index: 112, offset: 0x162] + | +- [Unload, table: 0, index: 113, offset: 0x163] + | | +- [Local0, table: 0, index: 114, offset: 0x165] + | +- [CreateBitField, table: 0, index: 115, offset: 0x166] + | | +- [Arg0, table: 0, index: 116, offset: 0x167] + | | +- [BytePrefix, table: 0, index: 117, offset: 0x168] -> [num value; dec: 0, hex: 0x0] + | | +- [NamePath, table: 0, index: 118, offset: 0x16a] -> [namepath: "WFL0"] + | +- [If, table: 0, index: 119, offset: 0x16e] + | | +- [LEqual, table: 0, index: 120, offset: 0x170] + | | | +- [Arg0, table: 0, index: 121, offset: 0x171] + | | | +- [BytePrefix, table: 0, index: 122, offset: 0x172] -> [num value; dec: 0, hex: 0x0] + | | +- [Return, table: 0, index: 123, offset: 0x174] + | | +- [NamePath, table: 0, index: 124, offset: 0x175] -> [namepath: "WFL0"] + | +- [CreateByteField, table: 0, index: 125, offset: 0x179] + | | +- [Arg0, table: 0, index: 126, offset: 0x17a] + | | +- [BytePrefix, table: 0, index: 127, offset: 0x17b] -> [num value; dec: 0, hex: 0x0] + | | +- [NamePath, table: 0, index: 128, offset: 0x17d] -> [namepath: "WFL1"] + | +- [If, table: 0, index: 129, offset: 0x181] + | | +- [LEqual, table: 0, index: 130, offset: 0x183] + | | | +- [Arg0, table: 0, index: 131, offset: 0x184] + | | | +- [BytePrefix, table: 0, index: 132, offset: 0x185] -> [num value; dec: 1, hex: 0x1] + | | +- [Return, table: 0, index: 133, offset: 0x187] + | | +- [NamePath, table: 0, index: 134, offset: 0x188] -> [namepath: "WFL1"] + | +- [CreateWordField, table: 0, index: 135, offset: 0x18c] + | | +- [Arg0, table: 0, index: 136, offset: 0x18d] + | | +- [BytePrefix, table: 0, index: 137, offset: 0x18e] -> [num value; dec: 0, hex: 0x0] + | | +- [NamePath, table: 0, index: 138, offset: 0x190] -> [namepath: "WFL2"] + | +- [If, table: 0, index: 139, offset: 0x194] + | | +- [LEqual, table: 0, index: 140, offset: 0x196] + | | | +- [Arg0, table: 0, index: 141, offset: 0x197] + | | | +- [BytePrefix, table: 0, index: 142, offset: 0x198] -> [num value; dec: 2, hex: 0x2] + | | +- [Return, table: 0, index: 143, offset: 0x19a] + | | +- [NamePath, table: 0, index: 144, offset: 0x19b] -> [namepath: "WFL2"] + | +- [CreateDWordField, table: 0, index: 145, offset: 0x19f] + | | +- [Arg0, table: 0, index: 146, offset: 0x1a0] + | | +- [BytePrefix, table: 0, index: 147, offset: 0x1a1] -> [num value; dec: 0, hex: 0x0] + | | +- [NamePath, table: 0, index: 148, offset: 0x1a3] -> [namepath: "WFL3"] + | +- [If, table: 0, index: 149, offset: 0x1a7] + | | +- [LEqual, table: 0, index: 150, offset: 0x1a9] + | | | +- [Arg0, table: 0, index: 151, offset: 0x1aa] + | | | +- [BytePrefix, table: 0, index: 152, offset: 0x1ab] -> [num value; dec: 3, hex: 0x3] + | | +- [Return, table: 0, index: 153, offset: 0x1ad] + | | +- [NamePath, table: 0, index: 154, offset: 0x1ae] -> [namepath: "WFL3"] + | +- [CreateQWordField, table: 0, index: 155, offset: 0x1b2] + | | +- [Arg0, table: 0, index: 156, offset: 0x1b3] + | | +- [BytePrefix, table: 0, index: 157, offset: 0x1b4] -> [num value; dec: 0, hex: 0x0] + | | +- [NamePath, table: 0, index: 158, offset: 0x1b6] -> [namepath: "WFL4"] + | +- [If, table: 0, index: 159, offset: 0x1ba] + | | +- [LEqual, table: 0, index: 160, offset: 0x1bc] + | | | +- [Arg0, table: 0, index: 161, offset: 0x1bd] + | | | +- [BytePrefix, table: 0, index: 162, offset: 0x1be] -> [num value; dec: 4, hex: 0x4] + | | +- [Return, table: 0, index: 163, offset: 0x1c0] + | | +- [NamePath, table: 0, index: 164, offset: 0x1c1] -> [namepath: "WFL4"] + | +- [CreateField, table: 0, index: 165, offset: 0x1c5] + | | +- [Arg0, table: 0, index: 166, offset: 0x1c7] + | | +- [BytePrefix, table: 0, index: 167, offset: 0x1c8] -> [num value; dec: 0, hex: 0x0] + | | +- [BytePrefix, table: 0, index: 168, offset: 0x1ca] -> [num value; dec: 13, hex: 0xd] + | | +- [NamePath, table: 0, index: 169, offset: 0x1cc] -> [namepath: "WFL5"] + | +- [If, table: 0, index: 170, offset: 0x1d0] + | | +- [LEqual, table: 0, index: 171, offset: 0x1d2] + | | | +- [Arg0, table: 0, index: 172, offset: 0x1d3] + | | | +- [BytePrefix, table: 0, index: 173, offset: 0x1d4] -> [num value; dec: 5, hex: 0x5] + | | +- [Return, table: 0, index: 174, offset: 0x1d6] + | | +- [NamePath, table: 0, index: 175, offset: 0x1d7] -> [namepath: "WFL5"] + | +- [Store, table: 0, index: 176, offset: 0x1db] + | | +- [LoadTable, table: 0, index: 177, offset: 0x1dc] + | | | +- [StringPrefix, table: 0, index: 178, offset: 0x1de] -> [string value: "OEM1"] + | | | +- [StringPrefix, table: 0, index: 179, offset: 0x1e4] -> [string value: "MYOEM"] + | | | +- [StringPrefix, table: 0, index: 180, offset: 0x1eb] -> [string value: "TABLE1"] + | | | +- [StringPrefix, table: 0, index: 181, offset: 0x1f3] -> [string value: "\_SB.PCI0"] + | | | +- [StringPrefix, table: 0, index: 182, offset: 0x1fe] -> [string value: "MYD"] + | | | +- [Package, table: 0, index: 183, offset: 0x203] + | | | | +- [BytePrefix, table: 0, index: 184, offset: 0x205] -> [num value; dec: 2, hex: 0x2] + | | | | +- [ScopeBlock, table: 0, index: 185, offset: 0x206] + | | | | +- [BytePrefix, table: 0, index: 186, offset: 0x206] -> [num value; dec: 0, hex: 0x0] + | | | | +- [StringPrefix, table: 0, index: 187, offset: 0x208] -> [string value: "\_SB.PCI0"] + | | | +- [Local0, table: 0, index: 188, offset: 0x213] + | | +- [Store, table: 0, index: 189, offset: 0x214] + | | +- [BytePrefix, table: 0, index: 190, offset: 0x215] -> [num value; dec: 255, hex: 0xff] + | | +- [Local0, table: 0, index: 191, offset: 0x217] + | +- [Store, table: 0, index: 192, offset: 0x218] + | | +- [WordPrefix, table: 0, index: 193, offset: 0x219] -> [num value; dec: 65535, hex: 0xffff] + | | +- [Local0, table: 0, index: 194, offset: 0x21c] + | +- [Store, table: 0, index: 195, offset: 0x21d] + | | +- [DwordPrefix, table: 0, index: 196, offset: 0x21e] -> [num value; dec: 4294967295, hex: 0xffffffff] + | | +- [Local0, table: 0, index: 197, offset: 0x223] + | +- [Store, table: 0, index: 198, offset: 0x224] + | | +- [QwordPrefix, table: 0, index: 199, offset: 0x225] -> [num value; dec: 18446744073709551615, hex: 0xffffffffffffffff] + | | +- [Local0, table: 0, index: 200, offset: 0x22e] + | +- [Store, table: 0, index: 201, offset: 0x22f] + | | +- [Zero, table: 0, index: 202, offset: 0x230] + | | +- [Local0, table: 0, index: 203, offset: 0x231] + | +- [Store, table: 0, index: 204, offset: 0x232] + | | +- [One, table: 0, index: 205, offset: 0x233] + | | +- [Local0, table: 0, index: 206, offset: 0x234] + | +- [Store, table: 0, index: 207, offset: 0x235] + | | +- [Ones, table: 0, index: 208, offset: 0x236] + | | +- [Local0, table: 0, index: 209, offset: 0x237] + | +- [Store, table: 0, index: 210, offset: 0x238] + | | +- [StringPrefix, table: 0, index: 211, offset: 0x239] -> [string value: "FOO"] + | | +- [Local0, table: 0, index: 212, offset: 0x23e] + | +- [FromBCD, table: 0, index: 213, offset: 0x23f] + | | +- [BytePrefix, table: 0, index: 214, offset: 0x241] -> [num value; dec: 9, hex: 0x9] + | | +- [Arg0, table: 0, index: 215, offset: 0x243] + | +- [ToBCD, table: 0, index: 216, offset: 0x244] + | | +- [Arg0, table: 0, index: 217, offset: 0x246] + | | +- [Local1, table: 0, index: 218, offset: 0x247] + | +- [BreakPoint, table: 0, index: 219, offset: 0x248] + | +- [Store, table: 0, index: 220, offset: 0x249] + | | +- [StringPrefix, table: 0, index: 221, offset: 0x24a] -> [string value: "test"] + | | +- [Debug, table: 0, index: 222, offset: 0x250] + | +- [Fatal, table: 0, index: 223, offset: 0x252] + | | +- [BytePrefix, table: 0, index: 224, offset: 0x254] -> [num value; dec: 240, hex: 0xf0] + | | +- [DwordPrefix, table: 0, index: 225, offset: 0x255] -> [num value; dec: 3735929054, hex: 0xdeadc0de] + | | +- [BytePrefix, table: 0, index: 226, offset: 0x259] -> [num value; dec: 1, hex: 0x1] + | +- [Acquire, table: 0, index: 227, offset: 0x25b] + | | +- [NamePath, table: 0, index: 228, offset: 0x25d] -> [namepath: "MUT0"] + | | +- [WordPrefix, table: 0, index: 229, offset: 0x261] -> [num value; dec: 65535, hex: 0xffff] + | +- [Release, table: 0, index: 230, offset: 0x263] + | | +- [NamePath, table: 0, index: 231, offset: 0x265] -> [namepath: "MUT0"] + | +- [Reset, table: 0, index: 232, offset: 0x269] + | | +- [NamePath, table: 0, index: 233, offset: 0x26b] -> [namepath: "HLO0"] + | +- [Wait, table: 0, index: 234, offset: 0x26f] + | | +- [NamePath, table: 0, index: 235, offset: 0x271] -> [namepath: "HLO0"] + | | +- [WordPrefix, table: 0, index: 236, offset: 0x275] -> [num value; dec: 65535, hex: 0xffff] + | +- [Store, table: 0, index: 237, offset: 0x278] + | | +- [Timer, table: 0, index: 238, offset: 0x279] + | | +- [Local0, table: 0, index: 239, offset: 0x27b] + | +- [CopyObject, table: 0, index: 240, offset: 0x27c] + | | +- [Local0, table: 0, index: 241, offset: 0x27d] + | | +- [Local1, table: 0, index: 242, offset: 0x27e] + | +- [Return, table: 0, index: 243, offset: 0x27f] + | +- [ObjectType, table: 0, index: 244, offset: 0x280] + | +- [Local1, table: 0, index: 245, offset: 0x281] + +- [OpRegion, name: "GIO0", table: 0, index: 246, offset: 0x282] + | +- [NamePath, table: 0, index: 247, offset: 0x284] -> [namepath: "GIO0"] + | +- [BytePrefix, table: 0, index: 248, offset: 0x288] -> [num value; dec: 1, hex: 0x1] + | +- [WordPrefix, table: 0, index: 249, offset: 0x289] -> [num value; dec: 293, hex: 0x125] + | +- [WordPrefix, table: 0, index: 250, offset: 0x28c] -> [num value; dec: 256, hex: 0x100] + +- [Field, table: 0, index: 251, offset: 0x28f] + | +- [NamePath, table: 0, index: 252, offset: 0x292] -> [namepath: "GIO0"] + | +- [BytePrefix, table: 0, index: 253, offset: 0x296] -> [num value; dec: 1, hex: 0x1] + +- [NamedField, name: "GLB1", table: 0, index: 254, offset: 0x297] -> [field index: 251, offset(bytes): 0x0, width(bits): 0x1, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "GLB2", table: 0, index: 255, offset: 0x29c] -> [field index: 251, offset(bytes): 0x1, width(bits): 0x1, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "BNK1", table: 0, index: 256, offset: 0x2a3] -> [field index: 251, offset(bytes): 0x8, width(bits): 0x4, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [BankField, table: 0, index: 257, offset: 0x2a8] + | +- [NamePath, table: 0, index: 328, offset: 0x2ab] -> [namepath: "GIO0"] + | +- [NamePath, table: 0, index: 329, offset: 0x2af] -> [namepath: "BNK1"] + | +- [BytePrefix, table: 0, index: 330, offset: 0x2b3] -> [num value; dec: 0, hex: 0x0] + | +- [BytePrefix, table: 0, index: 331, offset: 0x2b5] -> [num value; dec: 49, hex: 0x31] + +- [NamedField, name: "FET0", table: 0, index: 332, offset: 0x2b9] -> [field index: 257, offset(bytes): 0x180, width(bits): 0x1, accType: Byte, lockType: Lock, updateType: WriteAsOnes, connection: -] + +- [NamedField, name: "FET1", table: 0, index: 333, offset: 0x2be] -> [field index: 257, offset(bytes): 0x181, width(bits): 0x1, accType: Byte, lockType: Lock, updateType: WriteAsOnes, connection: -] + +- [OpRegion, name: "SMBD", table: 0, index: 258, offset: 0x2c3] + | +- [NamePath, table: 0, index: 259, offset: 0x2c5] -> [namepath: "SMBD"] + | +- [BytePrefix, table: 0, index: 260, offset: 0x2c9] -> [num value; dec: 4, hex: 0x4] + | +- [WordPrefix, table: 0, index: 261, offset: 0x2ca] -> [num value; dec: 16896, hex: 0x4200] + | +- [WordPrefix, table: 0, index: 262, offset: 0x2cd] -> [num value; dec: 256, hex: 0x100] + +- [Field, table: 0, index: 263, offset: 0x2d0] + | +- [NamePath, table: 0, index: 264, offset: 0x2d4] -> [namepath: "SMBD"] + | +- [BytePrefix, table: 0, index: 265, offset: 0x2d8] -> [num value; dec: 69, hex: 0x45] + +- [NamedField, name: "SFL0", table: 0, index: 266, offset: 0x2dc] -> [field index: 263, offset(bytes): 0x0, width(bits): 0x8, accType: Buffer, accAttr: Byte, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL1", table: 0, index: 267, offset: 0x2e4] -> [field index: 263, offset(bytes): 0x8, width(bits): 0x8, accType: Buffer, accAttr: Word, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL2", table: 0, index: 268, offset: 0x2ec] -> [field index: 263, offset(bytes): 0x10, width(bits): 0x8, accType: Buffer, accAttr: Block, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL3", table: 0, index: 269, offset: 0x2f4] -> [field index: 263, offset(bytes): 0x18, width(bits): 0x8, accType: Buffer, accAttr: Quick, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL4", table: 0, index: 270, offset: 0x2fc] -> [field index: 263, offset(bytes): 0x20, width(bits): 0x8, accType: Buffer, accAttr: SendReceive, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL5", table: 0, index: 271, offset: 0x304] -> [field index: 263, offset(bytes): 0x28, width(bits): 0x8, accType: Buffer, accAttr: ProcessCall, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL6", table: 0, index: 272, offset: 0x30c] -> [field index: 263, offset(bytes): 0x30, width(bits): 0x8, accType: Buffer, accAttr: BlockProcessCall, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL7", table: 0, index: 273, offset: 0x315] -> [field index: 263, offset(bytes): 0x38, width(bits): 0x8, accType: Buffer, accAttr: Bytes(0x12), lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL8", table: 0, index: 274, offset: 0x31e] -> [field index: 263, offset(bytes): 0x40, width(bits): 0x8, accType: Buffer, accAttr: RawBytes(0x13), lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL9", table: 0, index: 275, offset: 0x327] -> [field index: 263, offset(bytes): 0x48, width(bits): 0x8, accType: Buffer, accAttr: RawProcessBytes(0x14), lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SF10", table: 0, index: 276, offset: 0x32f] -> [field index: 263, offset(bytes): 0x50, width(bits): 0x8, accType: Any, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SF11", table: 0, index: 277, offset: 0x337] -> [field index: 263, offset(bytes): 0x58, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SF12", table: 0, index: 278, offset: 0x33f] -> [field index: 263, offset(bytes): 0x60, width(bits): 0x8, accType: Word, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SF13", table: 0, index: 279, offset: 0x347] -> [field index: 263, offset(bytes): 0x68, width(bits): 0x8, accType: Dword, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SF14", table: 0, index: 280, offset: 0x34f] -> [field index: 263, offset(bytes): 0x70, width(bits): 0x8, accType: Qword, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [DataRegion, name: "REG0", table: 0, index: 281, offset: 0x354] + | +- [NamePath, table: 0, index: 282, offset: 0x356] -> [namepath: "REG0"] + | +- [StringPrefix, table: 0, index: 283, offset: 0x35a] -> [string value: "FOOF"] + | +- [StringPrefix, table: 0, index: 284, offset: 0x360] -> [string value: "BAR"] + | +- [StringPrefix, table: 0, index: 285, offset: 0x365] -> [string value: "BAZ"] + +- [Processor, name: "CPU0", table: 0, index: 286, offset: 0x36a] + | +- [NamePath, table: 0, index: 287, offset: 0x36d] -> [namepath: "CPU0"] + | +- [BytePrefix, table: 0, index: 288, offset: 0x371] -> [num value; dec: 1, hex: 0x1] + | +- [DwordPrefix, table: 0, index: 289, offset: 0x372] -> [num value; dec: 288, hex: 0x120] + | +- [BytePrefix, table: 0, index: 290, offset: 0x376] -> [num value; dec: 6, hex: 0x6] + | +- [ScopeBlock, table: 0, index: 291, offset: 0x377] + +- [PowerRes, name: "PWR0", table: 0, index: 292, offset: 0x377] + | +- [NamePath, table: 0, index: 293, offset: 0x37a] -> [namepath: "PWR0"] + | +- [BytePrefix, table: 0, index: 294, offset: 0x37e] -> [num value; dec: 0, hex: 0x0] + | +- [WordPrefix, table: 0, index: 295, offset: 0x37f] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 0, index: 296, offset: 0x381] + +- [ThermalZone, name: "TZ0_", table: 0, index: 297, offset: 0x381] + | +- [NamePath, table: 0, index: 298, offset: 0x384] -> [namepath: "TZ0_"] + | +- [ScopeBlock, table: 0, index: 299, offset: 0x388] + +- [Method, name: "FLOW", argCount: 2, table: 0, index: 300, offset: 0x388] + | +- [NamePath, table: 0, index: 301, offset: 0x38a] -> [namepath: "FLOW"] + | +- [BytePrefix, table: 0, index: 302, offset: 0x38e] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 303, offset: 0x38f] + | +- [While, table: 0, index: 304, offset: 0x38f] + | | +- [LLess, table: 0, index: 334, offset: 0x391] + | | | +- [Arg0, table: 0, index: 335, offset: 0x392] + | | | +- [Arg1, table: 0, index: 336, offset: 0x393] + | | +- [ScopeBlock, table: 0, index: 337, offset: 0x394] + | | +- [Increment, table: 0, index: 338, offset: 0x394] + | | | +- [Arg0, table: 0, index: 339, offset: 0x395] + | | +- [If, table: 0, index: 340, offset: 0x396] + | | +- [LLess, table: 0, index: 341, offset: 0x398] + | | | +- [Arg0, table: 0, index: 342, offset: 0x399] + | | | +- [BytePrefix, table: 0, index: 343, offset: 0x39a] -> [num value; dec: 5, hex: 0x5] + | | +- [ScopeBlock, table: 0, index: 344, offset: 0x39c] + | | +- [Continue, table: 0, index: 345, offset: 0x39c] + | +- [Return, table: 0, index: 305, offset: 0x3ad] + | +- [Arg0, table: 0, index: 306, offset: 0x3ae] + +- [ThermalZone, name: "THRM", table: 0, index: 310, offset: 0x3b6] + +- [NamePath, table: 0, index: 311, offset: 0x3b9] -> [namepath: "THRM"] + +- [ScopeBlock, table: 0, index: 312, offset: 0x3be] + +- [Name, name: "DEF0", table: 0, index: 313, offset: 0x3be] + | +- [NamePath, table: 0, index: 314, offset: 0x3bf] -> [namepath: "DEF0"] + | +- [Ones, table: 0, index: 315, offset: 0x3c3] + +- [Method, name: "MTH0", argCount: 0, table: 0, index: 322, offset: 0x3d1] + | +- [NamePath, table: 0, index: 323, offset: 0x3d3] -> [namepath: "MTH0"] + | +- [BytePrefix, table: 0, index: 324, offset: 0x3dd] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 0, index: 325, offset: 0x3de] + | +- [Return, table: 0, index: 326, offset: 0x3de] + | +- [BytePrefix, table: 0, index: 327, offset: 0x3df] -> [num value; dec: 1, hex: 0x1] + +- [Name, name: "DEF1", table: 0, index: 319, offset: 0x3cb] + +- [NamePath, table: 0, index: 320, offset: 0x3cc] -> [namepath: "DEF1"] + +- [Zero, table: 0, index: 321, offset: 0x3d0]